@fangzhongya/vue-archive 0.0.2-8 → 0.0.2

package/dist/es/node_modules/.pnpm/highlight.js@11.7.0/node_modules/highlight.js/lib/core.js

@@ -1,83 +1,113 @@
-var te = { exports: {} };
-function ne(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(function(t) {
-    var i = e[t];
-    typeof i == "object" && !Object.isFrozen(i) && ne(i);
-  }), e;
+var deepFreezeEs6 = { exports: {} };
+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(function(name) {
+    var prop = obj[name];
+    if (typeof prop == "object" && !Object.isFrozen(prop)) {
+      deepFreeze(prop);
+    }
+  });
+  return obj;
 }
-te.exports = ne;
-te.exports.default = ne;
-class de {
+deepFreezeEs6.exports = deepFreeze;
+deepFreezeEs6.exports.default = deepFreeze;
+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 xe(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 v(e, ...t) {
-  const i = /* @__PURE__ */ Object.create(null);
-  for (const f in e)
-    i[f] = e[f];
-  return t.forEach(function(f) {
-    for (const b in f)
-      i[b] = f[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 Je = "</span>", pe = (e) => !!e.scope || e.sublanguage && e.language, Ve = (e, { prefix: t }) => {
-  if (e.includes(".")) {
-    const i = e.split(".");
+const SPAN_CLOSE = "</span>";
+const emitsWrappingTags = (node) => {
+  return !!node.scope || node.sublanguage && node.language;
+};
+const scopeToCSSClass = (name, { prefix }) => {
+  if (name.includes(".")) {
+    const pieces = name.split(".");
     return [
-      `${t}${i.shift()}`,
-      ...i.map((f, b) => `${f}${"_".repeat(b + 1)}`)
+      `${prefix}${pieces.shift()}`,
+      ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)
     ].join(" ");
   }
-  return `${t}${e}`;
+  return `${prefix}${name}`;
 };
-class qe {
+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 += xe(t);
+  addText(text) {
+    this.buffer += escapeHTML(text);
   }
   /**
    * Adds a node open to the output stream (if needed)
    *
    * @param {Node} node */
-  openNode(t) {
-    if (!pe(t))
+  openNode(node) {
+    if (!emitsWrappingTags(node))
       return;
-    let i = "";
-    t.sublanguage ? i = `language-${t.language}` : i = Ve(t.scope, { prefix: this.classPrefix }), this.span(i);
+    let className = "";
+    if (node.sublanguage) {
+      className = `language-${node.language}`;
+    } else {
+      className = scopeToCSSClass(node.scope, { prefix: this.classPrefix });
+    }
+    this.span(className);
   }
   /**
    * Adds a node close to the output stream (if needed)
    *
    * @param {Node} node */
-  closeNode(t) {
-    pe(t) && (this.buffer += Je);
+  closeNode(node) {
+    if (!emitsWrappingTags(node))
+      return;
+    this.buffer += SPAN_CLOSE;
   }
   /**
    * returns the accumulated buffer
@@ -90,17 +120,19 @@ class qe {
    * Builds a span element
    *
    * @param {string} className */
-  span(t) {
-    this.buffer += `<span class="${t}">`;
+  span(className) {
+    this.buffer += `<span class="${className}">`;
   }
 }
-const Ee = (e = {}) => {
-  const t = { children: [] };
-  return Object.assign(t, e), t;
+const newNode = (opts = {}) => {
+  const result = { children: [] };
+  Object.assign(result, opts);
+  return result;
 };
-class ie {
+class TokenTree {
   constructor() {
-    this.rootNode = Ee(), this.stack = [this.rootNode];
+    this.rootNode = newNode();
+    this.stack = [this.rootNode];
   }
   get top() {
     return this.stack[this.stack.length - 1];
@@ -109,20 +141,23 @@ class ie {
     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 = Ee({ 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() {
@@ -132,161 +167,226 @@ class ie {
    * @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((f) => this._walk(t, f)), 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) => {
-      ie._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 Qe extends ie {
+class TokenTreeEmitter extends TokenTree {
   /**
    * @param {*} options
    */
-  constructor(t) {
-    super(), this.options = t;
+  constructor(options) {
+    super();
+    this.options = options;
   }
   /**
    * @param {string} text
    * @param {string} scope
    */
-  addKeyword(t, i) {
-    t !== "" && (this.openNode(i), this.addText(t), this.closeNode());
+  addKeyword(text, scope) {
+    if (text === "") {
+      return;
+    }
+    this.openNode(scope);
+    this.addText(text);
+    this.closeNode();
   }
   /**
    * @param {string} text
    */
-  addText(t) {
-    t !== "" && this.add(t);
+  addText(text) {
+    if (text === "") {
+      return;
+    }
+    this.add(text);
   }
   /**
    * @param {Emitter & {root: DataNode}} emitter
    * @param {string} name
    */
-  addSublanguage(t, i) {
-    const f = t.root;
-    f.sublanguage = !0, f.language = i, this.add(f);
+  addSublanguage(emitter, name) {
+    const node = emitter.root;
+    node.sublanguage = true;
+    node.language = name;
+    this.add(node);
   }
   toHTML() {
-    return new qe(this, this.options).value();
+    const renderer = new HTMLRenderer(this, this.options);
+    return renderer.value();
   }
   finalize() {
-    return !0;
+    return true;
   }
 }
-function j(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 Oe(e) {
-  return L("(?=", e, ")");
+function lookahead(re) {
+  return concat("(?=", re, ")");
 }
-function me(e) {
-  return L("(?:", e, ")*");
+function anyNumberOfTimes(re) {
+  return concat("(?:", re, ")*");
 }
-function et(e) {
-  return L("(?:", e, ")?");
+function optional(re) {
+  return concat("(?:", re, ")?");
 }
-function L(...e) {
-  return e.map((i) => j(i)).join("");
+function concat(...args) {
+  const joined = args.map((x) => source(x)).join("");
+  return joined;
 }
-function tt(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 se(...e) {
-  return "(" + (tt(e).capture ? "" : "?:") + e.map((f) => j(f)).join("|") + ")";
+function either(...args) {
+  const opts = stripOptionsFromArgs(args);
+  const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
+  return joined;
 }
-function ye(e) {
-  return new RegExp(e.toString() + "|").exec("").length - 1;
+function countMatchGroups(re) {
+  return new RegExp(re.toString() + "|").exec("").length - 1;
 }
-function nt(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 it = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-function re(e, { joinWith: t }) {
-  let i = 0;
-  return e.map((f) => {
-    i += 1;
-    const b = i;
-    let _ = j(f), c = "";
-    for (; _.length > 0; ) {
-      const r = it.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((f) => `(${f})`).join(t);
+    return out;
+  }).map((re) => `(${re})`).join(joinWith);
 }
-const st = /\b\B/, Re = "[a-zA-Z]\\w*", ce = "[a-zA-Z_]\\w*", Se = "\\b\\d+(\\.\\d+)?", Ne = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", Ae = "\\b(0b[01]+)", rt = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", ct = (e = {}) => {
-  const t = /^#![ ]*\//;
-  return e.binary && (e.begin = L(
-    t,
-    /.*\b/,
-    e.binary,
-    /\b.*/
-  )), v({
+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, f) => {
-      i.index !== 0 && f.ignoreMatch();
+    "on:begin": (m, resp) => {
+      if (m.index !== 0)
+        resp.ignoreMatch();
     }
-  }, e);
-}, P = {
+  }, opts);
+};
+const BACKSLASH_ESCAPE = {
   begin: "\\\\[\\s\\S]",
   relevance: 0
-}, ot = {
+};
+const APOS_STRING_MODE = {
   scope: "string",
   begin: "'",
   end: "'",
   illegal: "\\n",
-  contains: [P]
-}, at = {
+  contains: [BACKSLASH_ESCAPE]
+};
+const QUOTE_STRING_MODE = {
   scope: "string",
   begin: '"',
   end: '"',
   illegal: "\\n",
-  contains: [P]
-}, lt = {
+  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/
-}, Y = function(e, t, i = {}) {
-  const f = v(
+};
+const COMMENT = function(begin, end, modeOptions = {}) {
+  const mode = inherit$1(
     {
       scope: "comment",
-      begin: e,
-      end: t,
+      begin,
+      end,
       contains: []
     },
-    i
+    modeOptions
   );
-  f.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 = se(
+  const ENGLISH_WORD = either(
     // list of common 1 and 2 letter words in English
     "I",
     "a",
@@ -307,7 +407,7 @@ const st = /\b\B/, Re = "[a-zA-Z]\\w*", ce = "[a-zA-Z_]\\w*", Se = "\\b\\d+(\\.\
     /[A-Za-z][a-z]{2,}/
     // allow capitalized words at beginning of sentences
   );
-  return f.contains.push(
+  mode.contains.push(
     {
       // TODO: how to include ", (, ) without breaking grammars that use these for
       // comment delimiters?
@@ -322,30 +422,38 @@ const st = /\b\B/, Re = "[a-zA-Z]\\w*", ce = "[a-zA-Z_]\\w*", Se = "\\b\\d+(\\.\
       //
       // for a visual example please see:
       // https://github.com/highlightjs/highlight.js/issues/2827
-      begin: L(
+      begin: concat(
         /[ ]+/,
         // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
         "(",
-        b,
+        ENGLISH_WORD,
         /[.]?[:]?([.][ ]|[ ])/,
         "){3}"
       )
       // look for 3 words in a row
     }
-  ), f;
-}, ut = Y("//", "$"), ft = Y("/\\*", "\\*/"), gt = Y("#", "$"), ht = {
+  );
+  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: Se,
+  begin: NUMBER_RE,
   relevance: 0
-}, dt = {
+};
+const C_NUMBER_MODE = {
   scope: "number",
-  begin: Ne,
+  begin: C_NUMBER_RE,
   relevance: 0
-}, pt = {
+};
+const BINARY_NUMBER_MODE = {
   scope: "number",
-  begin: Ae,
+  begin: BINARY_NUMBER_RE,
   relevance: 0
-}, Et = {
+};
+const REGEXP_MODE = {
   // this outer rule makes sure we actually have a WHOLE regex and not simply
   // an expression such as:
   //
@@ -359,106 +467,136 @@ const st = /\b\B/, Re = "[a-zA-Z]\\w*", ce = "[a-zA-Z_]\\w*", Se = "\\b\\d+(\\.\
     end: /\/[gimuy]*/,
     illegal: /\n/,
     contains: [
-      P,
+      BACKSLASH_ESCAPE,
       {
         begin: /\[/,
         end: /\]/,
         relevance: 0,
-        contains: [P]
+        contains: [BACKSLASH_ESCAPE]
       }
     ]
   }]
-}, bt = {
+};
+const TITLE_MODE = {
   scope: "title",
-  begin: Re,
+  begin: IDENT_RE,
   relevance: 0
-}, _t = {
+};
+const UNDERSCORE_TITLE_MODE = {
   scope: "title",
-  begin: ce,
+  begin: UNDERSCORE_IDENT_RE,
   relevance: 0
-}, wt = {
+};
+const METHOD_GUARD = {
   // excludes method names from keyword processing
-  begin: "\\.\\s*" + ce,
+  begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
   relevance: 0
-}, Mt = function(e) {
+};
+const END_SAME_AS_BEGIN = function(mode) {
   return Object.assign(
-    e,
+    mode,
     {
       /** @type {ModeCallback} */
-      "on:begin": (t, i) => {
-        i.data._beginMatch = t[1];
+      "on:begin": (m, resp) => {
+        resp.data._beginMatch = m[1];
       },
       /** @type {ModeCallback} */
-      "on:end": (t, i) => {
-        i.data._beginMatch !== t[1] && i.ignoreMatch();
+      "on:end": (m, resp) => {
+        if (resp.data._beginMatch !== m[1])
+          resp.ignoreMatch();
       }
     }
   );
 };
-var F = /* @__PURE__ */ Object.freeze({
+var MODES = /* @__PURE__ */ Object.freeze({
   __proto__: null,
-  MATCH_NOTHING_RE: st,
-  IDENT_RE: Re,
-  UNDERSCORE_IDENT_RE: ce,
-  NUMBER_RE: Se,
-  C_NUMBER_RE: Ne,
-  BINARY_NUMBER_RE: Ae,
-  RE_STARTERS_RE: rt,
-  SHEBANG: ct,
-  BACKSLASH_ESCAPE: P,
-  APOS_STRING_MODE: ot,
-  QUOTE_STRING_MODE: at,
-  PHRASAL_WORDS_MODE: lt,
-  COMMENT: Y,
-  C_LINE_COMMENT_MODE: ut,
-  C_BLOCK_COMMENT_MODE: ft,
-  HASH_COMMENT_MODE: gt,
-  NUMBER_MODE: ht,
-  C_NUMBER_MODE: dt,
-  BINARY_NUMBER_MODE: pt,
-  REGEXP_MODE: Et,
-  TITLE_MODE: bt,
-  UNDERSCORE_TITLE_MODE: _t,
-  METHOD_GUARD: wt,
-  END_SAME_AS_BEGIN: Mt
+  MATCH_NOTHING_RE,
+  IDENT_RE,
+  UNDERSCORE_IDENT_RE,
+  NUMBER_RE,
+  C_NUMBER_RE,
+  BINARY_NUMBER_RE,
+  RE_STARTERS_RE,
+  SHEBANG,
+  BACKSLASH_ESCAPE,
+  APOS_STRING_MODE,
+  QUOTE_STRING_MODE,
+  PHRASAL_WORDS_MODE,
+  COMMENT,
+  C_LINE_COMMENT_MODE,
+  C_BLOCK_COMMENT_MODE,
+  HASH_COMMENT_MODE,
+  NUMBER_MODE,
+  C_NUMBER_MODE,
+  BINARY_NUMBER_MODE,
+  REGEXP_MODE,
+  TITLE_MODE,
+  UNDERSCORE_TITLE_MODE,
+  METHOD_GUARD,
+  END_SAME_AS_BEGIN
 });
-function xt(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 Ot(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 yt(e, t) {
-  t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = xt, 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 Rt(e, t) {
-  Array.isArray(e.illegal) && (e.illegal = se(...e.illegal));
+function compileIllegal(mode, _parent) {
+  if (!Array.isArray(mode.illegal))
+    return;
+  mode.illegal = either(...mode.illegal);
 }
-function St(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 Nt(e, t) {
-  e.relevance === void 0 && (e.relevance = 1);
+function compileRelevance(mode, _parent) {
+  if (mode.relevance === void 0)
+    mode.relevance = 1;
 }
-const At = (e, t) => {
-  if (!e.beforeMatch)
+const beforeMatchExt = (mode, parent) => {
+  if (!mode.beforeMatch)
     return;
-  if (e.starts)
+  if (mode.starts)
     throw new Error("beforeMatch cannot be used with starts");
-  const i = Object.assign({}, e);
-  Object.keys(e).forEach((f) => {
-    delete e[f];
-  }), e.keywords = i.keywords, e.begin = L(i.beforeMatch, Oe(i.begin)), e.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;
-}, kt = [
+  };
+  mode.relevance = 0;
+  delete originalMode.beforeMatch;
+};
+const COMMON_KEYWORDS = [
   "of",
   "and",
   "for",
@@ -473,106 +611,174 @@ const At = (e, t) => {
   // common variable name
   "value"
   // common variable name
-], Tt = "keyword";
-function ke(e, t, i = Tt) {
-  const f = /* @__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(
-      f,
-      ke(e[_], t, _)
-    );
-  }), f;
-  function b(_, c) {
-    t && (c = c.map((r) => r.toLowerCase())), c.forEach(function(r) {
-      const l = r.split("|");
-      f[l[0]] = [_, It(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 It(e, t) {
-  return t ? Number(t) : vt(e) ? 0 : 1;
+function scoreForKeyword(keyword, providedScore) {
+  if (providedScore) {
+    return Number(providedScore);
+  }
+  return commonKeyword(keyword) ? 0 : 1;
 }
-function vt(e) {
-  return kt.includes(e.toLowerCase());
+function commonKeyword(keyword) {
+  return COMMON_KEYWORDS.includes(keyword.toLowerCase());
 }
-const be = {}, D = (e) => {
-  console.error(e);
-}, _e = (e, ...t) => {
-  console.log(`WARN: ${e}`, ...t);
-}, C = (e, t) => {
-  be[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), be[`${e}/${t}`] = !0);
-}, X = new Error();
-function Te(e, t, { key: i }) {
-  let f = 0;
-  const b = e[i], _ = {}, c = {};
-  for (let r = 1; r <= t.length; r++)
-    c[r + f] = b[r], _[r + f] = !0, f += ye(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 Bt(e) {
-  if (Array.isArray(e.begin)) {
-    if (e.skip || e.excludeBegin || e.returnBegin)
-      throw D("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), X;
-    if (typeof e.beginScope != "object" || e.beginScope === null)
-      throw D("beginScope must be object"), X;
-    Te(e, e.begin, { key: "beginScope" }), e.begin = re(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 Dt(e) {
-  if (Array.isArray(e.end)) {
-    if (e.skip || e.excludeEnd || e.returnEnd)
-      throw D("skip, excludeEnd, returnEnd not compatible with endScope: {}"), X;
-    if (typeof e.endScope != "object" || e.endScope === null)
-      throw D("endScope must be object"), X;
-    Te(e, e.end, { key: "endScope" }), e.end = re(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 Lt(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 Ct(e) {
-  Lt(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Bt(e), Dt(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 Ht(e) {
-  function t(c, r) {
+function compileLanguage(language) {
+  function langRe(value, global) {
     return new RegExp(
-      j(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 += ye(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(re(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((H, Z) => Z > 0 && H !== void 0), w = this.matchIndexes[x];
-      return l.splice(0, x), Object.assign(l, w);
+      }
+      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 f {
+  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, w]) => l.addRule(x, w)), 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;
@@ -581,89 +787,173 @@ function Ht(e) {
       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 w = this.getMatcher(0);
-        w.lastIndex = this.lastIndex + 1, x = w.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);
+        }
       }
-      return x && (this.regexIndex += x.position + 1, this.regexIndex === this.count && this.considerAll()), x;
+      if (result) {
+        this.regexIndex += result.position + 1;
+        if (this.regexIndex === this.count) {
+          this.considerAll();
+        }
+      }
+      return result;
     }
   }
-  function b(c) {
-    const r = new f();
-    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;
     [
-      Ot,
+      scopeClassName,
       // do this early so compiler extensions generally don't have to worry about
       // the distinction between match/begin
-      St,
-      Ct,
-      At
-    ].forEach((w) => w(c, r)), e.compilerExtensions.forEach((w) => w(c, r)), c.__beforeBegin = null, [
-      yt,
+      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.
-      Rt,
+      compileIllegal,
       // default to 1 relevance if not specified
-      Nt
-    ].forEach((w) => w(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 = ke(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 = j(l.end) || "", c.endsWithParent && r.terminatorEnd && (l.terminatorEnd += (c.end ? "|" : "") + r.terminatorEnd)), c.illegal && (l.illegalRe = t(
-      /** @type {RegExp | string} */
-      c.illegal
-    )), c.contains || (c.contains = []), c.contains = [].concat(...c.contains.map(function(w) {
-      return jt(w === "self" ? c : w);
-    })), c.contains.forEach(function(w) {
-      _(
+      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 */
-        w,
-        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 = v(e.classNameAliases || {}), _(
+  }
+  language.classNameAliases = inherit$1(language.classNameAliases || {});
+  return compileMode(
     /** @type Mode */
-    e
+    language
   );
 }
-function Ie(e) {
-  return e ? e.endsWithParent || Ie(e.starts) : !1;
+function dependencyOnParent(mode) {
+  if (!mode)
+    return false;
+  return mode.endsWithParent || dependencyOnParent(mode.starts);
 }
-function jt(e) {
-  return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
-    return v(e, { variants: null }, t);
-  })), e.cachedVariants ? e.cachedVariants : Ie(e) ? v(e, { starts: e.starts ? v(e.starts) : null }) : Object.isFrozen(e) ? v(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 Pt = "11.7.0";
-class Ut extends Error {
-  constructor(t, i) {
-    super(t), this.name = "HTMLInjectionError", this.html = i;
+var version = "11.7.0";
+class HTMLInjectionError extends Error {
+  constructor(reason, html) {
+    super(reason);
+    this.name = "HTMLInjectionError";
+    this.html = html;
   }
 }
-const ee = xe, we = v, Me = Symbol("nomatch"), $t = 7, Gt = function(e) {
-  const t = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null), f = [];
-  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-",
@@ -671,394 +961,613 @@ const ee = xe, we = v, Me = Symbol("nomatch"), $t = 7, Gt = function(e) {
     languages: null,
     // beta configuration options, subject to change, welcome to discuss
     // https://github.com/highlightjs/highlight.js/issues/1086
-    __emitter: Qe
+    __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 = A(h[1]);
-      return p || (_e(_.replace("{}", h[1])), _e("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) || A(p));
-  }
-  function w(n, a, h) {
-    let p = "", M = "";
-    typeof a == "object" ? (p = n, h = a.ignoreIllegals, M = a.language) : (C("10.7.0", "highlight(lang, code, ...args) has been deprecated."), C("10.7.0", `Please use highlight(code, options) instead.
-https://github.com/highlightjs/highlight.js/issues/2277`), M = n, p = a), h === void 0 && (h = !0);
-    const S = {
-      code: p,
-      language: M
+    const context = {
+      code,
+      language: languageName
     };
-    G("before:highlight", S);
-    const k = S.result ? S.result : H(S.language, S.code, h);
-    return k.code = S.code, G("after:highlight", k), k;
-  }
-  function H(n, a, h, p) {
-    const M = /* @__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 k() {
-      if (!u.keywords) {
-        O.addText(E);
+    function processKeywords() {
+      if (!top.keywords) {
+        emitter.addText(modeBuffer);
         return;
       }
-      let s = 0;
-      u.keywordPatternRe.lastIndex = 0;
-      let o = u.keywordPatternRe.exec(E), g = "";
-      for (; o; ) {
-        g += E.substring(s, o.index);
-        const d = I.case_insensitive ? o[0].toLowerCase() : o[0], y = S(u, d);
-        if (y) {
-          const [N, Ye] = y;
-          if (O.addText(g), g = "", M[d] = (M[d] || 0) + 1, M[d] <= $t && (z += Ye), N.startsWith("_"))
-            g += o[0];
-          else {
-            const Ze = I.classNameAliases[N] || N;
-            O.addKeyword(o[0], Ze);
+      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;
+            emitter.addKeyword(match[0], cssClass);
           }
-        } else
-          g += o[0];
-        s = u.keywordPatternRe.lastIndex, o = u.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 K() {
-      if (E === "")
+    function processSubLanguage() {
+      if (modeBuffer === "")
         return;
-      let s = null;
-      if (typeof u.subLanguage == "string") {
-        if (!t[u.subLanguage]) {
-          O.addText(E);
+      let result2 = null;
+      if (typeof top.subLanguage === "string") {
+        if (!languages[top.subLanguage]) {
+          emitter.addText(modeBuffer);
           return;
         }
-        s = H(u.subLanguage, E, !0, he[u.subLanguage]), he[u.subLanguage] = /** @type {CompiledMode} */
-        s._top;
-      } else
-        s = J(E, u.subLanguage.length ? u.subLanguage : null);
-      u.relevance > 0 && (z += 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 R() {
-      u.subLanguage != null ? K() : k(), E = "";
+    function processBuffer() {
+      if (top.subLanguage != null) {
+        processSubLanguage();
+      } else {
+        processKeywords();
+      }
+      modeBuffer = "";
     }
-    function T(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 y = I.classNameAliases[s[g]] || s[g], N = o[g];
-        y ? O.addKeyword(N, y) : (E = N, k(), E = ""), g++;
+        const klass = language.classNameAliases[scope[i]] || scope[i];
+        const text = match[i];
+        if (klass) {
+          emitter.addKeyword(text, klass);
+        } else {
+          modeBuffer = text;
+          processKeywords();
+          modeBuffer = "";
+        }
+        i++;
       }
     }
-    function ue(s, o) {
-      return s.scope && typeof s.scope == "string" && O.openNode(I.classNameAliases[s.scope] || s.scope), s.beginScope && (s.beginScope._wrap ? (O.addKeyword(E, I.classNameAliases[s.beginScope._wrap] || s.beginScope._wrap), E = "") : s.beginScope._multi && (T(s.beginScope, o), E = "")), u = Object.create(s, { parent: { value: u } }), u;
+    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) {
+          emitter.addKeyword(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 fe(s, o, g) {
-      let d = nt(s.endRe, g);
-      if (d) {
-        if (s["on:end"]) {
-          const y = new de(s);
-          s["on:end"](o, y), y.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 fe(s.parent, o, g);
+      if (mode.endsWithParent) {
+        return endOfMode(mode.parent, match, matchPlusRemainder);
+      }
     }
-    function Ke(s) {
-      return u.matcher.regexIndex === 0 ? (E += s[0], 1) : (m = !0, 0);
+    function doIgnore(lexeme) {
+      if (top.matcher.regexIndex === 0) {
+        modeBuffer += lexeme[0];
+        return 1;
+      } else {
+        resumeScanAtSamePosition = true;
+        return 0;
+      }
     }
-    function We(s) {
-      const o = s[0], g = s.rule, d = new de(g), y = [g.__beforeBegin, g["on:begin"]];
-      for (const N of y)
-        if (N && (N(s, d), d.isMatchIgnored))
-          return Ke(o);
-      return g.skip ? E += o : (g.excludeBegin && (E += o), R(), !g.returnBegin && !g.excludeBegin && (E = o)), ue(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 ze(s) {
-      const o = s[0], g = a.substring(s.index), d = fe(u, s, g);
-      if (!d)
-        return Me;
-      const y = u;
-      u.endScope && u.endScope._wrap ? (R(), O.addKeyword(o, u.endScope._wrap)) : u.endScope && u.endScope._multi ? (R(), T(u.endScope, s)) : y.skip ? E += o : (y.returnEnd || y.excludeEnd || (E += o), R(), y.excludeEnd && (E = o));
-      do
-        u.scope && O.closeNode(), !u.skip && !u.subLanguage && (z += u.relevance), u = u.parent;
-      while (u !== d.parent);
-      return d.starts && ue(d.starts, s), y.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();
+        emitter.addKeyword(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 Fe() {
-      const s = [];
-      for (let o = u; o !== I; 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 W = {};
-    function ge(s, o) {
-      const g = o && o[0];
-      if (E += s, g == null)
-        return R(), 0;
-      if (W.type === "begin" && o.type === "end" && W.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 = W.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 (W = o, o.type === "begin")
-        return We(o);
-      if (o.type === "illegal" && !h) {
-        const d = new Error('Illegal lexeme "' + g + '" for mode "' + (u.scope || "<unnamed>") + '"');
-        throw d.mode = u, d;
-      } else if (o.type === "end") {
-        const d = ze(o);
-        if (d !== Me)
-          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 (Q > 1e5 && Q > 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 I = A(n);
-    if (!I)
-      throw D(_.replace("{}", n)), new Error('Unknown language: "' + n + '"');
-    const Xe = Ht(I);
-    let q = "", u = p || Xe;
-    const he = {}, O = new r.__emitter(r);
-    Fe();
-    let E = "", z = 0, B = 0, Q = 0, m = !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 {
-      for (u.matcher.considerAll(); ; ) {
-        Q++, m ? m = !1 : u.matcher.considerAll(), u.matcher.lastIndex = B;
-        const s = u.matcher.exec(a);
-        if (!s)
+      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 o = a.substring(B, s.index), g = ge(o, s);
-        B = s.index + g;
+        const beforeMatch = codeToHighlight.substring(index, match.index);
+        const processedCount = processLexeme(beforeMatch, match);
+        index = match.index + processedCount;
       }
-      return ge(a.substring(B)), O.closeAllNodes(), O.finalize(), q = O.toHTML(), {
-        language: n,
-        value: q,
-        relevance: z,
-        illegal: !1,
-        _emitter: O,
-        _top: u
+      processLexeme(codeToHighlight.substring(index));
+      emitter.closeAllNodes();
+      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: ee(a),
-          illegal: !0,
+          language: languageName,
+          value: escape(codeToHighlight),
+          illegal: true,
           relevance: 0,
           _illegalBy: {
-            message: s.message,
-            index: B,
-            context: a.slice(B - 100, B + 100),
-            mode: s.mode,
-            resultSoFar: q
+            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: ee(a),
-          illegal: !1,
+          language: languageName,
+          value: escape(codeToHighlight),
+          illegal: false,
           relevance: 0,
-          errorRaised: s,
-          _emitter: O,
-          _top: u
+          errorRaised: err,
+          _emitter: emitter,
+          _top: top
         };
-      throw s;
+      } else {
+        throw err;
+      }
     }
   }
-  function Z(n) {
-    const a = {
-      value: ee(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 J(n, a) {
-    a = a || r.languages || Object.keys(t);
-    const h = Z(n), p = a.filter(A).filter(le).map(
-      (R) => H(R, 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 M = p.sort((R, T) => {
-      if (R.relevance !== T.relevance)
-        return T.relevance - R.relevance;
-      if (R.language && T.language) {
-        if (A(R.language).supersetOf === T.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 (A(T.language).supersetOf === R.language)
+        } else if (getLanguage(b.language).supersetOf === a.language) {
           return -1;
+        }
       }
       return 0;
-    }), [S, k] = M, K = S;
-    return K.secondBest = k, K;
+    });
+    const [best, secondBest] = sorted;
+    const result = best;
+    result.secondBest = secondBest;
+    return result;
   }
-  function ve(n, a, h) {
-    const p = a && i[a] || h;
-    n.classList.add("hljs"), n.classList.add(`language-${p}`);
+  function updateClassName(element, currentLang, resultLang) {
+    const language = currentLang && aliases[currentLang] || resultLang;
+    element.classList.add("hljs");
+    element.classList.add(`language-${language}`);
   }
-  function V(n) {
-    let a = null;
-    const h = x(n);
-    if (l(h))
+  function highlightElement(element) {
+    let node = null;
+    const language = blockLanguage(element);
+    if (shouldNotHighlight(language))
       return;
-    if (G(
+    fire(
       "before:highlightElement",
-      { el: n, language: h }
-    ), 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 Ut(
-        "One of your code blocks includes unescaped HTML.",
-        n.innerHTML
-      );
-    a = n;
-    const p = a.textContent, M = h ? w(p, { language: h, ignoreIllegals: !0 }) : J(p);
-    n.innerHTML = M.value, ve(n, h, M.language), n.result = {
-      language: M.language,
+      { el: element, 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;
+    updateClassName(element, language, result.language);
+    element.result = {
+      language: result.language,
       // TODO: remove with version 11.0
-      re: M.relevance,
-      relevance: M.relevance
-    }, M.secondBest && (n.secondBest = {
-      language: M.secondBest.language,
-      relevance: M.secondBest.relevance
-    }), G("after:highlightElement", { el: n, result: M, text: p });
-  }
-  function Be(n) {
-    r = we(r, n);
-  }
-  const De = () => {
-    $(), C("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 Le() {
-    $(), C("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+  function initHighlightingOnLoad() {
+    highlightAll();
+    deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
   }
-  let oe = !1;
-  function $() {
+  let wantsHighlight = false;
+  function highlightAll() {
     if (document.readyState === "loading") {
-      oe = !0;
+      wantsHighlight = true;
       return;
     }
-    document.querySelectorAll(r.cssSelector).forEach(V);
+    const blocks = document.querySelectorAll(options.cssSelector);
+    blocks.forEach(highlightElement);
+  }
+  function boot() {
+    if (wantsHighlight)
+      highlightAll();
   }
-  function Ce() {
-    oe && $();
+  if (typeof window !== "undefined" && window.addEventListener) {
+    window.addEventListener("DOMContentLoaded", boot, false);
   }
-  typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", Ce, !1);
-  function He(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 && ae(h.aliases, { languageName: n });
   }
-  function je(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 Pe() {
-    return Object.keys(t);
+  function listLanguages() {
+    return Object.keys(languages);
   }
-  function A(n) {
-    return n = (n || "").toLowerCase(), t[n] || t[i[n]];
+  function getLanguage(name) {
+    name = (name || "").toLowerCase();
+    return languages[name] || languages[aliases[name]];
   }
-  function ae(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 le(n) {
-    const a = A(n);
-    return a && !a.disableAutodetect;
+  function autoDetection(name) {
+    const lang = getLanguage(name);
+    return lang && !lang.disableAutodetect;
   }
-  function Ue(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 $e(n) {
-    Ue(n), f.push(n);
+  function addPlugin(plugin) {
+    upgradePluginAPI(plugin);
+    plugins.push(plugin);
   }
-  function G(n, a) {
-    const h = n;
-    f.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 Ge(n) {
-    return C("10.7.0", "highlightBlock will be removed entirely in v12.0"), C("10.7.0", "Please use highlightElement now."), V(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: w,
-    highlightAuto: J,
-    highlightAll: $,
-    highlightElement: V,
+  Object.assign(hljs, {
+    highlight: highlight2,
+    highlightAuto,
+    highlightAll,
+    highlightElement,
     // TODO: Remove with v12 API
-    highlightBlock: Ge,
-    configure: Be,
-    initHighlighting: De,
-    initHighlightingOnLoad: Le,
-    registerLanguage: He,
-    unregisterLanguage: je,
-    listLanguages: Pe,
-    getLanguage: A,
-    registerAliases: ae,
-    autoDetection: le,
-    inherit: we,
-    addPlugin: $e
-  }), e.debugMode = function() {
-    b = !1;
-  }, e.safeMode = function() {
-    b = !0;
-  }, e.versionString = Pt, e.regex = {
-    concat: L,
-    lookahead: Oe,
-    either: se,
-    optional: et,
-    anyNumberOfTimes: me
+    highlightBlock: deprecateHighlightBlock,
+    configure,
+    initHighlighting,
+    initHighlightingOnLoad,
+    registerLanguage,
+    unregisterLanguage,
+    listLanguages,
+    getLanguage,
+    registerAliases,
+    autoDetection,
+    inherit,
+    addPlugin
+  });
+  hljs.debugMode = function() {
+    SAFE_MODE = false;
+  };
+  hljs.safeMode = function() {
+    SAFE_MODE = true;
+  };
+  hljs.versionString = version;
+  hljs.regex = {
+    concat,
+    lookahead,
+    either,
+    optional,
+    anyNumberOfTimes
   };
-  for (const n in F)
-    typeof F[n] == "object" && te.exports(F[n]);
-  return Object.assign(e, F), e;
+  for (const key in MODES) {
+    if (typeof MODES[key] === "object") {
+      deepFreezeEs6.exports(MODES[key]);
+    }
+  }
+  Object.assign(hljs, MODES);
+  return hljs;
 };
-var U = Gt({}), Kt = U;
-U.HighlightJS = U;
-U.default = U;
-const Wt = Kt;
+var highlight = HLJS({});
+var core = highlight;
+highlight.HighlightJS = highlight;
+highlight.default = highlight;
+const HighlightJS = core;
 export {
-  Kt as c,
-  Wt as default
+  core as c,
+  HighlightJS as default
 };