@fewangsit/wangsvue 1.5.219-alpha.0 → 1.5.219-alpha.2

package/vendor/highlight.js/lib/core.es.js

@@ -1,88 +1,114 @@
-var re, De;
-function Ft() {
-  if (De) return re;
-  De = 1;
-  function ce(e) {
-    return e instanceof Map ? e.clear = e.delete = e.set = function() {
-      throw new Error("map is read-only");
-    } : e instanceof Set && (e.add = e.clear = e.delete = function() {
-      throw new Error("set is read-only");
-    }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((t) => {
-      const i = e[t], u = typeof i;
-      (u === "object" || u === "function") && !Object.isFrozen(i) && ce(i);
-    }), e;
+var core;
+var hasRequiredCore;
+function requireCore() {
+  if (hasRequiredCore) return core;
+  hasRequiredCore = 1;
+  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 oe {
+  class Response {
     /**
      * @param {CompiledMode} mode
      */
-    constructor(t) {
-      t.data === void 0 && (t.data = {}), this.data = t.data, this.isMatchIgnored = !1;
+    constructor(mode) {
+      if (mode.data === void 0) mode.data = {};
+      this.data = mode.data;
+      this.isMatchIgnored = false;
     }
     ignoreMatch() {
-      this.isMatchIgnored = !0;
+      this.isMatchIgnored = true;
     }
   }
-  function ae(e) {
-    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+  function escapeHTML(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
   }
-  function T(e, ...t) {
-    const i = /* @__PURE__ */ Object.create(null);
-    for (const u in e)
-      i[u] = e[u];
-    return t.forEach(function(u) {
-      for (const b in u)
-        i[b] = u[b];
-    }), /** @type {T} */
-    i;
+  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 Ce = "</span>", le = (e) => !!e.scope, Le = (e, { prefix: t }) => {
-    if (e.startsWith("language:"))
-      return e.replace("language:", "language-");
-    if (e.includes(".")) {
-      const i = e.split(".");
+  const SPAN_CLOSE = "</span>";
+  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 [
-        `${t}${i.shift()}`,
-        ...i.map((u, b) => `${u}${"_".repeat(b + 1)}`)
+        `${prefix}${pieces.shift()}`,
+        ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)
       ].join(" ");
     }
-    return `${t}${e}`;
+    return `${prefix}${name}`;
   };
-  class He {
+  class HTMLRenderer {
     /**
      * Creates a new HTMLRenderer
      *
      * @param {Tree} parseTree - the parse tree (must support `walk` API)
      * @param {{classPrefix: string}} options
      */
-    constructor(t, i) {
-      this.buffer = "", this.classPrefix = i.classPrefix, t.walk(this);
+    constructor(parseTree, options) {
+      this.buffer = "";
+      this.classPrefix = options.classPrefix;
+      parseTree.walk(this);
     }
     /**
      * Adds texts to the output stream
      *
      * @param {string} text */
-    addText(t) {
-      this.buffer += ae(t);
+    addText(text) {
+      this.buffer += escapeHTML(text);
     }
     /**
      * Adds a node open to the output stream (if needed)
      *
      * @param {Node} node */
-    openNode(t) {
-      if (!le(t)) return;
-      const i = Le(
-        t.scope,
+    openNode(node) {
+      if (!emitsWrappingTags(node)) return;
+      const className = scopeToCSSClass(
+        node.scope,
         { prefix: this.classPrefix }
       );
-      this.span(i);
+      this.span(className);
     }
     /**
      * Adds a node close to the output stream (if needed)
      *
      * @param {Node} node */
-    closeNode(t) {
-      le(t) && (this.buffer += Ce);
+    closeNode(node) {
+      if (!emitsWrappingTags(node)) return;
+      this.buffer += SPAN_CLOSE;
     }
     /**
      * returns the accumulated buffer
@@ -95,17 +121,19 @@ function Ft() {
      * Builds a span element
      *
      * @param {string} className */
-    span(t) {
-      this.buffer += `<span class="${t}">`;
+    span(className) {
+      this.buffer += `<span class="${className}">`;
     }
   }
-  const ue = (e = {}) => {
-    const t = { children: [] };
-    return Object.assign(t, e), t;
+  const newNode = (opts = {}) => {
+    const result = { children: [] };
+    Object.assign(result, opts);
+    return result;
   };
-  class Z {
+  class TokenTree {
     constructor() {
-      this.rootNode = ue(), this.stack = [this.rootNode];
+      this.rootNode = newNode();
+      this.stack = [this.rootNode];
     }
     get top() {
       return this.stack[this.stack.length - 1];
@@ -114,20 +142,23 @@ function Ft() {
       return this.rootNode;
     }
     /** @param {Node} node */
-    add(t) {
-      this.top.children.push(t);
+    add(node) {
+      this.top.children.push(node);
     }
     /** @param {string} scope */
-    openNode(t) {
-      const i = ue({ scope: t });
-      this.add(i), this.stack.push(i);
+    openNode(scope) {
+      const node = newNode({ scope });
+      this.add(node);
+      this.stack.push(node);
     }
     closeNode() {
-      if (this.stack.length > 1)
+      if (this.stack.length > 1) {
         return this.stack.pop();
+      }
+      return void 0;
     }
     closeAllNodes() {
-      for (; this.closeNode(); ) ;
+      while (this.closeNode()) ;
     }
     toJSON() {
       return JSON.stringify(this.rootNode, null, 4);
@@ -136,41 +167,58 @@ function Ft() {
      * @typedef { import("./html_renderer").Renderer } Renderer
      * @param {Renderer} builder
      */
-    walk(t) {
-      return this.constructor._walk(t, this.rootNode);
+    walk(builder) {
+      return this.constructor._walk(builder, this.rootNode);
     }
     /**
      * @param {Renderer} builder
      * @param {Node} node
      */
-    static _walk(t, i) {
-      return typeof i == "string" ? t.addText(i) : i.children && (t.openNode(i), i.children.forEach((u) => this._walk(t, u)), t.closeNode(i)), t;
+    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(t) {
-      typeof t != "string" && t.children && (t.children.every((i) => typeof i == "string") ? t.children = [t.children.join("")] : t.children.forEach((i) => {
-        Z._collapse(i);
-      }));
+    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 Pe extends Z {
+  class TokenTreeEmitter extends TokenTree {
     /**
      * @param {*} options
      */
-    constructor(t) {
-      super(), this.options = t;
+    constructor(options) {
+      super();
+      this.options = options;
     }
     /**
      * @param {string} text
      */
-    addText(t) {
-      t !== "" && this.add(t);
+    addText(text) {
+      if (text === "") {
+        return;
+      }
+      this.add(text);
     }
     /** @param {string} scope */
-    startScope(t) {
-      this.openNode(t);
+    startScope(scope) {
+      this.openNode(scope);
     }
     endScope() {
       this.closeNode();
@@ -179,118 +227,156 @@ function Ft() {
      * @param {Emitter & {root: DataNode}} emitter
      * @param {string} name
      */
-    __addSublanguage(t, i) {
-      const u = t.root;
-      i && (u.scope = `language:${i}`), this.add(u);
+    __addSublanguage(emitter, name) {
+      const node = emitter.root;
+      if (name) node.scope = `language:${name}`;
+      this.add(node);
     }
     toHTML() {
-      return new He(this, this.options).value();
+      const renderer = new HTMLRenderer(this, this.options);
+      return renderer.value();
     }
     finalize() {
-      return this.closeAllNodes(), !0;
+      this.closeAllNodes();
+      return true;
     }
   }
-  function P(e) {
-    return e ? typeof e == "string" ? e : e.source : null;
+  function source(re) {
+    if (!re) return null;
+    if (typeof re === "string") return re;
+    return re.source;
   }
-  function fe(e) {
-    return v("(?=", e, ")");
+  function lookahead(re) {
+    return concat("(?=", re, ")");
   }
-  function je(e) {
-    return v("(?:", e, ")*");
+  function anyNumberOfTimes(re) {
+    return concat("(?:", re, ")*");
   }
-  function Ue(e) {
-    return v("(?:", e, ")?");
+  function optional(re) {
+    return concat("(?:", re, ")?");
   }
-  function v(...e) {
-    return e.map((i) => P(i)).join("");
+  function concat(...args) {
+    const joined = args.map((x) => source(x)).join("");
+    return joined;
   }
-  function $e(e) {
-    const t = e[e.length - 1];
-    return typeof t == "object" && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {};
+  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 q(...e) {
-    return "(" + ($e(e).capture ? "" : "?:") + e.map((u) => P(u)).join("|") + ")";
+  function either(...args) {
+    const opts = stripOptionsFromArgs(args);
+    const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
+    return joined;
   }
-  function ge(e) {
-    return new RegExp(e.toString() + "|").exec("").length - 1;
+  function countMatchGroups(re) {
+    return new RegExp(re.toString() + "|").exec("").length - 1;
   }
-  function Ge(e, t) {
-    const i = e && e.exec(t);
-    return i && i.index === 0;
+  function startsWith(re, lexeme) {
+    const match = re && re.exec(lexeme);
+    return match && match.index === 0;
   }
-  const We = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-  function J(e, { joinWith: t }) {
-    let i = 0;
-    return e.map((u) => {
-      i += 1;
-      const b = i;
-      let _ = P(u), c = "";
-      for (; _.length > 0; ) {
-        const r = We.exec(_);
-        if (!r) {
-          c += _;
+  const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+  function _rewriteBackreferences(regexps, { joinWith }) {
+    let numCaptures = 0;
+    return regexps.map((regex) => {
+      numCaptures += 1;
+      const offset = numCaptures;
+      let re = source(regex);
+      let out = "";
+      while (re.length > 0) {
+        const match = BACKREF_RE.exec(re);
+        if (!match) {
+          out += re;
           break;
         }
-        c += _.substring(0, r.index), _ = _.substring(r.index + r[0].length), r[0][0] === "\\" && r[1] ? c += "\\" + String(Number(r[1]) + b) : (c += r[0], r[0] === "(" && i++);
+        out += re.substring(0, match.index);
+        re = re.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 c;
-    }).map((u) => `(${u})`).join(t);
+      return out;
+    }).map((re) => `(${re})`).join(joinWith);
   }
-  const Ke = /\b\B/, he = "[a-zA-Z]\\w*", V = "[a-zA-Z_]\\w*", de = "\\b\\d+(\\.\\d+)?", pe = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", Ee = "\\b(0b[01]+)", ze = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", Fe = (e = {}) => {
-    const t = /^#![ ]*\//;
-    return e.binary && (e.begin = v(
-      t,
-      /.*\b/,
-      e.binary,
-      /\b.*/
-    )), T({
+  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: t,
+      begin: beginShebang,
       end: /$/,
       relevance: 0,
       /** @type {ModeCallback} */
-      "on:begin": (i, u) => {
-        i.index !== 0 && u.ignoreMatch();
+      "on:begin": (m, resp) => {
+        if (m.index !== 0) resp.ignoreMatch();
       }
-    }, e);
-  }, j = {
+    }, opts);
+  };
+  const BACKSLASH_ESCAPE = {
     begin: "\\\\[\\s\\S]",
     relevance: 0
-  }, Xe = {
+  };
+  const APOS_STRING_MODE = {
     scope: "string",
     begin: "'",
     end: "'",
     illegal: "\\n",
-    contains: [j]
-  }, Ye = {
+    contains: [BACKSLASH_ESCAPE]
+  };
+  const QUOTE_STRING_MODE = {
     scope: "string",
     begin: '"',
     end: '"',
     illegal: "\\n",
-    contains: [j]
-  }, Ze = {
+    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/
-  }, $ = function(e, t, i = {}) {
-    const u = T(
+  };
+  const COMMENT = function(begin, end, modeOptions = {}) {
+    const mode = inherit$1(
       {
         scope: "comment",
-        begin: e,
-        end: t,
+        begin,
+        end,
         contains: []
       },
-      i
+      modeOptions
     );
-    u.contains.push({
+    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: !0,
+      excludeBegin: true,
       relevance: 0
     });
-    const b = q(
+    const ENGLISH_WORD = either(
       // list of common 1 and 2 letter words in English
       "I",
       "a",
@@ -311,7 +397,7 @@ function Ft() {
       /[A-Za-z][a-z]{2,}/
       // allow capitalized words at beginning of sentences
     );
-    return u.contains.push(
+    mode.contains.push(
       {
         // TODO: how to include ", (, ) without breaking grammars that use these for
         // comment delimiters?
@@ -326,130 +412,161 @@ function Ft() {
         //
         // for a visual example please see:
         // https://github.com/highlightjs/highlight.js/issues/2827
-        begin: v(
+        begin: concat(
           /[ ]+/,
           // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
           "(",
-          b,
+          ENGLISH_WORD,
           /[.]?[:]?([.][ ]|[ ])/,
           "){3}"
         )
         // look for 3 words in a row
       }
-    ), u;
-  }, qe = $("//", "$"), Je = $("/\\*", "\\*/"), Ve = $("#", "$"), Qe = {
+    );
+    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: de,
+    begin: NUMBER_RE,
     relevance: 0
-  }, me = {
+  };
+  const C_NUMBER_MODE = {
     scope: "number",
-    begin: pe,
+    begin: C_NUMBER_RE,
     relevance: 0
-  }, et = {
+  };
+  const BINARY_NUMBER_MODE = {
     scope: "number",
-    begin: Ee,
+    begin: BINARY_NUMBER_RE,
     relevance: 0
-  }, tt = {
+  };
+  const REGEXP_MODE = {
     scope: "regexp",
     begin: /\/(?=[^/\n]*\/)/,
     end: /\/[gimuy]*/,
     contains: [
-      j,
+      BACKSLASH_ESCAPE,
       {
         begin: /\[/,
         end: /\]/,
         relevance: 0,
-        contains: [j]
+        contains: [BACKSLASH_ESCAPE]
       }
     ]
-  }, nt = {
+  };
+  const TITLE_MODE = {
     scope: "title",
-    begin: he,
+    begin: IDENT_RE,
     relevance: 0
-  }, it = {
+  };
+  const UNDERSCORE_TITLE_MODE = {
     scope: "title",
-    begin: V,
+    begin: UNDERSCORE_IDENT_RE,
     relevance: 0
-  }, st = {
+  };
+  const METHOD_GUARD = {
     // excludes method names from keyword processing
-    begin: "\\.\\s*" + V,
+    begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
     relevance: 0
   };
-  var G = /* @__PURE__ */ Object.freeze({
-    __proto__: null,
-    APOS_STRING_MODE: Xe,
-    BACKSLASH_ESCAPE: j,
-    BINARY_NUMBER_MODE: et,
-    BINARY_NUMBER_RE: Ee,
-    COMMENT: $,
-    C_BLOCK_COMMENT_MODE: Je,
-    C_LINE_COMMENT_MODE: qe,
-    C_NUMBER_MODE: me,
-    C_NUMBER_RE: pe,
-    END_SAME_AS_BEGIN: function(e) {
-      return Object.assign(
-        e,
-        {
-          /** @type {ModeCallback} */
-          "on:begin": (t, i) => {
-            i.data._beginMatch = t[1];
-          },
-          /** @type {ModeCallback} */
-          "on:end": (t, i) => {
-            i.data._beginMatch !== t[1] && i.ignoreMatch();
-          }
+  const END_SAME_AS_BEGIN = function(mode) {
+    return Object.assign(
+      mode,
+      {
+        /** @type {ModeCallback} */
+        "on:begin": (m, resp) => {
+          resp.data._beginMatch = m[1];
+        },
+        /** @type {ModeCallback} */
+        "on:end": (m, resp) => {
+          if (resp.data._beginMatch !== m[1]) resp.ignoreMatch();
         }
-      );
-    },
-    HASH_COMMENT_MODE: Ve,
-    IDENT_RE: he,
-    MATCH_NOTHING_RE: Ke,
-    METHOD_GUARD: st,
-    NUMBER_MODE: Qe,
-    NUMBER_RE: de,
-    PHRASAL_WORDS_MODE: Ze,
-    QUOTE_STRING_MODE: Ye,
-    REGEXP_MODE: tt,
-    RE_STARTERS_RE: ze,
-    SHEBANG: Fe,
-    TITLE_MODE: nt,
-    UNDERSCORE_IDENT_RE: V,
-    UNDERSCORE_TITLE_MODE: it
+      }
+    );
+  };
+  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 rt(e, t) {
-    e.input[e.index - 1] === "." && t.ignoreMatch();
+  function skipIfHasPrecedingDot(match, response) {
+    const before = match.input[match.index - 1];
+    if (before === ".") {
+      response.ignoreMatch();
+    }
   }
-  function ct(e, t) {
-    e.className !== void 0 && (e.scope = e.className, delete e.className);
+  function scopeClassName(mode, _parent) {
+    if (mode.className !== void 0) {
+      mode.scope = mode.className;
+      delete mode.className;
+    }
   }
-  function ot(e, t) {
-    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = rt, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+  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 at(e, t) {
-    Array.isArray(e.illegal) && (e.illegal = q(...e.illegal));
+  function compileIllegal(mode, _parent) {
+    if (!Array.isArray(mode.illegal)) return;
+    mode.illegal = either(...mode.illegal);
   }
-  function lt(e, t) {
-    if (e.match) {
-      if (e.begin || e.end) throw new Error("begin & end are not supported with match");
-      e.begin = e.match, delete e.match;
-    }
+  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 ut(e, t) {
-    e.relevance === void 0 && (e.relevance = 1);
+  function compileRelevance(mode, _parent) {
+    if (mode.relevance === void 0) mode.relevance = 1;
   }
-  const ft = (e, t) => {
-    if (!e.beforeMatch) return;
-    if (e.starts) throw new Error("beforeMatch cannot be used with starts");
-    const i = Object.assign({}, e);
-    Object.keys(e).forEach((u) => {
-      delete e[u];
-    }), e.keywords = i.keywords, e.begin = v(i.beforeMatch, fe(i.begin)), e.starts = {
+  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(i, { endsParent: !0 })
+        Object.assign(originalMode, { endsParent: true })
       ]
-    }, e.relevance = 0, delete i.beforeMatch;
-  }, gt = [
+    };
+    mode.relevance = 0;
+    delete originalMode.beforeMatch;
+  };
+  const COMMON_KEYWORDS = [
     "of",
     "and",
     "for",
@@ -464,105 +581,170 @@ function Ft() {
     // common variable name
     "value"
     // common variable name
-  ], ht = "keyword";
-  function be(e, t, i = ht) {
-    const u = /* @__PURE__ */ Object.create(null);
-    return typeof e == "string" ? b(i, e.split(" ")) : Array.isArray(e) ? b(i, e) : Object.keys(e).forEach(function(_) {
-      Object.assign(
-        u,
-        be(e[_], t, _)
-      );
-    }), u;
-    function b(_, c) {
-      t && (c = c.map((r) => r.toLowerCase())), c.forEach(function(r) {
-        const l = r.split("|");
-        u[l[0]] = [_, dt(l[0], l[1])];
+  ];
+  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((x) => x.toLowerCase());
+      }
+      keywordList.forEach(function(keyword) {
+        const pair = keyword.split("|");
+        compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])];
       });
     }
   }
-  function dt(e, t) {
-    return t ? Number(t) : pt(e) ? 0 : 1;
+  function scoreForKeyword(keyword, providedScore) {
+    if (providedScore) {
+      return Number(providedScore);
+    }
+    return commonKeyword(keyword) ? 0 : 1;
   }
-  function pt(e) {
-    return gt.includes(e.toLowerCase());
+  function commonKeyword(keyword) {
+    return COMMON_KEYWORDS.includes(keyword.toLowerCase());
   }
-  const _e = {}, D = (e) => {
-    console.error(e);
-  }, Me = (e, ...t) => {
-    console.log(`WARN: ${e}`, ...t);
-  }, L = (e, t) => {
-    _e[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), _e[`${e}/${t}`] = !0);
-  }, W = new Error();
-  function we(e, t, { key: i }) {
-    let u = 0;
-    const b = e[i], _ = {}, c = {};
-    for (let r = 1; r <= t.length; r++)
-      c[r + u] = b[r], _[r + u] = !0, u += ge(t[r - 1]);
-    e[i] = c, e[i]._emit = _, e[i]._multi = !0;
+  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 Et(e) {
-    if (Array.isArray(e.begin)) {
-      if (e.skip || e.excludeBegin || e.returnBegin)
-        throw D("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), W;
-      if (typeof e.beginScope != "object" || e.beginScope === null)
-        throw D("beginScope must be object"), W;
-      we(e, e.begin, { key: "beginScope" }), e.begin = J(e.begin, { joinWith: "" });
+  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 bt(e) {
-    if (Array.isArray(e.end)) {
-      if (e.skip || e.excludeEnd || e.returnEnd)
-        throw D("skip, excludeEnd, returnEnd not compatible with endScope: {}"), W;
-      if (typeof e.endScope != "object" || e.endScope === null)
-        throw D("endScope must be object"), W;
-      we(e, e.end, { key: "endScope" }), e.end = J(e.end, { 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 _t(e) {
-    e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+  function scopeSugar(mode) {
+    if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+      mode.beginScope = mode.scope;
+      delete mode.scope;
+    }
   }
-  function Mt(e) {
-    _t(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Et(e), bt(e);
+  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 wt(e) {
-    function t(c, r) {
+  function compileLanguage(language) {
+    function langRe(value, global) {
       return new RegExp(
-        P(c),
-        "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (r ? "g" : "")
+        source(value),
+        "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : "")
       );
     }
-    class i {
+    class MultiRegex {
       constructor() {
-        this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+        this.matchIndexes = {};
+        this.regexes = [];
+        this.matchAt = 1;
+        this.position = 0;
       }
       // @ts-ignore
-      addRule(r, l) {
-        l.position = this.position++, this.matchIndexes[this.matchAt] = l, this.regexes.push([l, r]), this.matchAt += ge(r) + 1;
+      addRule(re, opts) {
+        opts.position = this.position++;
+        this.matchIndexes[this.matchAt] = opts;
+        this.regexes.push([opts, re]);
+        this.matchAt += countMatchGroups(re) + 1;
       }
       compile() {
-        this.regexes.length === 0 && (this.exec = () => null);
-        const r = this.regexes.map((l) => l[1]);
-        this.matcherRe = t(J(r, { joinWith: "|" }), !0), this.lastIndex = 0;
+        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(r) {
+      exec(s) {
         this.matcherRe.lastIndex = this.lastIndex;
-        const l = this.matcherRe.exec(r);
-        if (!l)
+        const match = this.matcherRe.exec(s);
+        if (!match) {
           return null;
-        const x = l.findIndex((U, m) => m > 0 && U !== void 0), M = this.matchIndexes[x];
-        return l.splice(0, x), Object.assign(l, M);
+        }
+        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 u {
+    class ResumableMultiRegex {
       constructor() {
-        this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+        this.rules = [];
+        this.multiRegexes = [];
+        this.count = 0;
+        this.lastIndex = 0;
+        this.regexIndex = 0;
       }
       // @ts-ignore
-      getMatcher(r) {
-        if (this.multiRegexes[r]) return this.multiRegexes[r];
-        const l = new i();
-        return this.rules.slice(r).forEach(([x, M]) => l.addRule(x, M)), l.compile(), this.multiRegexes[r] = l, l;
+      getMatcher(index) {
+        if (this.multiRegexes[index]) return this.multiRegexes[index];
+        const matcher = new MultiRegex();
+        this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+        matcher.compile();
+        this.multiRegexes[index] = matcher;
+        return matcher;
       }
       resumingScanAtSamePosition() {
         return this.regexIndex !== 0;
@@ -571,88 +753,163 @@ function Ft() {
         this.regexIndex = 0;
       }
       // @ts-ignore
-      addRule(r, l) {
-        this.rules.push([r, l]), l.type === "begin" && this.count++;
+      addRule(re, opts) {
+        this.rules.push([re, opts]);
+        if (opts.type === "begin") this.count++;
       }
       /** @param {string} s */
-      exec(r) {
-        const l = this.getMatcher(this.regexIndex);
-        l.lastIndex = this.lastIndex;
-        let x = l.exec(r);
-        if (this.resumingScanAtSamePosition() && !(x && x.index === this.lastIndex)) {
-          const M = this.getMatcher(0);
-          M.lastIndex = this.lastIndex + 1, x = M.exec(r);
+      exec(s) {
+        const m = this.getMatcher(this.regexIndex);
+        m.lastIndex = this.lastIndex;
+        let result = m.exec(s);
+        if (this.resumingScanAtSamePosition()) {
+          if (result && result.index === this.lastIndex) ;
+          else {
+            const m2 = this.getMatcher(0);
+            m2.lastIndex = this.lastIndex + 1;
+            result = m2.exec(s);
+          }
+        }
+        if (result) {
+          this.regexIndex += result.position + 1;
+          if (this.regexIndex === this.count) {
+            this.considerAll();
+          }
         }
-        return x && (this.regexIndex += x.position + 1, this.regexIndex === this.count && this.considerAll()), x;
+        return result;
       }
     }
-    function b(c) {
-      const r = new u();
-      return c.contains.forEach((l) => r.addRule(l.begin, { rule: l, type: "begin" })), c.terminatorEnd && r.addRule(c.terminatorEnd, { type: "end" }), c.illegal && r.addRule(c.illegal, { type: "illegal" }), r;
+    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 _(c, r) {
-      const l = (
+    function compileMode(mode, parent) {
+      const cmode = (
         /** @type CompiledMode */
-        c
+        mode
       );
-      if (c.isCompiled) return l;
+      if (mode.isCompiled) return cmode;
       [
-        ct,
+        scopeClassName,
         // do this early so compiler extensions generally don't have to worry about
         // the distinction between match/begin
-        lt,
-        Mt,
-        ft
-      ].forEach((M) => M(c, r)), e.compilerExtensions.forEach((M) => M(c, r)), c.__beforeBegin = null, [
-        ot,
+        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.
-        at,
+        compileIllegal,
         // default to 1 relevance if not specified
-        ut
-      ].forEach((M) => M(c, r)), c.isCompiled = !0;
-      let x = null;
-      return typeof c.keywords == "object" && c.keywords.$pattern && (c.keywords = Object.assign({}, c.keywords), x = c.keywords.$pattern, delete c.keywords.$pattern), x = x || /\w+/, c.keywords && (c.keywords = be(c.keywords, e.case_insensitive)), l.keywordPatternRe = t(x, !0), r && (c.begin || (c.begin = /\B|\b/), l.beginRe = t(l.begin), !c.end && !c.endsWithParent && (c.end = /\B|\b/), c.end && (l.endRe = t(l.end)), l.terminatorEnd = P(l.end) || "", c.endsWithParent && r.terminatorEnd && (l.terminatorEnd += (c.end ? "|" : "") + r.terminatorEnd)), c.illegal && (l.illegalRe = t(
+        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} */
-        c.illegal
-      )), c.contains || (c.contains = []), c.contains = [].concat(...c.contains.map(function(M) {
-        return xt(M === "self" ? c : M);
-      })), c.contains.forEach(function(M) {
-        _(
+        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 */
-          M,
-          l
+          c,
+          cmode
         );
-      }), c.starts && _(c.starts, r), l.matcher = b(l), l;
+      });
+      if (mode.starts) {
+        compileMode(mode.starts, parent);
+      }
+      cmode.matcher = buildModeRegex(cmode);
+      return cmode;
     }
-    if (e.compilerExtensions || (e.compilerExtensions = []), e.contains && e.contains.includes("self"))
+    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.");
-    return e.classNameAliases = T(e.classNameAliases || {}), _(
+    }
+    language.classNameAliases = inherit$1(language.classNameAliases || {});
+    return compileMode(
       /** @type Mode */
-      e
+      language
     );
   }
-  function xe(e) {
-    return e ? e.endsWithParent || xe(e.starts) : !1;
+  function dependencyOnParent(mode) {
+    if (!mode) return false;
+    return mode.endsWithParent || dependencyOnParent(mode.starts);
   }
-  function xt(e) {
-    return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
-      return T(e, { variants: null }, t);
-    })), e.cachedVariants ? e.cachedVariants : xe(e) ? T(e, { starts: e.starts ? T(e.starts) : null }) : Object.isFrozen(e) ? T(e) : e;
+  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 Ot = "11.10.0";
-  class Rt extends Error {
-    constructor(t, i) {
-      super(t), this.name = "HTMLInjectionError", this.html = i;
+  var version = "11.10.0";
+  class HTMLInjectionError extends Error {
+    constructor(reason, html) {
+      super(reason);
+      this.name = "HTMLInjectionError";
+      this.html = html;
     }
   }
-  const Q = ae, Oe = T, Re = Symbol("nomatch"), yt = 7, ye = function(e) {
-    const t = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null), u = [];
-    let b = !0;
-    const _ = "Could not find the language '{}', did you forget to load/include a language module?", c = { disableAutodetect: !0, name: "Plain text", contains: [] };
-    let r = {
-      ignoreUnescapedHTML: !1,
-      throwUnescapedHTML: !1,
+  const escape = escapeHTML;
+  const inherit = inherit$1;
+  const NO_MATCH = Symbol("nomatch");
+  const MAX_KEYWORD_HITS = 7;
+  const HLJS = function(hljs) {
+    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-",
@@ -660,404 +917,625 @@ function Ft() {
       languages: null,
       // beta configuration options, subject to change, welcome to discuss
       // https://github.com/highlightjs/highlight.js/issues/1086
-      __emitter: Pe
+      __emitter: TokenTreeEmitter
     };
-    function l(n) {
-      return r.noHighlightRe.test(n);
-    }
-    function x(n) {
-      let a = n.className + " ";
-      a += n.parentNode ? n.parentNode.className : "";
-      const h = r.languageDetectRe.exec(a);
-      if (h) {
-        const p = I(h[1]);
-        return p || (Me(_.replace("{}", h[1])), Me("Falling back to no-highlight mode for this block.", n)), p ? h[1] : "no-highlight";
+    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;
       }
-      return a.split(/\s+/).find((p) => l(p) || I(p));
-    }
-    function M(n, a, h) {
-      let p = "", w = "";
-      typeof a == "object" ? (p = n, h = a.ignoreIllegals, w = a.language) : (L("10.7.0", "highlight(lang, code, ...args) has been deprecated."), L("10.7.0", `Please use highlight(code, options) instead.
-https://github.com/highlightjs/highlight.js/issues/2277`), w = n, p = a), h === void 0 && (h = !0);
-      const S = {
-        code: p,
-        language: w
+      const context = {
+        code,
+        language: languageName
       };
-      z("before:highlight", S);
-      const B = S.result ? S.result : U(S.language, S.code, h);
-      return B.code = S.code, z("after:highlight", B), B;
-    }
-    function U(n, a, h, p) {
-      const w = /* @__PURE__ */ Object.create(null);
-      function S(s, o) {
-        return s.keywords[o];
+      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 B() {
-        if (!f.keywords) {
-          O.addText(E);
+      function processKeywords() {
+        if (!top.keywords) {
+          emitter.addText(modeBuffer);
           return;
         }
-        let s = 0;
-        f.keywordPatternRe.lastIndex = 0;
-        let o = f.keywordPatternRe.exec(E), g = "";
-        for (; o; ) {
-          g += E.substring(s, o.index);
-          const d = A.case_insensitive ? o[0].toLowerCase() : o[0], R = S(f, d);
-          if (R) {
-            const [k, Wt] = R;
-            if (O.addText(g), g = "", w[d] = (w[d] || 0) + 1, w[d] <= yt && (Y += Wt), k.startsWith("_"))
-              g += o[0];
-            else {
-              const Kt = A.classNameAliases[k] || k;
-              N(o[0], Kt);
+        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
-            g += o[0];
-          s = f.keywordPatternRe.lastIndex, o = f.keywordPatternRe.exec(E);
+          } else {
+            buf += match[0];
+          }
+          lastIndex = top.keywordPatternRe.lastIndex;
+          match = top.keywordPatternRe.exec(modeBuffer);
         }
-        g += E.substring(s), O.addText(g);
+        buf += modeBuffer.substring(lastIndex);
+        emitter.addText(buf);
       }
-      function F() {
-        if (E === "") return;
-        let s = null;
-        if (typeof f.subLanguage == "string") {
-          if (!t[f.subLanguage]) {
-            O.addText(E);
+      function processSubLanguage() {
+        if (modeBuffer === "") return;
+        let result2 = null;
+        if (typeof top.subLanguage === "string") {
+          if (!languages[top.subLanguage]) {
+            emitter.addText(modeBuffer);
             return;
           }
-          s = U(f.subLanguage, E, !0, ve[f.subLanguage]), ve[f.subLanguage] = /** @type {CompiledMode} */
-          s._top;
-        } else
-          s = ee(E, f.subLanguage.length ? f.subLanguage : null);
-        f.relevance > 0 && (Y += s.relevance), O.__addSublanguage(s._emitter, s.language);
+          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 y() {
-        f.subLanguage != null ? F() : B(), E = "";
+      function processBuffer() {
+        if (top.subLanguage != null) {
+          processSubLanguage();
+        } else {
+          processKeywords();
+        }
+        modeBuffer = "";
       }
-      function N(s, o) {
-        s !== "" && (O.startScope(o), O.addText(s), O.endScope());
+      function emitKeyword(keyword, scope) {
+        if (keyword === "") return;
+        emitter.startScope(scope);
+        emitter.addText(keyword);
+        emitter.endScope();
       }
-      function ke(s, o) {
-        let g = 1;
-        const d = o.length - 1;
-        for (; g <= d; ) {
-          if (!s._emit[g]) {
-            g++;
+      function emitMultiClass(scope, match) {
+        let i = 1;
+        const max = match.length - 1;
+        while (i <= max) {
+          if (!scope._emit[i]) {
+            i++;
             continue;
           }
-          const R = A.classNameAliases[s[g]] || s[g], k = o[g];
-          R ? N(k, R) : (E = k, B(), E = ""), g++;
+          const klass = language.classNameAliases[scope[i]] || scope[i];
+          const text = match[i];
+          if (klass) {
+            emitKeyword(text, klass);
+          } else {
+            modeBuffer = text;
+            processKeywords();
+            modeBuffer = "";
+          }
+          i++;
         }
       }
-      function Te(s, o) {
-        return s.scope && typeof s.scope == "string" && O.openNode(A.classNameAliases[s.scope] || s.scope), s.beginScope && (s.beginScope._wrap ? (N(E, A.classNameAliases[s.beginScope._wrap] || s.beginScope._wrap), E = "") : s.beginScope._multi && (ke(s.beginScope, o), E = "")), f = Object.create(s, { parent: { value: f } }), f;
+      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 Ie(s, o, g) {
-        let d = Ge(s.endRe, g);
-        if (d) {
-          if (s["on:end"]) {
-            const R = new oe(s);
-            s["on:end"](o, R), R.isMatchIgnored && (d = !1);
+      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 (d) {
-            for (; s.endsParent && s.parent; )
-              s = s.parent;
-            return s;
+          if (matched) {
+            while (mode.endsParent && mode.parent) {
+              mode = mode.parent;
+            }
+            return mode;
           }
         }
-        if (s.endsWithParent)
-          return Ie(s.parent, o, g);
+        if (mode.endsWithParent) {
+          return endOfMode(mode.parent, match, matchPlusRemainder);
+        }
       }
-      function Pt(s) {
-        return f.matcher.regexIndex === 0 ? (E += s[0], 1) : (se = !0, 0);
+      function doIgnore(lexeme) {
+        if (top.matcher.regexIndex === 0) {
+          modeBuffer += lexeme[0];
+          return 1;
+        } else {
+          resumeScanAtSamePosition = true;
+          return 0;
+        }
       }
-      function jt(s) {
-        const o = s[0], g = s.rule, d = new oe(g), R = [g.__beforeBegin, g["on:begin"]];
-        for (const k of R)
-          if (k && (k(s, d), d.isMatchIgnored))
-            return Pt(o);
-        return g.skip ? E += o : (g.excludeBegin && (E += o), y(), !g.returnBegin && !g.excludeBegin && (E = o)), Te(g, s), g.returnBegin ? 0 : o.length;
+      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 Ut(s) {
-        const o = s[0], g = a.substring(s.index), d = Ie(f, s, g);
-        if (!d)
-          return Re;
-        const R = f;
-        f.endScope && f.endScope._wrap ? (y(), N(o, f.endScope._wrap)) : f.endScope && f.endScope._multi ? (y(), ke(f.endScope, s)) : R.skip ? E += o : (R.returnEnd || R.excludeEnd || (E += o), y(), R.excludeEnd && (E = o));
-        do
-          f.scope && O.closeNode(), !f.skip && !f.subLanguage && (Y += f.relevance), f = f.parent;
-        while (f !== d.parent);
-        return d.starts && Te(d.starts, s), R.returnEnd ? 0 : o.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 $t() {
-        const s = [];
-        for (let o = f; o !== A; o = o.parent)
-          o.scope && s.unshift(o.scope);
-        s.forEach((o) => O.openNode(o));
+      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 X = {};
-      function Be(s, o) {
-        const g = o && o[0];
-        if (E += s, g == null)
-          return y(), 0;
-        if (X.type === "begin" && o.type === "end" && X.index === o.index && g === "") {
-          if (E += a.slice(o.index, o.index + 1), !b) {
-            const d = new Error(`0 width match regex (${n})`);
-            throw d.languageName = n, d.badRule = X.rule, d;
+      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;
         }
-        if (X = o, o.type === "begin")
-          return jt(o);
-        if (o.type === "illegal" && !h) {
-          const d = new Error('Illegal lexeme "' + g + '" for mode "' + (f.scope || "<unnamed>") + '"');
-          throw d.mode = f, d;
-        } else if (o.type === "end") {
-          const d = Ut(o);
-          if (d !== Re)
-            return d;
+        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 || "<unnamed>") + '"');
+          err.mode = top;
+          throw err;
+        } else if (match.type === "end") {
+          const processed = doEndMatch(match);
+          if (processed !== NO_MATCH) {
+            return processed;
+          }
         }
-        if (o.type === "illegal" && g === "")
+        if (match.type === "illegal" && lexeme === "") {
           return 1;
-        if (ie > 1e5 && ie > o.index * 3)
-          throw new Error("potential infinite loop, way more iterations than matches");
-        return E += g, g.length;
+        }
+        if (iterations > 1e5 && iterations > match.index * 3) {
+          const err = new Error("potential infinite loop, way more iterations than matches");
+          throw err;
+        }
+        modeBuffer += lexeme;
+        return lexeme.length;
+      }
+      const language = getLanguage(languageName);
+      if (!language) {
+        error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+        throw new Error('Unknown language: "' + languageName + '"');
       }
-      const A = I(n);
-      if (!A)
-        throw D(_.replace("{}", n)), new Error('Unknown language: "' + n + '"');
-      const Gt = wt(A);
-      let ne = "", f = p || Gt;
-      const ve = {}, O = new r.__emitter(r);
-      $t();
-      let E = "", Y = 0, C = 0, ie = 0, se = !1;
+      const md = compileLanguage(language);
+      let result = "";
+      let top = continuation || md;
+      const continuations = {};
+      const emitter = new options.__emitter(options);
+      processContinuations();
+      let modeBuffer = "";
+      let relevance = 0;
+      let index = 0;
+      let iterations = 0;
+      let resumeScanAtSamePosition = false;
       try {
-        if (A.__emitTokens)
-          A.__emitTokens(a, O);
-        else {
-          for (f.matcher.considerAll(); ; ) {
-            ie++, se ? se = !1 : f.matcher.considerAll(), f.matcher.lastIndex = C;
-            const s = f.matcher.exec(a);
-            if (!s) break;
-            const o = a.substring(C, s.index), g = Be(o, s);
-            C = s.index + g;
+        if (!language.__emitTokens) {
+          top.matcher.considerAll();
+          for (; ; ) {
+            iterations++;
+            if (resumeScanAtSamePosition) {
+              resumeScanAtSamePosition = false;
+            } else {
+              top.matcher.considerAll();
+            }
+            top.matcher.lastIndex = index;
+            const match = top.matcher.exec(codeToHighlight);
+            if (!match) break;
+            const beforeMatch = codeToHighlight.substring(index, match.index);
+            const processedCount = processLexeme(beforeMatch, match);
+            index = match.index + processedCount;
           }
-          Be(a.substring(C));
+          processLexeme(codeToHighlight.substring(index));
+        } else {
+          language.__emitTokens(codeToHighlight, emitter);
         }
-        return O.finalize(), ne = O.toHTML(), {
-          language: n,
-          value: ne,
-          relevance: Y,
-          illegal: !1,
-          _emitter: O,
-          _top: f
+        emitter.finalize();
+        result = emitter.toHTML();
+        return {
+          language: languageName,
+          value: result,
+          relevance,
+          illegal: false,
+          _emitter: emitter,
+          _top: top
         };
-      } catch (s) {
-        if (s.message && s.message.includes("Illegal"))
+      } catch (err) {
+        if (err.message && err.message.includes("Illegal")) {
           return {
-            language: n,
-            value: Q(a),
-            illegal: !0,
+            language: languageName,
+            value: escape(codeToHighlight),
+            illegal: true,
             relevance: 0,
             _illegalBy: {
-              message: s.message,
-              index: C,
-              context: a.slice(C - 100, C + 100),
-              mode: s.mode,
-              resultSoFar: ne
+              message: err.message,
+              index,
+              context: codeToHighlight.slice(index - 100, index + 100),
+              mode: err.mode,
+              resultSoFar: result
             },
-            _emitter: O
+            _emitter: emitter
           };
-        if (b)
+        } else if (SAFE_MODE) {
           return {
-            language: n,
-            value: Q(a),
-            illegal: !1,
+            language: languageName,
+            value: escape(codeToHighlight),
+            illegal: false,
             relevance: 0,
-            errorRaised: s,
-            _emitter: O,
-            _top: f
+            errorRaised: err,
+            _emitter: emitter,
+            _top: top
           };
-        throw s;
+        } else {
+          throw err;
+        }
       }
     }
-    function m(n) {
-      const a = {
-        value: Q(n),
-        illegal: !1,
+    function justTextHighlightResult(code) {
+      const result = {
+        value: escape(code),
+        illegal: false,
         relevance: 0,
-        _top: c,
-        _emitter: new r.__emitter(r)
+        _top: PLAINTEXT_LANGUAGE,
+        _emitter: new options.__emitter(options)
       };
-      return a._emitter.addText(n), a;
+      result._emitter.addText(code);
+      return result;
     }
-    function ee(n, a) {
-      a = a || r.languages || Object.keys(t);
-      const h = m(n), p = a.filter(I).filter(Ae).map(
-        (y) => U(y, n, !1)
+    function highlightAuto(code, languageSubset) {
+      languageSubset = languageSubset || options.languages || Object.keys(languages);
+      const plaintext = justTextHighlightResult(code);
+      const results = languageSubset.filter(getLanguage).filter(autoDetection).map(
+        (name) => _highlight(name, code, false)
       );
-      p.unshift(h);
-      const w = p.sort((y, N) => {
-        if (y.relevance !== N.relevance) return N.relevance - y.relevance;
-        if (y.language && N.language) {
-          if (I(y.language).supersetOf === N.language)
+      results.unshift(plaintext);
+      const sorted = results.sort((a, b) => {
+        if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+        if (a.language && b.language) {
+          if (getLanguage(a.language).supersetOf === b.language) {
             return 1;
-          if (I(N.language).supersetOf === y.language)
+          } else if (getLanguage(b.language).supersetOf === a.language) {
             return -1;
+          }
         }
         return 0;
-      }), [S, B] = w, F = S;
-      return F.secondBest = B, F;
-    }
-    function St(n, a, h) {
-      const p = a && i[a] || h;
-      n.classList.add("hljs"), n.classList.add(`language-${p}`);
-    }
-    function te(n) {
-      let a = null;
-      const h = x(n);
-      if (l(h)) return;
-      if (z(
+      });
+      const [best, secondBest] = sorted;
+      const result = best;
+      result.secondBest = secondBest;
+      return result;
+    }
+    function updateClassName(element, currentLang, resultLang) {
+      const language = currentLang && aliases[currentLang] || resultLang;
+      element.classList.add("hljs");
+      element.classList.add(`language-${language}`);
+    }
+    function highlightElement(element) {
+      let node = null;
+      const language = blockLanguage(element);
+      if (shouldNotHighlight(language)) return;
+      fire(
         "before:highlightElement",
-        { el: n, language: h }
-      ), n.dataset.highlighted) {
-        console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", n);
+        { el: element, language }
+      );
+      if (element.dataset.highlighted) {
+        console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
         return;
       }
-      if (n.children.length > 0 && (r.ignoreUnescapedHTML || (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."), console.warn("https://github.com/highlightjs/highlight.js/wiki/security"), console.warn("The element with unescaped HTML:"), console.warn(n)), r.throwUnescapedHTML))
-        throw new Rt(
-          "One of your code blocks includes unescaped HTML.",
-          n.innerHTML
-        );
-      a = n;
-      const p = a.textContent, w = h ? M(p, { language: h, ignoreIllegals: !0 }) : ee(p);
-      n.innerHTML = w.value, n.dataset.highlighted = "yes", St(n, h, w.language), n.result = {
-        language: w.language,
+      if (element.children.length > 0) {
+        if (!options.ignoreUnescapedHTML) {
+          console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+          console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+          console.warn("The element with unescaped HTML:");
+          console.warn(element);
+        }
+        if (options.throwUnescapedHTML) {
+          const err = new HTMLInjectionError(
+            "One of your code blocks includes unescaped HTML.",
+            element.innerHTML
+          );
+          throw err;
+        }
+      }
+      node = element;
+      const text = node.textContent;
+      const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text);
+      element.innerHTML = result.value;
+      element.dataset.highlighted = "yes";
+      updateClassName(element, language, result.language);
+      element.result = {
+        language: result.language,
         // TODO: remove with version 11.0
-        re: w.relevance,
-        relevance: w.relevance
-      }, w.secondBest && (n.secondBest = {
-        language: w.secondBest.language,
-        relevance: w.secondBest.relevance
-      }), z("after:highlightElement", { el: n, result: w, text: p });
-    }
-    function Nt(n) {
-      r = Oe(r, n);
-    }
-    const At = () => {
-      K(), L("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+        re: result.relevance,
+        relevance: result.relevance
+      };
+      if (result.secondBest) {
+        element.secondBest = {
+          language: result.secondBest.language,
+          relevance: result.secondBest.relevance
+        };
+      }
+      fire("after:highlightElement", { el: element, result, text });
+    }
+    function configure(userOptions) {
+      options = inherit(options, userOptions);
+    }
+    const initHighlighting = () => {
+      highlightAll();
+      deprecated("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
     };
-    function kt() {
-      K(), L("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+    function initHighlightingOnLoad() {
+      highlightAll();
+      deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
     }
-    let Se = !1;
-    function K() {
+    let wantsHighlight = false;
+    function highlightAll() {
       if (document.readyState === "loading") {
-        Se = !0;
+        wantsHighlight = true;
         return;
       }
-      document.querySelectorAll(r.cssSelector).forEach(te);
+      const blocks = document.querySelectorAll(options.cssSelector);
+      blocks.forEach(highlightElement);
+    }
+    function boot() {
+      if (wantsHighlight) highlightAll();
     }
-    function Tt() {
-      Se && K();
+    if (typeof window !== "undefined" && window.addEventListener) {
+      window.addEventListener("DOMContentLoaded", boot, false);
     }
-    typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", Tt, !1);
-    function It(n, a) {
-      let h = null;
+    function registerLanguage(languageName, languageDefinition) {
+      let lang = null;
       try {
-        h = a(e);
-      } catch (p) {
-        if (D("Language definition for '{}' could not be registered.".replace("{}", n)), b)
-          D(p);
-        else
-          throw p;
-        h = c;
+        lang = languageDefinition(hljs);
+      } catch (error$1) {
+        error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+        if (!SAFE_MODE) {
+          throw error$1;
+        } else {
+          error(error$1);
+        }
+        lang = PLAINTEXT_LANGUAGE;
+      }
+      if (!lang.name) lang.name = languageName;
+      languages[languageName] = lang;
+      lang.rawDefinition = languageDefinition.bind(null, hljs);
+      if (lang.aliases) {
+        registerAliases(lang.aliases, { languageName });
       }
-      h.name || (h.name = n), t[n] = h, h.rawDefinition = a.bind(null, e), h.aliases && Ne(h.aliases, { languageName: n });
     }
-    function Bt(n) {
-      delete t[n];
-      for (const a of Object.keys(i))
-        i[a] === n && delete i[a];
+    function unregisterLanguage(languageName) {
+      delete languages[languageName];
+      for (const alias of Object.keys(aliases)) {
+        if (aliases[alias] === languageName) {
+          delete aliases[alias];
+        }
+      }
     }
-    function vt() {
-      return Object.keys(t);
+    function listLanguages() {
+      return Object.keys(languages);
     }
-    function I(n) {
-      return n = (n || "").toLowerCase(), t[n] || t[i[n]];
+    function getLanguage(name) {
+      name = (name || "").toLowerCase();
+      return languages[name] || languages[aliases[name]];
     }
-    function Ne(n, { languageName: a }) {
-      typeof n == "string" && (n = [n]), n.forEach((h) => {
-        i[h.toLowerCase()] = a;
+    function registerAliases(aliasList, { languageName }) {
+      if (typeof aliasList === "string") {
+        aliasList = [aliasList];
+      }
+      aliasList.forEach((alias) => {
+        aliases[alias.toLowerCase()] = languageName;
       });
     }
-    function Ae(n) {
-      const a = I(n);
-      return a && !a.disableAutodetect;
+    function autoDetection(name) {
+      const lang = getLanguage(name);
+      return lang && !lang.disableAutodetect;
     }
-    function Dt(n) {
-      n["before:highlightBlock"] && !n["before:highlightElement"] && (n["before:highlightElement"] = (a) => {
-        n["before:highlightBlock"](
-          Object.assign({ block: a.el }, a)
-        );
-      }), n["after:highlightBlock"] && !n["after:highlightElement"] && (n["after:highlightElement"] = (a) => {
-        n["after:highlightBlock"](
-          Object.assign({ block: a.el }, a)
-        );
-      });
+    function upgradePluginAPI(plugin) {
+      if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+        plugin["before:highlightElement"] = (data) => {
+          plugin["before:highlightBlock"](
+            Object.assign({ block: data.el }, data)
+          );
+        };
+      }
+      if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+        plugin["after:highlightElement"] = (data) => {
+          plugin["after:highlightBlock"](
+            Object.assign({ block: data.el }, data)
+          );
+        };
+      }
     }
-    function Ct(n) {
-      Dt(n), u.push(n);
+    function addPlugin(plugin) {
+      upgradePluginAPI(plugin);
+      plugins.push(plugin);
     }
-    function Lt(n) {
-      const a = u.indexOf(n);
-      a !== -1 && u.splice(a, 1);
+    function removePlugin(plugin) {
+      const index = plugins.indexOf(plugin);
+      if (index !== -1) {
+        plugins.splice(index, 1);
+      }
     }
-    function z(n, a) {
-      const h = n;
-      u.forEach(function(p) {
-        p[h] && p[h](a);
+    function fire(event, args) {
+      const cb = event;
+      plugins.forEach(function(plugin) {
+        if (plugin[cb]) {
+          plugin[cb](args);
+        }
       });
     }
-    function Ht(n) {
-      return L("10.7.0", "highlightBlock will be removed entirely in v12.0"), L("10.7.0", "Please use highlightElement now."), te(n);
+    function deprecateHighlightBlock(el) {
+      deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+      deprecated("10.7.0", "Please use highlightElement now.");
+      return highlightElement(el);
     }
-    Object.assign(e, {
-      highlight: M,
-      highlightAuto: ee,
-      highlightAll: K,
-      highlightElement: te,
+    Object.assign(hljs, {
+      highlight: highlight2,
+      highlightAuto,
+      highlightAll,
+      highlightElement,
       // TODO: Remove with v12 API
-      highlightBlock: Ht,
-      configure: Nt,
-      initHighlighting: At,
-      initHighlightingOnLoad: kt,
-      registerLanguage: It,
-      unregisterLanguage: Bt,
-      listLanguages: vt,
-      getLanguage: I,
-      registerAliases: Ne,
-      autoDetection: Ae,
-      inherit: Oe,
-      addPlugin: Ct,
-      removePlugin: Lt
-    }), e.debugMode = function() {
-      b = !1;
-    }, e.safeMode = function() {
-      b = !0;
-    }, e.versionString = Ot, e.regex = {
-      concat: v,
-      lookahead: fe,
-      either: q,
-      optional: Ue,
-      anyNumberOfTimes: je
+      highlightBlock: deprecateHighlightBlock,
+      configure,
+      initHighlighting,
+      initHighlightingOnLoad,
+      registerLanguage,
+      unregisterLanguage,
+      listLanguages,
+      getLanguage,
+      registerAliases,
+      autoDetection,
+      inherit,
+      addPlugin,
+      removePlugin
+    });
+    hljs.debugMode = function() {
+      SAFE_MODE = false;
     };
-    for (const n in G)
-      typeof G[n] == "object" && ce(G[n]);
-    return Object.assign(e, G), e;
-  }, H = ye({});
-  return H.newInstance = () => ye({}), re = H, H.HighlightJS = H, H.default = H, re;
+    hljs.safeMode = function() {
+      SAFE_MODE = true;
+    };
+    hljs.versionString = version;
+    hljs.regex = {
+      concat,
+      lookahead,
+      either,
+      optional,
+      anyNumberOfTimes
+    };
+    for (const key in MODES) {
+      if (typeof MODES[key] === "object") {
+        deepFreeze(MODES[key]);
+      }
+    }
+    Object.assign(hljs, MODES);
+    return hljs;
+  };
+  const highlight = HLJS({});
+  highlight.newInstance = () => HLJS({});
+  core = highlight;
+  highlight.HighlightJS = highlight;
+  highlight.default = highlight;
+  return core;
 }
 export {
-  Ft as r
+  requireCore as r
 };