{"version":3,"sources":["webpack:///./node_modules/react-syntax-highlighter/node_modules/highlight.js/lib/languages/typescript.js"],"names":["IDENT_RE","KEYWORDS","LITERALS","BUILT_INS","concat","source","re","lookahead","optional","_len","arguments","length","args","Array","_key","joined","map","x","join","module","exports","hljs","KEYWORDS$1","$pattern","keyword","literal","built_in","DECORATOR","className","begin","swapMode","mode","label","replacement","indx","contains","findIndex","m","Error","splice","tsLanguage","IDENT_RE$1","FRAGMENT","XML_TAG","end","isTrulyOpeningTag","match","response","afterMatchIndex","index","nextChar","input","_ref","after","tag","replace","indexOf","hasClosingTag","ignoreMatch","nonDecimalLiterals","prefixLetters","validChars","noLeadingZeroDecimalDigits","decimalDigits","exponentPart","NUMBER","variants","relevance","SUBST","keywords","HTML_TEMPLATE","starts","returnEnd","BACKSLASH_ESCAPE","subLanguage","CSS_TEMPLATE","TEMPLATE_STRING","COMMENT","endsParent","C_BLOCK_COMMENT_MODE","C_LINE_COMMENT_MODE","SUBST_INTERNALS","APOS_STRING_MODE","QUOTE_STRING_MODE","REGEXP_MODE","SUBST_AND_COMMENTS","PARAMS_CONTAINS","PARAMS","excludeBegin","excludeEnd","name","aliases","illegal","SHEBANG","binary","RE_STARTERS_RE","UNDERSCORE_IDENT_RE","returnBegin","skip","beginKeywords","inherit","TITLE_MODE","UNDERSCORE_TITLE_MODE","javascript","Object","assign","push","find"],"mappings":"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","file":"react-syntax-highlighter_languages_highlight_typescript-5c89c4f8f0033958cb69.js","sourcesContent":["var IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';\nvar KEYWORDS = [\"as\", // for exports\n\"in\", \"of\", \"if\", \"for\", \"while\", \"finally\", \"var\", \"new\", \"function\", \"do\", \"return\", \"void\", \"else\", \"break\", \"catch\", \"instanceof\", \"with\", \"throw\", \"case\", \"default\", \"try\", \"switch\", \"continue\", \"typeof\", \"delete\", \"let\", \"yield\", \"const\", \"class\", // JS handles these with a special rule\n// \"get\",\n// \"set\",\n\"debugger\", \"async\", \"await\", \"static\", \"import\", \"from\", \"export\", \"extends\"];\nvar LITERALS = [\"true\", \"false\", \"null\", \"undefined\", \"NaN\", \"Infinity\"];\nvar TYPES = [\"Intl\", \"DataView\", \"Number\", \"Math\", \"Date\", \"String\", \"RegExp\", \"Object\", \"Function\", \"Boolean\", \"Error\", \"Symbol\", \"Set\", \"Map\", \"WeakSet\", \"WeakMap\", \"Proxy\", \"Reflect\", \"JSON\", \"Promise\", \"Float64Array\", \"Int16Array\", \"Int32Array\", \"Int8Array\", \"Uint16Array\", \"Uint32Array\", \"Float32Array\", \"Array\", \"Uint8Array\", \"Uint8ClampedArray\", \"ArrayBuffer\"];\nvar ERROR_TYPES = [\"EvalError\", \"InternalError\", \"RangeError\", \"ReferenceError\", \"SyntaxError\", \"TypeError\", \"URIError\"];\nvar BUILT_IN_GLOBALS = [\"setInterval\", \"setTimeout\", \"clearInterval\", \"clearTimeout\", \"require\", \"exports\", \"eval\", \"isFinite\", \"isNaN\", \"parseFloat\", \"parseInt\", \"decodeURI\", \"decodeURIComponent\", \"encodeURI\", \"encodeURIComponent\", \"escape\", \"unescape\"];\nvar BUILT_IN_VARIABLES = [\"arguments\", \"this\", \"super\", \"console\", \"window\", \"document\", \"localStorage\", \"module\", \"global\" // Node.js\n];\nvar BUILT_INS = [].concat(BUILT_IN_GLOBALS, BUILT_IN_VARIABLES, TYPES, ERROR_TYPES);\n/**\n * @param {string} value\n * @returns {RegExp}\n * */\n\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\n\nfunction source(re) {\n  if (!re) return null;\n  if (typeof re === \"string\") return re;\n  return re.source;\n}\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\n\n\nfunction lookahead(re) {\n  return concat('(?=', re, ')');\n}\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\n\n\nfunction optional(re) {\n  return concat('(', re, ')?');\n}\n/**\n * @param {...(RegExp | string) } args\n * @returns {string}\n */\n\n\nfunction concat() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  var joined = args.map(function (x) {\n    return source(x);\n  }).join(\"\");\n  return joined;\n}\n/*\nLanguage: JavaScript\nDescription: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions.\nCategory: common, scripting\nWebsite: https://developer.mozilla.org/en-US/docs/Web/JavaScript\n*/\n\n/** @type LanguageFn */\n\n\nfunction javascript(hljs) {\n  /**\n   * Takes a string like \"<Booger\" and checks to see\n   * if we can find a matching \"</Booger\" later in the\n   * content.\n   * @param {RegExpMatchArray} match\n   * @param {{after:number}} param1\n   */\n  var hasClosingTag = function hasClosingTag(match, _ref) {\n    var after = _ref.after;\n    var tag = match[0].replace(\"<\", \"</\");\n    var pos = match.input.indexOf(tag, after);\n    return pos !== -1;\n  };\n\n  var IDENT_RE$1 = IDENT_RE;\n  var FRAGMENT = {\n    begin: '<>',\n    end: '</>'\n  };\n  var XML_TAG = {\n    begin: /<[A-Za-z0-9\\\\._:-]+/,\n    end: /\\/[A-Za-z0-9\\\\._:-]+>|\\/>/,\n\n    /**\n     * @param {RegExpMatchArray} match\n     * @param {CallbackResponse} response\n     */\n    isTrulyOpeningTag: function isTrulyOpeningTag(match, response) {\n      var afterMatchIndex = match[0].length + match.index;\n      var nextChar = match.input[afterMatchIndex]; // nested type?\n      // HTML should not include another raw `<` inside a tag\n      // But a type might: `<Array<Array<number>>`, etc.\n\n      if (nextChar === \"<\") {\n        response.ignoreMatch();\n        return;\n      } // <something>\n      // This is now either a tag or a type.\n\n\n      if (nextChar === \">\") {\n        // if we cannot find a matching closing tag, then we\n        // will ignore it\n        if (!hasClosingTag(match, {\n          after: afterMatchIndex\n        })) {\n          response.ignoreMatch();\n        }\n      }\n    }\n  };\n  var KEYWORDS$1 = {\n    $pattern: IDENT_RE,\n    keyword: KEYWORDS.join(\" \"),\n    literal: LITERALS.join(\" \"),\n    built_in: BUILT_INS.join(\" \")\n  };\n\n  var nonDecimalLiterals = function nonDecimalLiterals(prefixLetters, validChars) {\n    return \"\\\\b0[\".concat(prefixLetters, \"][\").concat(validChars, \"]([\").concat(validChars, \"_]*[\").concat(validChars, \"])?n?\");\n  };\n\n  var noLeadingZeroDecimalDigits = /[1-9]([0-9_]*\\d)?/;\n  var decimalDigits = /\\d([0-9_]*\\d)?/;\n  var exponentPart = concat(/[eE][+-]?/, decimalDigits);\n  var NUMBER = {\n    className: 'number',\n    variants: [{\n      begin: nonDecimalLiterals('bB', '01')\n    }, // Binary literals\n    {\n      begin: nonDecimalLiterals('oO', '0-7')\n    }, // Octal literals\n    {\n      begin: nonDecimalLiterals('xX', '0-9a-fA-F')\n    }, // Hexadecimal literals\n    {\n      begin: concat(/\\b/, noLeadingZeroDecimalDigits, 'n')\n    }, // Non-zero BigInt literals\n    {\n      begin: concat(/(\\b0)?\\./, decimalDigits, optional(exponentPart))\n    }, // Decimal literals between 0 and 1\n    {\n      begin: concat(/\\b/, noLeadingZeroDecimalDigits, optional(concat(/\\./, optional(decimalDigits))), // fractional part\n      optional(exponentPart))\n    }, // Decimal literals >= 1\n    {\n      begin: /\\b0[\\.n]?/\n    } // Zero literals (`0`, `0.`, `0n`)\n    ],\n    relevance: 0\n  };\n  var SUBST = {\n    className: 'subst',\n    begin: '\\\\$\\\\{',\n    end: '\\\\}',\n    keywords: KEYWORDS$1,\n    contains: [] // defined later\n\n  };\n  var HTML_TEMPLATE = {\n    begin: 'html`',\n    end: '',\n    starts: {\n      end: '`',\n      returnEnd: false,\n      contains: [hljs.BACKSLASH_ESCAPE, SUBST],\n      subLanguage: 'xml'\n    }\n  };\n  var CSS_TEMPLATE = {\n    begin: 'css`',\n    end: '',\n    starts: {\n      end: '`',\n      returnEnd: false,\n      contains: [hljs.BACKSLASH_ESCAPE, SUBST],\n      subLanguage: 'css'\n    }\n  };\n  var TEMPLATE_STRING = {\n    className: 'string',\n    begin: '`',\n    end: '`',\n    contains: [hljs.BACKSLASH_ESCAPE, SUBST]\n  };\n  var JSDOC_COMMENT = hljs.COMMENT('/\\\\*\\\\*', '\\\\*/', {\n    relevance: 0,\n    contains: [{\n      className: 'doctag',\n      begin: '@[A-Za-z]+',\n      contains: [{\n        className: 'type',\n        begin: '\\\\{',\n        end: '\\\\}',\n        relevance: 0\n      }, {\n        className: 'variable',\n        begin: IDENT_RE$1 + '(?=\\\\s*(-)|$)',\n        endsParent: true,\n        relevance: 0\n      }, // eat spaces (not newlines) so we can find\n      // types or variables\n      {\n        begin: /(?=[^\\n])\\s/,\n        relevance: 0\n      }]\n    }]\n  });\n  var COMMENT = {\n    className: \"comment\",\n    variants: [JSDOC_COMMENT, hljs.C_BLOCK_COMMENT_MODE, hljs.C_LINE_COMMENT_MODE]\n  };\n  var SUBST_INTERNALS = [hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE, HTML_TEMPLATE, CSS_TEMPLATE, TEMPLATE_STRING, NUMBER, hljs.REGEXP_MODE];\n  SUBST.contains = SUBST_INTERNALS.concat({\n    // we need to pair up {} inside our subst to prevent\n    // it from ending too early by matching another }\n    begin: /{/,\n    end: /}/,\n    keywords: KEYWORDS$1,\n    contains: [\"self\"].concat(SUBST_INTERNALS)\n  });\n  var SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);\n  var PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([// eat recursive parens in sub expressions\n  {\n    begin: /\\(/,\n    end: /\\)/,\n    keywords: KEYWORDS$1,\n    contains: [\"self\"].concat(SUBST_AND_COMMENTS)\n  }]);\n  var PARAMS = {\n    className: 'params',\n    begin: /\\(/,\n    end: /\\)/,\n    excludeBegin: true,\n    excludeEnd: true,\n    keywords: KEYWORDS$1,\n    contains: PARAMS_CONTAINS\n  };\n  return {\n    name: 'Javascript',\n    aliases: ['js', 'jsx', 'mjs', 'cjs'],\n    keywords: KEYWORDS$1,\n    // this will be extended by TypeScript\n    exports: {\n      PARAMS_CONTAINS: PARAMS_CONTAINS\n    },\n    illegal: /#(?![$_A-z])/,\n    contains: [hljs.SHEBANG({\n      label: \"shebang\",\n      binary: \"node\",\n      relevance: 5\n    }), {\n      label: \"use_strict\",\n      className: 'meta',\n      relevance: 10,\n      begin: /^\\s*['\"]use (strict|asm)['\"]/\n    }, hljs.APOS_STRING_MODE, hljs.QUOTE_STRING_MODE, HTML_TEMPLATE, CSS_TEMPLATE, TEMPLATE_STRING, COMMENT, NUMBER, {\n      // object attr container\n      begin: concat(/[{,\\n]\\s*/, // we need to look ahead to make sure that we actually have an\n      // attribute coming up so we don't steal a comma from a potential\n      // \"value\" container\n      //\n      // NOTE: this might not work how you think.  We don't actually always\n      // enter this mode and stay.  Instead it might merely match `,\n      // <comments up next>` and then immediately end after the , because it\n      // fails to find any actual attrs. But this still does the job because\n      // it prevents the value contain rule from grabbing this instead and\n      // prevening this rule from firing when we actually DO have keys.\n      lookahead(concat( // we also need to allow for multiple possible comments inbetween\n      // the first key:value pairing\n      /(\\/\\/.*$)*/, /(\\/\\*(.|\\n)*\\*\\/)*/, /\\s*/, IDENT_RE$1 + '\\\\s*:'))),\n      relevance: 0,\n      contains: [{\n        className: 'attr',\n        begin: IDENT_RE$1 + lookahead('\\\\s*:'),\n        relevance: 0\n      }]\n    }, {\n      // \"value\" container\n      begin: '(' + hljs.RE_STARTERS_RE + '|\\\\b(case|return|throw)\\\\b)\\\\s*',\n      keywords: 'return throw case',\n      contains: [COMMENT, hljs.REGEXP_MODE, {\n        className: 'function',\n        // we have to count the parens to make sure we actually have the\n        // correct bounding ( ) before the =>.  There could be any number of\n        // sub-expressions inside also surrounded by parens.\n        begin: '(\\\\(' + '[^()]*(\\\\(' + '[^()]*(\\\\(' + '[^()]*' + '\\\\))*[^()]*' + '\\\\))*[^()]*' + '\\\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\\\s*=>',\n        returnBegin: true,\n        end: '\\\\s*=>',\n        contains: [{\n          className: 'params',\n          variants: [{\n            begin: hljs.UNDERSCORE_IDENT_RE\n          }, {\n            className: null,\n            begin: /\\(\\s*\\)/,\n            skip: true\n          }, {\n            begin: /\\(/,\n            end: /\\)/,\n            excludeBegin: true,\n            excludeEnd: true,\n            keywords: KEYWORDS$1,\n            contains: PARAMS_CONTAINS\n          }]\n        }]\n      }, {\n        // could be a comma delimited list of params to a function call\n        begin: /,/,\n        relevance: 0\n      }, {\n        className: '',\n        begin: /\\s/,\n        end: /\\s*/,\n        skip: true\n      }, {\n        // JSX\n        variants: [{\n          begin: FRAGMENT.begin,\n          end: FRAGMENT.end\n        }, {\n          begin: XML_TAG.begin,\n          // we carefully check the opening tag to see if it truly\n          // is a tag and not a false positive\n          'on:begin': XML_TAG.isTrulyOpeningTag,\n          end: XML_TAG.end\n        }],\n        subLanguage: 'xml',\n        contains: [{\n          begin: XML_TAG.begin,\n          end: XML_TAG.end,\n          skip: true,\n          contains: ['self']\n        }]\n      }],\n      relevance: 0\n    }, {\n      className: 'function',\n      beginKeywords: 'function',\n      end: /[{;]/,\n      excludeEnd: true,\n      keywords: KEYWORDS$1,\n      contains: ['self', hljs.inherit(hljs.TITLE_MODE, {\n        begin: IDENT_RE$1\n      }), PARAMS],\n      illegal: /%/\n    }, {\n      className: 'function',\n      // we have to count the parens to make sure we actually have the correct\n      // bounding ( ).  There could be any number of sub-expressions inside\n      // also surrounded by parens.\n      begin: hljs.UNDERSCORE_IDENT_RE + '\\\\(' + // first parens\n      '[^()]*(\\\\(' + '[^()]*(\\\\(' + '[^()]*' + '\\\\))*[^()]*' + '\\\\))*[^()]*' + '\\\\)\\\\s*{',\n      // end parens\n      returnBegin: true,\n      contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, {\n        begin: IDENT_RE$1\n      })]\n    }, // hack: prevents detection of keywords in some circumstances\n    // .keyword()\n    // $keyword = x\n    {\n      variants: [{\n        begin: '\\\\.' + IDENT_RE$1\n      }, {\n        begin: '\\\\$' + IDENT_RE$1\n      }],\n      relevance: 0\n    }, {\n      // ES6 class\n      className: 'class',\n      beginKeywords: 'class',\n      end: /[{;=]/,\n      excludeEnd: true,\n      illegal: /[:\"\\[\\]]/,\n      contains: [{\n        beginKeywords: 'extends'\n      }, hljs.UNDERSCORE_TITLE_MODE]\n    }, {\n      begin: /\\b(?=constructor)/,\n      end: /[\\{;]/,\n      excludeEnd: true,\n      contains: [hljs.inherit(hljs.TITLE_MODE, {\n        begin: IDENT_RE$1\n      }), 'self', PARAMS]\n    }, {\n      begin: '(get|set)\\\\s+(?=' + IDENT_RE$1 + '\\\\()',\n      end: /{/,\n      keywords: \"get set\",\n      contains: [hljs.inherit(hljs.TITLE_MODE, {\n        begin: IDENT_RE$1\n      }), {\n        begin: /\\(\\)/\n      }, // eat to avoid empty params\n      PARAMS]\n    }, {\n      begin: /\\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`\n\n    }]\n  };\n}\n/*\nLanguage: TypeScript\nAuthor: Panu Horsmalahti <panu.horsmalahti@iki.fi>\nContributors: Ike Ku <dempfi@yahoo.com>\nDescription: TypeScript is a strict superset of JavaScript\nWebsite: https://www.typescriptlang.org\nCategory: common, scripting\n*/\n\n/** @type LanguageFn */\n\n\nfunction typescript(hljs) {\n  var IDENT_RE$1 = IDENT_RE;\n  var NAMESPACE = {\n    beginKeywords: 'namespace',\n    end: /\\{/,\n    excludeEnd: true\n  };\n  var INTERFACE = {\n    beginKeywords: 'interface',\n    end: /\\{/,\n    excludeEnd: true,\n    keywords: 'interface extends'\n  };\n  var USE_STRICT = {\n    className: 'meta',\n    relevance: 10,\n    begin: /^\\s*['\"]use strict['\"]/\n  };\n  var TYPES = [\"any\", \"void\", \"number\", \"boolean\", \"string\", \"object\", \"never\", \"enum\"];\n  var TS_SPECIFIC_KEYWORDS = [\"type\", \"namespace\", \"typedef\", \"interface\", \"public\", \"private\", \"protected\", \"implements\", \"declare\", \"abstract\", \"readonly\"];\n  var KEYWORDS$1 = {\n    $pattern: IDENT_RE,\n    keyword: KEYWORDS.concat(TS_SPECIFIC_KEYWORDS).join(\" \"),\n    literal: LITERALS.join(\" \"),\n    built_in: BUILT_INS.concat(TYPES).join(\" \")\n  };\n  var DECORATOR = {\n    className: 'meta',\n    begin: '@' + IDENT_RE$1\n  };\n\n  var swapMode = function swapMode(mode, label, replacement) {\n    var indx = mode.contains.findIndex(function (m) {\n      return m.label === label;\n    });\n\n    if (indx === -1) {\n      throw new Error(\"can not find mode to replace\");\n    }\n\n    mode.contains.splice(indx, 1, replacement);\n  };\n\n  var tsLanguage = javascript(hljs); // this should update anywhere keywords is used since\n  // it will be the same actual JS object\n\n  Object.assign(tsLanguage.keywords, KEYWORDS$1);\n  tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);\n  tsLanguage.contains = tsLanguage.contains.concat([DECORATOR, NAMESPACE, INTERFACE]); // TS gets a simpler shebang rule than JS\n\n  swapMode(tsLanguage, \"shebang\", hljs.SHEBANG()); // JS use strict rule purposely excludes `asm` which makes no sense\n\n  swapMode(tsLanguage, \"use_strict\", USE_STRICT);\n  var functionDeclaration = tsLanguage.contains.find(function (m) {\n    return m.className === \"function\";\n  });\n  functionDeclaration.relevance = 0; // () => {} is more typical in TypeScript\n\n  Object.assign(tsLanguage, {\n    name: 'TypeScript',\n    aliases: ['ts']\n  });\n  return tsLanguage;\n}\n\nmodule.exports = typescript;"],"sourceRoot":""}