| exports.ids = ["vendors~react-syntax-highlighter_languages_highlight_javascript"]; |
| exports.modules = { |
| |
| /***/ "./node_modules/react-syntax-highlighter/node_modules/highlight.js/lib/languages/javascript.js": |
| /*!*****************************************************************************************************!*\ |
| !*** ./node_modules/react-syntax-highlighter/node_modules/highlight.js/lib/languages/javascript.js ***! |
| \*****************************************************************************************************/ |
| /*! no static exports found */ |
| /***/ (function(module, exports) { |
| |
| const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*'; |
| const KEYWORDS = [ |
| "as", // for exports |
| "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 |
| // "get", |
| // "set", |
| "debugger", |
| "async", |
| "await", |
| "static", |
| "import", |
| "from", |
| "export", |
| "extends" |
| ]; |
| const LITERALS = [ |
| "true", |
| "false", |
| "null", |
| "undefined", |
| "NaN", |
| "Infinity" |
| ]; |
| |
| const 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" |
| ]; |
| |
| const ERROR_TYPES = [ |
| "EvalError", |
| "InternalError", |
| "RangeError", |
| "ReferenceError", |
| "SyntaxError", |
| "TypeError", |
| "URIError" |
| ]; |
| |
| const BUILT_IN_GLOBALS = [ |
| "setInterval", |
| "setTimeout", |
| "clearInterval", |
| "clearTimeout", |
| |
| "require", |
| "exports", |
| |
| "eval", |
| "isFinite", |
| "isNaN", |
| "parseFloat", |
| "parseInt", |
| "decodeURI", |
| "decodeURIComponent", |
| "encodeURI", |
| "encodeURIComponent", |
| "escape", |
| "unescape" |
| ]; |
| |
| const BUILT_IN_VARIABLES = [ |
| "arguments", |
| "this", |
| "super", |
| "console", |
| "window", |
| "document", |
| "localStorage", |
| "module", |
| "global" // Node.js |
| ]; |
| |
| const BUILT_INS = [].concat( |
| BUILT_IN_GLOBALS, |
| BUILT_IN_VARIABLES, |
| TYPES, |
| ERROR_TYPES |
| ); |
| |
| /** |
| * @param {string} value |
| * @returns {RegExp} |
| * */ |
| |
| /** |
| * @param {RegExp | string } re |
| * @returns {string} |
| */ |
| function source(re) { |
| if (!re) return null; |
| if (typeof re === "string") return re; |
| |
| return re.source; |
| } |
| |
| /** |
| * @param {RegExp | string } re |
| * @returns {string} |
| */ |
| function lookahead(re) { |
| return concat('(?=', re, ')'); |
| } |
| |
| /** |
| * @param {RegExp | string } re |
| * @returns {string} |
| */ |
| function optional(re) { |
| return concat('(', re, ')?'); |
| } |
| |
| /** |
| * @param {...(RegExp | string) } args |
| * @returns {string} |
| */ |
| function concat(...args) { |
| const joined = args.map((x) => source(x)).join(""); |
| return joined; |
| } |
| |
| /* |
| Language: JavaScript |
| Description: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions. |
| Category: common, scripting |
| Website: https://developer.mozilla.org/en-US/docs/Web/JavaScript |
| */ |
| |
| /** @type LanguageFn */ |
| function javascript(hljs) { |
| /** |
| * Takes a string like "<Booger" and checks to see |
| * if we can find a matching "</Booger" later in the |
| * content. |
| * @param {RegExpMatchArray} match |
| * @param {{after:number}} param1 |
| */ |
| const hasClosingTag = (match, { after }) => { |
| const tag = match[0].replace("<", "</"); |
| const pos = match.input.indexOf(tag, after); |
| return pos !== -1; |
| }; |
| |
| const IDENT_RE$1 = IDENT_RE; |
| const FRAGMENT = { |
| begin: '<>', |
| end: '</>' |
| }; |
| const XML_TAG = { |
| begin: /<[A-Za-z0-9\\._:-]+/, |
| end: /\/[A-Za-z0-9\\._:-]+>|\/>/, |
| /** |
| * @param {RegExpMatchArray} match |
| * @param {CallbackResponse} response |
| */ |
| isTrulyOpeningTag: (match, response) => { |
| const afterMatchIndex = match[0].length + match.index; |
| const nextChar = match.input[afterMatchIndex]; |
| // nested type? |
| // HTML should not include another raw `<` inside a tag |
| // But a type might: `<Array<Array<number>>`, etc. |
| if (nextChar === "<") { |
| response.ignoreMatch(); |
| return; |
| } |
| // <something> |
| // This is now either a tag or a type. |
| if (nextChar === ">") { |
| // if we cannot find a matching closing tag, then we |
| // will ignore it |
| if (!hasClosingTag(match, { after: afterMatchIndex })) { |
| response.ignoreMatch(); |
| } |
| } |
| } |
| }; |
| const KEYWORDS$1 = { |
| $pattern: IDENT_RE, |
| keyword: KEYWORDS.join(" "), |
| literal: LITERALS.join(" "), |
| built_in: BUILT_INS.join(" ") |
| }; |
| const nonDecimalLiterals = (prefixLetters, validChars) => |
| `\\b0[${prefixLetters}][${validChars}]([${validChars}_]*[${validChars}])?n?`; |
| const noLeadingZeroDecimalDigits = /[1-9]([0-9_]*\d)?/; |
| const decimalDigits = /\d([0-9_]*\d)?/; |
| const exponentPart = concat(/[eE][+-]?/, decimalDigits); |
| const NUMBER = { |
| className: 'number', |
| variants: [ |
| { begin: nonDecimalLiterals('bB', '01') }, // Binary literals |
| { begin: nonDecimalLiterals('oO', '0-7') }, // Octal literals |
| { begin: nonDecimalLiterals('xX', '0-9a-fA-F') }, // Hexadecimal literals |
| { begin: concat(/\b/, noLeadingZeroDecimalDigits, 'n') }, // Non-zero BigInt literals |
| { begin: concat(/(\b0)?\./, decimalDigits, optional(exponentPart)) }, // Decimal literals between 0 and 1 |
| { begin: concat( |
| /\b/, |
| noLeadingZeroDecimalDigits, |
| optional(concat(/\./, optional(decimalDigits))), // fractional part |
| optional(exponentPart) |
| ) }, // Decimal literals >= 1 |
| { begin: /\b0[\.n]?/ }, // Zero literals (`0`, `0.`, `0n`) |
| ], |
| relevance: 0 |
| }; |
| const SUBST = { |
| className: 'subst', |
| begin: '\\$\\{', |
| end: '\\}', |
| keywords: KEYWORDS$1, |
| contains: [] // defined later |
| }; |
| const HTML_TEMPLATE = { |
| begin: 'html`', |
| end: '', |
| starts: { |
| end: '`', |
| returnEnd: false, |
| contains: [ |
| hljs.BACKSLASH_ESCAPE, |
| SUBST |
| ], |
| subLanguage: 'xml' |
| } |
| }; |
| const CSS_TEMPLATE = { |
| begin: 'css`', |
| end: '', |
| starts: { |
| end: '`', |
| returnEnd: false, |
| contains: [ |
| hljs.BACKSLASH_ESCAPE, |
| SUBST |
| ], |
| subLanguage: 'css' |
| } |
| }; |
| const TEMPLATE_STRING = { |
| className: 'string', |
| begin: '`', |
| end: '`', |
| contains: [ |
| hljs.BACKSLASH_ESCAPE, |
| SUBST |
| ] |
| }; |
| const JSDOC_COMMENT = hljs.COMMENT( |
| '/\\*\\*', |
| '\\*/', |
| { |
| relevance: 0, |
| contains: [ |
| { |
| className: 'doctag', |
| begin: '@[A-Za-z]+', |
| contains: [ |
| { |
| className: 'type', |
| begin: '\\{', |
| end: '\\}', |
| relevance: 0 |
| }, |
| { |
| className: 'variable', |
| begin: IDENT_RE$1 + '(?=\\s*(-)|$)', |
| endsParent: true, |
| relevance: 0 |
| }, |
| // eat spaces (not newlines) so we can find |
| // types or variables |
| { |
| begin: /(?=[^\n])\s/, |
| relevance: 0 |
| } |
| ] |
| } |
| ] |
| } |
| ); |
| const COMMENT = { |
| className: "comment", |
| variants: [ |
| JSDOC_COMMENT, |
| hljs.C_BLOCK_COMMENT_MODE, |
| hljs.C_LINE_COMMENT_MODE |
| ] |
| }; |
| const SUBST_INTERNALS = [ |
| hljs.APOS_STRING_MODE, |
| hljs.QUOTE_STRING_MODE, |
| HTML_TEMPLATE, |
| CSS_TEMPLATE, |
| TEMPLATE_STRING, |
| NUMBER, |
| hljs.REGEXP_MODE |
| ]; |
| SUBST.contains = SUBST_INTERNALS |
| .concat({ |
| // we need to pair up {} inside our subst to prevent |
| // it from ending too early by matching another } |
| begin: /{/, |
| end: /}/, |
| keywords: KEYWORDS$1, |
| contains: [ |
| "self" |
| ].concat(SUBST_INTERNALS) |
| }); |
| const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains); |
| const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([ |
| // eat recursive parens in sub expressions |
| { |
| begin: /\(/, |
| end: /\)/, |
| keywords: KEYWORDS$1, |
| contains: ["self"].concat(SUBST_AND_COMMENTS) |
| } |
| ]); |
| const PARAMS = { |
| className: 'params', |
| begin: /\(/, |
| end: /\)/, |
| excludeBegin: true, |
| excludeEnd: true, |
| keywords: KEYWORDS$1, |
| contains: PARAMS_CONTAINS |
| }; |
| |
| return { |
| name: 'Javascript', |
| aliases: ['js', 'jsx', 'mjs', 'cjs'], |
| keywords: KEYWORDS$1, |
| // this will be extended by TypeScript |
| exports: { PARAMS_CONTAINS }, |
| illegal: /#(?![$_A-z])/, |
| contains: [ |
| hljs.SHEBANG({ |
| label: "shebang", |
| binary: "node", |
| relevance: 5 |
| }), |
| { |
| label: "use_strict", |
| className: 'meta', |
| relevance: 10, |
| begin: /^\s*['"]use (strict|asm)['"]/ |
| }, |
| hljs.APOS_STRING_MODE, |
| hljs.QUOTE_STRING_MODE, |
| HTML_TEMPLATE, |
| CSS_TEMPLATE, |
| TEMPLATE_STRING, |
| COMMENT, |
| NUMBER, |
| { // object attr container |
| begin: concat(/[{,\n]\s*/, |
| // we need to look ahead to make sure that we actually have an |
| // attribute coming up so we don't steal a comma from a potential |
| // "value" container |
| // |
| // NOTE: this might not work how you think. We don't actually always |
| // enter this mode and stay. Instead it might merely match `, |
| // <comments up next>` and then immediately end after the , because it |
| // fails to find any actual attrs. But this still does the job because |
| // it prevents the value contain rule from grabbing this instead and |
| // prevening this rule from firing when we actually DO have keys. |
| lookahead(concat( |
| // we also need to allow for multiple possible comments inbetween |
| // the first key:value pairing |
| /(\/\/.*$)*/, |
| /(\/\*(.|\n)*\*\/)*/, |
| /\s*/, |
| IDENT_RE$1 + '\\s*:'))), |
| relevance: 0, |
| contains: [ |
| { |
| className: 'attr', |
| begin: IDENT_RE$1 + lookahead('\\s*:'), |
| relevance: 0 |
| } |
| ] |
| }, |
| { // "value" container |
| begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*', |
| keywords: 'return throw case', |
| contains: [ |
| COMMENT, |
| hljs.REGEXP_MODE, |
| { |
| className: 'function', |
| // we have to count the parens to make sure we actually have the |
| // correct bounding ( ) before the =>. There could be any number of |
| // sub-expressions inside also surrounded by parens. |
| begin: '(\\(' + |
| '[^()]*(\\(' + |
| '[^()]*(\\(' + |
| '[^()]*' + |
| '\\))*[^()]*' + |
| '\\))*[^()]*' + |
| '\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\s*=>', |
| returnBegin: true, |
| end: '\\s*=>', |
| contains: [ |
| { |
| className: 'params', |
| variants: [ |
| { |
| begin: hljs.UNDERSCORE_IDENT_RE |
| }, |
| { |
| className: null, |
| begin: /\(\s*\)/, |
| skip: true |
| }, |
| { |
| begin: /\(/, |
| end: /\)/, |
| excludeBegin: true, |
| excludeEnd: true, |
| keywords: KEYWORDS$1, |
| contains: PARAMS_CONTAINS |
| } |
| ] |
| } |
| ] |
| }, |
| { // could be a comma delimited list of params to a function call |
| begin: /,/, relevance: 0 |
| }, |
| { |
| className: '', |
| begin: /\s/, |
| end: /\s*/, |
| skip: true |
| }, |
| { // JSX |
| variants: [ |
| { begin: FRAGMENT.begin, end: FRAGMENT.end }, |
| { |
| begin: XML_TAG.begin, |
| // we carefully check the opening tag to see if it truly |
| // is a tag and not a false positive |
| 'on:begin': XML_TAG.isTrulyOpeningTag, |
| end: XML_TAG.end |
| } |
| ], |
| subLanguage: 'xml', |
| contains: [ |
| { |
| begin: XML_TAG.begin, |
| end: XML_TAG.end, |
| skip: true, |
| contains: ['self'] |
| } |
| ] |
| } |
| ], |
| relevance: 0 |
| }, |
| { |
| className: 'function', |
| beginKeywords: 'function', |
| end: /[{;]/, |
| excludeEnd: true, |
| keywords: KEYWORDS$1, |
| contains: [ |
| 'self', |
| hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }), |
| PARAMS |
| ], |
| illegal: /%/ |
| }, |
| { |
| className: 'function', |
| // we have to count the parens to make sure we actually have the correct |
| // bounding ( ). There could be any number of sub-expressions inside |
| // also surrounded by parens. |
| begin: hljs.UNDERSCORE_IDENT_RE + |
| '\\(' + // first parens |
| '[^()]*(\\(' + |
| '[^()]*(\\(' + |
| '[^()]*' + |
| '\\))*[^()]*' + |
| '\\))*[^()]*' + |
| '\\)\\s*{', // end parens |
| returnBegin:true, |
| contains: [ |
| PARAMS, |
| hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }), |
| ] |
| }, |
| // hack: prevents detection of keywords in some circumstances |
| // .keyword() |
| // $keyword = x |
| { |
| variants: [ |
| { begin: '\\.' + IDENT_RE$1 }, |
| { begin: '\\$' + IDENT_RE$1 } |
| ], |
| relevance: 0 |
| }, |
| { // ES6 class |
| className: 'class', |
| beginKeywords: 'class', |
| end: /[{;=]/, |
| excludeEnd: true, |
| illegal: /[:"\[\]]/, |
| contains: [ |
| { beginKeywords: 'extends' }, |
| hljs.UNDERSCORE_TITLE_MODE |
| ] |
| }, |
| { |
| begin: /\b(?=constructor)/, |
| end: /[\{;]/, |
| excludeEnd: true, |
| contains: [ |
| hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }), |
| 'self', |
| PARAMS |
| ] |
| }, |
| { |
| begin: '(get|set)\\s+(?=' + IDENT_RE$1 + '\\()', |
| end: /{/, |
| keywords: "get set", |
| contains: [ |
| hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }), |
| { begin: /\(\)/ }, // eat to avoid empty params |
| PARAMS |
| ] |
| }, |
| { |
| begin: /\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something` |
| } |
| ] |
| }; |
| } |
| |
| module.exports = javascript; |
| |
| |
| /***/ }) |
| |
| };; |
| //# sourceMappingURL=vendors~react-syntax-highlighter_languages_highlight_javascript.render-page.js.map |