An error occurred:
" + w(n.message + "", true) + ""; return t ? Promise.resolve(r) : r; } if (t) return Promise.reject(n); throw n; }; } }; var _ = new B(); function d(u3, e) { return _.parse(u3, e); } d.options = d.setOptions = function(u3) { return _.setOptions(u3), d.defaults = _.defaults, Z(d.defaults), d; }; d.getDefaults = L; d.defaults = T; d.use = function(...u3) { return _.use(...u3), d.defaults = _.defaults, Z(d.defaults), d; }; d.walkTokens = function(u3, e) { return _.walkTokens(u3, e); }; d.parseInline = _.parseInline; d.Parser = b; d.parser = b.parse; d.Renderer = P; d.TextRenderer = $; d.Lexer = x; d.lexer = x.lex; d.Tokenizer = y; d.Hooks = S; d.parse = d; d.options; d.setOptions; d.use; d.walkTokens; d.parseInline; b.parse; x.lex; function getDefaultExportFromCjs(x2) { return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2; } function deepFreeze(obj) { if (obj instanceof Map) { obj.clear = obj.delete = obj.set = function() { throw new Error("map is read-only"); }; } else if (obj instanceof Set) { obj.add = obj.clear = obj.delete = function() { throw new Error("set is read-only"); }; } Object.freeze(obj); Object.getOwnPropertyNames(obj).forEach((name) => { const prop = obj[name]; const type = typeof prop; if ((type === "object" || type === "function") && !Object.isFrozen(prop)) { deepFreeze(prop); } }); return obj; } class Response { /** * @param {CompiledMode} mode */ constructor(mode) { if (mode.data === void 0) mode.data = {}; this.data = mode.data; this.isMatchIgnored = false; } ignoreMatch() { this.isMatchIgnored = true; } } function escapeHTML(value) { return value.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'"); } function inherit$1(original, ...objects) { const result = /* @__PURE__ */ Object.create(null); for (const key in original) { result[key] = original[key]; } objects.forEach(function(obj) { for (const key in obj) { result[key] = obj[key]; } }); return ( /** @type {T} */ result ); } const SPAN_CLOSE = ""; const emitsWrappingTags = (node) => { return !!node.scope; }; const scopeToCSSClass = (name, { prefix }) => { if (name.startsWith("language:")) { return name.replace("language:", "language-"); } if (name.includes(".")) { const pieces = name.split("."); return [ `${prefix}${pieces.shift()}`, ...pieces.map((x2, i) => `${x2}${"_".repeat(i + 1)}`) ].join(" "); } return `${prefix}${name}`; }; class HTMLRenderer { /** * Creates a new HTMLRenderer * * @param {Tree} parseTree - the parse tree (must support `walk` API) * @param {{classPrefix: string}} options */ constructor(parseTree, options) { this.buffer = ""; this.classPrefix = options.classPrefix; parseTree.walk(this); } /** * Adds texts to the output stream * * @param {string} text */ addText(text) { this.buffer += escapeHTML(text); } /** * Adds a node open to the output stream (if needed) * * @param {Node} node */ openNode(node) { if (!emitsWrappingTags(node)) return; const className = scopeToCSSClass( node.scope, { prefix: this.classPrefix } ); this.span(className); } /** * Adds a node close to the output stream (if needed) * * @param {Node} node */ closeNode(node) { if (!emitsWrappingTags(node)) return; this.buffer += SPAN_CLOSE; } /** * returns the accumulated buffer */ value() { return this.buffer; } // helpers /** * Builds a span element * * @param {string} className */ span(className) { this.buffer += ``; } } const newNode = (opts = {}) => { const result = { children: [] }; Object.assign(result, opts); return result; }; class TokenTree { constructor() { this.rootNode = newNode(); this.stack = [this.rootNode]; } get top() { return this.stack[this.stack.length - 1]; } get root() { return this.rootNode; } /** @param {Node} node */ add(node) { this.top.children.push(node); } /** @param {string} scope */ openNode(scope) { const node = newNode({ scope }); this.add(node); this.stack.push(node); } closeNode() { if (this.stack.length > 1) { return this.stack.pop(); } return void 0; } closeAllNodes() { while (this.closeNode()) ; } toJSON() { return JSON.stringify(this.rootNode, null, 4); } /** * @typedef { import("./html_renderer").Renderer } Renderer * @param {Renderer} builder */ walk(builder) { return this.constructor._walk(builder, this.rootNode); } /** * @param {Renderer} builder * @param {Node} node */ static _walk(builder, node) { if (typeof node === "string") { builder.addText(node); } else if (node.children) { builder.openNode(node); node.children.forEach((child) => this._walk(builder, child)); builder.closeNode(node); } return builder; } /** * @param {Node} node */ static _collapse(node) { if (typeof node === "string") return; if (!node.children) return; if (node.children.every((el) => typeof el === "string")) { node.children = [node.children.join("")]; } else { node.children.forEach((child) => { TokenTree._collapse(child); }); } } } class TokenTreeEmitter extends TokenTree { /** * @param {*} options */ constructor(options) { super(); this.options = options; } /** * @param {string} text */ addText(text) { if (text === "") { return; } this.add(text); } /** @param {string} scope */ startScope(scope) { this.openNode(scope); } endScope() { this.closeNode(); } /** * @param {Emitter & {root: DataNode}} emitter * @param {string} name */ __addSublanguage(emitter, name) { const node = emitter.root; if (name) node.scope = `language:${name}`; this.add(node); } toHTML() { const renderer = new HTMLRenderer(this, this.options); return renderer.value(); } finalize() { this.closeAllNodes(); return true; } } function source(re2) { if (!re2) return null; if (typeof re2 === "string") return re2; return re2.source; } function lookahead(re2) { return concat("(?=", re2, ")"); } function anyNumberOfTimes(re2) { return concat("(?:", re2, ")*"); } function optional(re2) { return concat("(?:", re2, ")?"); } function concat(...args) { const joined = args.map((x2) => source(x2)).join(""); return joined; } function stripOptionsFromArgs(args) { const opts = args[args.length - 1]; if (typeof opts === "object" && opts.constructor === Object) { args.splice(args.length - 1, 1); return opts; } else { return {}; } } function either(...args) { const opts = stripOptionsFromArgs(args); const joined = "(" + (opts.capture ? "" : "?:") + args.map((x2) => source(x2)).join("|") + ")"; return joined; } function countMatchGroups(re2) { return new RegExp(re2.toString() + "|").exec("").length - 1; } function startsWith(re2, lexeme) { const match = re2 && re2.exec(lexeme); return match && match.index === 0; } const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./; function _rewriteBackreferences(regexps, { joinWith }) { let numCaptures = 0; return regexps.map((regex) => { numCaptures += 1; const offset = numCaptures; let re2 = source(regex); let out = ""; while (re2.length > 0) { const match = BACKREF_RE.exec(re2); if (!match) { out += re2; break; } out += re2.substring(0, match.index); re2 = re2.substring(match.index + match[0].length); if (match[0][0] === "\\" && match[1]) { out += "\\" + String(Number(match[1]) + offset); } else { out += match[0]; if (match[0] === "(") { numCaptures++; } } } return out; }).map((re2) => `(${re2})`).join(joinWith); } const MATCH_NOTHING_RE = /\b\B/; const IDENT_RE = "[a-zA-Z]\\w*"; const UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*"; const NUMBER_RE = "\\b\\d+(\\.\\d+)?"; const C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)"; const BINARY_NUMBER_RE = "\\b(0b[01]+)"; const RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~"; const SHEBANG = (opts = {}) => { const beginShebang = /^#![ ]*\//; if (opts.binary) { opts.begin = concat( beginShebang, /.*\b/, opts.binary, /\b.*/ ); } return inherit$1({ scope: "meta", begin: beginShebang, end: /$/, relevance: 0, /** @type {ModeCallback} */ "on:begin": (m2, resp) => { if (m2.index !== 0) resp.ignoreMatch(); } }, opts); }; const BACKSLASH_ESCAPE = { begin: "\\\\[\\s\\S]", relevance: 0 }; const APOS_STRING_MODE = { scope: "string", begin: "'", end: "'", illegal: "\\n", contains: [BACKSLASH_ESCAPE] }; const QUOTE_STRING_MODE = { scope: "string", begin: '"', end: '"', illegal: "\\n", contains: [BACKSLASH_ESCAPE] }; const PHRASAL_WORDS_MODE = { begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/ }; const COMMENT = function(begin, end, modeOptions = {}) { const mode = inherit$1( { scope: "comment", begin, end, contains: [] }, modeOptions ); mode.contains.push({ scope: "doctag", // hack to avoid the space from being included. the space is necessary to // match here to prevent the plain text rule below from gobbling up doctags begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)", end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, excludeBegin: true, relevance: 0 }); const ENGLISH_WORD = either( // list of common 1 and 2 letter words in English "I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", // note: this is not an exhaustive list of contractions, just popular ones /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, // contractions - can't we'd they're let's, etc /[A-Za-z]+[-][a-z]+/, // `no-way`, etc. /[A-Za-z][a-z]{2,}/ // allow capitalized words at beginning of sentences ); mode.contains.push( { // TODO: how to include ", (, ) without breaking grammars that use these for // comment delimiters? // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/ // --- // this tries to find sequences of 3 english words in a row (without any // "programming" type syntax) this gives us a strong signal that we've // TRULY found a comment - vs perhaps scanning with the wrong language. // It's possible to find something that LOOKS like the start of the // comment - but then if there is no readable text - good chance it is a // false match and not a comment. // // for a visual example please see: // https://github.com/highlightjs/highlight.js/issues/2827 begin: concat( /[ ]+/, // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */ "(", ENGLISH_WORD, /[.]?[:]?([.][ ]|[ ])/, "){3}" ) // look for 3 words in a row } ); return mode; }; const C_LINE_COMMENT_MODE = COMMENT("//", "$"); const C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/"); const HASH_COMMENT_MODE = COMMENT("#", "$"); const NUMBER_MODE = { scope: "number", begin: NUMBER_RE, relevance: 0 }; const C_NUMBER_MODE = { scope: "number", begin: C_NUMBER_RE, relevance: 0 }; const BINARY_NUMBER_MODE = { scope: "number", begin: BINARY_NUMBER_RE, relevance: 0 }; const REGEXP_MODE = { scope: "regexp", begin: /\/(?=[^/\n]*\/)/, end: /\/[gimuy]*/, contains: [ BACKSLASH_ESCAPE, { begin: /\[/, end: /\]/, relevance: 0, contains: [BACKSLASH_ESCAPE] } ] }; const TITLE_MODE = { scope: "title", begin: IDENT_RE, relevance: 0 }; const UNDERSCORE_TITLE_MODE = { scope: "title", begin: UNDERSCORE_IDENT_RE, relevance: 0 }; const METHOD_GUARD = { // excludes method names from keyword processing begin: "\\.\\s*" + UNDERSCORE_IDENT_RE, relevance: 0 }; const END_SAME_AS_BEGIN = function(mode) { return Object.assign( mode, { /** @type {ModeCallback} */ "on:begin": (m2, resp) => { resp.data._beginMatch = m2[1]; }, /** @type {ModeCallback} */ "on:end": (m2, resp) => { if (resp.data._beginMatch !== m2[1]) resp.ignoreMatch(); } } ); }; var MODES = /* @__PURE__ */ Object.freeze({ __proto__: null, APOS_STRING_MODE, BACKSLASH_ESCAPE, BINARY_NUMBER_MODE, BINARY_NUMBER_RE, COMMENT, C_BLOCK_COMMENT_MODE, C_LINE_COMMENT_MODE, C_NUMBER_MODE, C_NUMBER_RE, END_SAME_AS_BEGIN, HASH_COMMENT_MODE, IDENT_RE, MATCH_NOTHING_RE, METHOD_GUARD, NUMBER_MODE, NUMBER_RE, PHRASAL_WORDS_MODE, QUOTE_STRING_MODE, REGEXP_MODE, RE_STARTERS_RE, SHEBANG, TITLE_MODE, UNDERSCORE_IDENT_RE, UNDERSCORE_TITLE_MODE }); function skipIfHasPrecedingDot(match, response) { const before = match.input[match.index - 1]; if (before === ".") { response.ignoreMatch(); } } function scopeClassName(mode, _parent) { if (mode.className !== void 0) { mode.scope = mode.className; delete mode.className; } } function beginKeywords(mode, parent) { if (!parent) return; if (!mode.beginKeywords) return; mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)"; mode.__beforeBegin = skipIfHasPrecedingDot; mode.keywords = mode.keywords || mode.beginKeywords; delete mode.beginKeywords; if (mode.relevance === void 0) mode.relevance = 0; } function compileIllegal(mode, _parent) { if (!Array.isArray(mode.illegal)) return; mode.illegal = either(...mode.illegal); } function compileMatch(mode, _parent) { if (!mode.match) return; if (mode.begin || mode.end) throw new Error("begin & end are not supported with match"); mode.begin = mode.match; delete mode.match; } function compileRelevance(mode, _parent) { if (mode.relevance === void 0) mode.relevance = 1; } const beforeMatchExt = (mode, parent) => { if (!mode.beforeMatch) return; if (mode.starts) throw new Error("beforeMatch cannot be used with starts"); const originalMode = Object.assign({}, mode); Object.keys(mode).forEach((key) => { delete mode[key]; }); mode.keywords = originalMode.keywords; mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin)); mode.starts = { relevance: 0, contains: [ Object.assign(originalMode, { endsParent: true }) ] }; mode.relevance = 0; delete originalMode.beforeMatch; }; const COMMON_KEYWORDS = [ "of", "and", "for", "in", "not", "or", "if", "then", "parent", // common variable name "list", // common variable name "value" // common variable name ]; const DEFAULT_KEYWORD_SCOPE = "keyword"; function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) { const compiledKeywords = /* @__PURE__ */ Object.create(null); if (typeof rawKeywords === "string") { compileList(scopeName, rawKeywords.split(" ")); } else if (Array.isArray(rawKeywords)) { compileList(scopeName, rawKeywords); } else { Object.keys(rawKeywords).forEach(function(scopeName2) { Object.assign( compiledKeywords, compileKeywords(rawKeywords[scopeName2], caseInsensitive, scopeName2) ); }); } return compiledKeywords; function compileList(scopeName2, keywordList) { if (caseInsensitive) { keywordList = keywordList.map((x2) => x2.toLowerCase()); } keywordList.forEach(function(keyword) { const pair = keyword.split("|"); compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])]; }); } } function scoreForKeyword(keyword, providedScore) { if (providedScore) { return Number(providedScore); } return commonKeyword(keyword) ? 0 : 1; } function commonKeyword(keyword) { return COMMON_KEYWORDS.includes(keyword.toLowerCase()); } const seenDeprecations = {}; const error = (message) => { console.error(message); }; const warn = (message, ...args) => { console.log(`WARN: ${message}`, ...args); }; const deprecated = (version2, message) => { if (seenDeprecations[`${version2}/${message}`]) return; console.log(`Deprecated as of ${version2}. ${message}`); seenDeprecations[`${version2}/${message}`] = true; }; const MultiClassError = new Error(); function remapScopeNames(mode, regexes, { key }) { let offset = 0; const scopeNames = mode[key]; const emit = {}; const positions = {}; for (let i = 1; i <= regexes.length; i++) { positions[i + offset] = scopeNames[i]; emit[i + offset] = true; offset += countMatchGroups(regexes[i - 1]); } mode[key] = positions; mode[key]._emit = emit; mode[key]._multi = true; } function beginMultiClass(mode) { if (!Array.isArray(mode.begin)) return; if (mode.skip || mode.excludeBegin || mode.returnBegin) { error("skip, excludeBegin, returnBegin not compatible with beginScope: {}"); throw MultiClassError; } if (typeof mode.beginScope !== "object" || mode.beginScope === null) { error("beginScope must be object"); throw MultiClassError; } remapScopeNames(mode, mode.begin, { key: "beginScope" }); mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" }); } function endMultiClass(mode) { if (!Array.isArray(mode.end)) return; if (mode.skip || mode.excludeEnd || mode.returnEnd) { error("skip, excludeEnd, returnEnd not compatible with endScope: {}"); throw MultiClassError; } if (typeof mode.endScope !== "object" || mode.endScope === null) { error("endScope must be object"); throw MultiClassError; } remapScopeNames(mode, mode.end, { key: "endScope" }); mode.end = _rewriteBackreferences(mode.end, { joinWith: "" }); } function scopeSugar(mode) { if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) { mode.beginScope = mode.scope; delete mode.scope; } } function MultiClass(mode) { scopeSugar(mode); if (typeof mode.beginScope === "string") { mode.beginScope = { _wrap: mode.beginScope }; } if (typeof mode.endScope === "string") { mode.endScope = { _wrap: mode.endScope }; } beginMultiClass(mode); endMultiClass(mode); } function compileLanguage(language) { function langRe(value, global) { return new RegExp( source(value), "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : "") ); } class MultiRegex { constructor() { this.matchIndexes = {}; this.regexes = []; this.matchAt = 1; this.position = 0; } // @ts-ignore addRule(re2, opts) { opts.position = this.position++; this.matchIndexes[this.matchAt] = opts; this.regexes.push([opts, re2]); this.matchAt += countMatchGroups(re2) + 1; } compile() { if (this.regexes.length === 0) { this.exec = () => null; } const terminators = this.regexes.map((el) => el[1]); this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: "|" }), true); this.lastIndex = 0; } /** @param {string} s */ exec(s) { this.matcherRe.lastIndex = this.lastIndex; const match = this.matcherRe.exec(s); if (!match) { return null; } const i = match.findIndex((el, i2) => i2 > 0 && el !== void 0); const matchData = this.matchIndexes[i]; match.splice(0, i); return Object.assign(match, matchData); } } class ResumableMultiRegex { constructor() { this.rules = []; this.multiRegexes = []; this.count = 0; this.lastIndex = 0; this.regexIndex = 0; } // @ts-ignore getMatcher(index) { if (this.multiRegexes[index]) return this.multiRegexes[index]; const matcher = new MultiRegex(); this.rules.slice(index).forEach(([re2, opts]) => matcher.addRule(re2, opts)); matcher.compile(); this.multiRegexes[index] = matcher; return matcher; } resumingScanAtSamePosition() { return this.regexIndex !== 0; } considerAll() { this.regexIndex = 0; } // @ts-ignore addRule(re2, opts) { this.rules.push([re2, opts]); if (opts.type === "begin") this.count++; } /** @param {string} s */ exec(s) { const m2 = this.getMatcher(this.regexIndex); m2.lastIndex = this.lastIndex; let result = m2.exec(s); if (this.resumingScanAtSamePosition()) { if (result && result.index === this.lastIndex) ; else { const m22 = this.getMatcher(0); m22.lastIndex = this.lastIndex + 1; result = m22.exec(s); } } if (result) { this.regexIndex += result.position + 1; if (this.regexIndex === this.count) { this.considerAll(); } } return result; } } function buildModeRegex(mode) { const mm = new ResumableMultiRegex(); mode.contains.forEach((term) => mm.addRule(term.begin, { rule: term, type: "begin" })); if (mode.terminatorEnd) { mm.addRule(mode.terminatorEnd, { type: "end" }); } if (mode.illegal) { mm.addRule(mode.illegal, { type: "illegal" }); } return mm; } function compileMode(mode, parent) { const cmode = ( /** @type CompiledMode */ mode ); if (mode.isCompiled) return cmode; [ scopeClassName, // do this early so compiler extensions generally don't have to worry about // the distinction between match/begin compileMatch, MultiClass, beforeMatchExt ].forEach((ext) => ext(mode, parent)); language.compilerExtensions.forEach((ext) => ext(mode, parent)); mode.__beforeBegin = null; [ beginKeywords, // do this later so compiler extensions that come earlier have access to the // raw array if they wanted to perhaps manipulate it, etc. compileIllegal, // default to 1 relevance if not specified compileRelevance ].forEach((ext) => ext(mode, parent)); mode.isCompiled = true; let keywordPattern = null; if (typeof mode.keywords === "object" && mode.keywords.$pattern) { mode.keywords = Object.assign({}, mode.keywords); keywordPattern = mode.keywords.$pattern; delete mode.keywords.$pattern; } keywordPattern = keywordPattern || /\w+/; if (mode.keywords) { mode.keywords = compileKeywords(mode.keywords, language.case_insensitive); } cmode.keywordPatternRe = langRe(keywordPattern, true); if (parent) { if (!mode.begin) mode.begin = /\B|\b/; cmode.beginRe = langRe(cmode.begin); if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/; if (mode.end) cmode.endRe = langRe(cmode.end); cmode.terminatorEnd = source(cmode.end) || ""; if (mode.endsWithParent && parent.terminatorEnd) { cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd; } } if (mode.illegal) cmode.illegalRe = langRe( /** @type {RegExp | string} */ mode.illegal ); if (!mode.contains) mode.contains = []; mode.contains = [].concat(...mode.contains.map(function(c) { return expandOrCloneMode(c === "self" ? mode : c); })); mode.contains.forEach(function(c) { compileMode( /** @type Mode */ c, cmode ); }); if (mode.starts) { compileMode(mode.starts, parent); } cmode.matcher = buildModeRegex(cmode); return cmode; } if (!language.compilerExtensions) language.compilerExtensions = []; if (language.contains && language.contains.includes("self")) { throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation."); } language.classNameAliases = inherit$1(language.classNameAliases || {}); return compileMode( /** @type Mode */ language ); } function dependencyOnParent(mode) { if (!mode) return false; return mode.endsWithParent || dependencyOnParent(mode.starts); } function expandOrCloneMode(mode) { if (mode.variants && !mode.cachedVariants) { mode.cachedVariants = mode.variants.map(function(variant) { return inherit$1(mode, { variants: null }, variant); }); } if (mode.cachedVariants) { return mode.cachedVariants; } if (dependencyOnParent(mode)) { return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null }); } if (Object.isFrozen(mode)) { return inherit$1(mode); } return mode; } var version = "11.11.1"; class HTMLInjectionError extends Error { constructor(reason, html) { super(reason); this.name = "HTMLInjectionError"; this.html = html; } } const escape = escapeHTML; const inherit = inherit$1; const NO_MATCH = Symbol("nomatch"); const MAX_KEYWORD_HITS = 7; const HLJS = function(hljs2) { const languages = /* @__PURE__ */ Object.create(null); const aliases = /* @__PURE__ */ Object.create(null); const plugins = []; let SAFE_MODE = true; const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?"; const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: "Plain text", contains: [] }; let options = { ignoreUnescapedHTML: false, throwUnescapedHTML: false, noHighlightRe: /^(no-?highlight)$/i, languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, classPrefix: "hljs-", cssSelector: "pre code", languages: null, // beta configuration options, subject to change, welcome to discuss // https://github.com/highlightjs/highlight.js/issues/1086 __emitter: TokenTreeEmitter }; function shouldNotHighlight(languageName) { return options.noHighlightRe.test(languageName); } function blockLanguage(block) { let classes = block.className + " "; classes += block.parentNode ? block.parentNode.className : ""; const match = options.languageDetectRe.exec(classes); if (match) { const language = getLanguage(match[1]); if (!language) { warn(LANGUAGE_NOT_FOUND.replace("{}", match[1])); warn("Falling back to no-highlight mode for this block.", block); } return language ? match[1] : "no-highlight"; } return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class)); } function highlight2(codeOrLanguageName, optionsOrCode, ignoreIllegals) { let code = ""; let languageName = ""; if (typeof optionsOrCode === "object") { code = codeOrLanguageName; ignoreIllegals = optionsOrCode.ignoreIllegals; languageName = optionsOrCode.language; } else { deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated."); deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"); languageName = codeOrLanguageName; code = optionsOrCode; } if (ignoreIllegals === void 0) { ignoreIllegals = true; } const context = { code, language: languageName }; fire("before:highlight", context); const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals); result.code = context.code; fire("after:highlight", result); return result; } function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) { const keywordHits = /* @__PURE__ */ Object.create(null); function keywordData(mode, matchText) { return mode.keywords[matchText]; } function processKeywords() { if (!top.keywords) { emitter.addText(modeBuffer); return; } let lastIndex = 0; top.keywordPatternRe.lastIndex = 0; let match = top.keywordPatternRe.exec(modeBuffer); let buf = ""; while (match) { buf += modeBuffer.substring(lastIndex, match.index); const word = language.case_insensitive ? match[0].toLowerCase() : match[0]; const data = keywordData(top, word); if (data) { const [kind, keywordRelevance] = data; emitter.addText(buf); buf = ""; keywordHits[word] = (keywordHits[word] || 0) + 1; if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance; if (kind.startsWith("_")) { buf += match[0]; } else { const cssClass = language.classNameAliases[kind] || kind; emitKeyword(match[0], cssClass); } } else { buf += match[0]; } lastIndex = top.keywordPatternRe.lastIndex; match = top.keywordPatternRe.exec(modeBuffer); } buf += modeBuffer.substring(lastIndex); emitter.addText(buf); } function processSubLanguage() { if (modeBuffer === "") return; let result2 = null; if (typeof top.subLanguage === "string") { if (!languages[top.subLanguage]) { emitter.addText(modeBuffer); return; } result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]); continuations[top.subLanguage] = /** @type {CompiledMode} */ result2._top; } else { result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null); } if (top.relevance > 0) { relevance += result2.relevance; } emitter.__addSublanguage(result2._emitter, result2.language); } function processBuffer() { if (top.subLanguage != null) { processSubLanguage(); } else { processKeywords(); } modeBuffer = ""; } function emitKeyword(keyword, scope) { if (keyword === "") return; emitter.startScope(scope); emitter.addText(keyword); emitter.endScope(); } function emitMultiClass(scope, match) { let i = 1; const max = match.length - 1; while (i <= max) { if (!scope._emit[i]) { i++; continue; } const klass = language.classNameAliases[scope[i]] || scope[i]; const text = match[i]; if (klass) { emitKeyword(text, klass); } else { modeBuffer = text; processKeywords(); modeBuffer = ""; } i++; } } function startNewMode(mode, match) { if (mode.scope && typeof mode.scope === "string") { emitter.openNode(language.classNameAliases[mode.scope] || mode.scope); } if (mode.beginScope) { if (mode.beginScope._wrap) { emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap); modeBuffer = ""; } else if (mode.beginScope._multi) { emitMultiClass(mode.beginScope, match); modeBuffer = ""; } } top = Object.create(mode, { parent: { value: top } }); return top; } function endOfMode(mode, match, matchPlusRemainder) { let matched = startsWith(mode.endRe, matchPlusRemainder); if (matched) { if (mode["on:end"]) { const resp = new Response(mode); mode["on:end"](match, resp); if (resp.isMatchIgnored) matched = false; } if (matched) { while (mode.endsParent && mode.parent) { mode = mode.parent; } return mode; } } if (mode.endsWithParent) { return endOfMode(mode.parent, match, matchPlusRemainder); } } function doIgnore(lexeme) { if (top.matcher.regexIndex === 0) { modeBuffer += lexeme[0]; return 1; } else { resumeScanAtSamePosition = true; return 0; } } function doBeginMatch(match) { const lexeme = match[0]; const newMode = match.rule; const resp = new Response(newMode); const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]]; for (const cb of beforeCallbacks) { if (!cb) continue; cb(match, resp); if (resp.isMatchIgnored) return doIgnore(lexeme); } if (newMode.skip) { modeBuffer += lexeme; } else { if (newMode.excludeBegin) { modeBuffer += lexeme; } processBuffer(); if (!newMode.returnBegin && !newMode.excludeBegin) { modeBuffer = lexeme; } } startNewMode(newMode, match); return newMode.returnBegin ? 0 : lexeme.length; } function doEndMatch(match) { const lexeme = match[0]; const matchPlusRemainder = codeToHighlight.substring(match.index); const endMode = endOfMode(top, match, matchPlusRemainder); if (!endMode) { return NO_MATCH; } const origin = top; if (top.endScope && top.endScope._wrap) { processBuffer(); emitKeyword(lexeme, top.endScope._wrap); } else if (top.endScope && top.endScope._multi) { processBuffer(); emitMultiClass(top.endScope, match); } else if (origin.skip) { modeBuffer += lexeme; } else { if (!(origin.returnEnd || origin.excludeEnd)) { modeBuffer += lexeme; } processBuffer(); if (origin.excludeEnd) { modeBuffer = lexeme; } } do { if (top.scope) { emitter.closeNode(); } if (!top.skip && !top.subLanguage) { relevance += top.relevance; } top = top.parent; } while (top !== endMode.parent); if (endMode.starts) { startNewMode(endMode.starts, match); } return origin.returnEnd ? 0 : lexeme.length; } function processContinuations() { const list = []; for (let current = top; current !== language; current = current.parent) { if (current.scope) { list.unshift(current.scope); } } list.forEach((item) => emitter.openNode(item)); } let lastMatch = {}; function processLexeme(textBeforeMatch, match) { const lexeme = match && match[0]; modeBuffer += textBeforeMatch; if (lexeme == null) { processBuffer(); return 0; } if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") { modeBuffer += codeToHighlight.slice(match.index, match.index + 1); if (!SAFE_MODE) { const err = new Error(`0 width match regex (${languageName})`); err.languageName = languageName; err.badRule = lastMatch.rule; throw err; } return 1; } lastMatch = match; if (match.type === "begin") { return doBeginMatch(match); } else if (match.type === "illegal" && !ignoreIllegals) { const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || "