@cas-smartdesign/element-preview 0.2.1 → 0.3.0

package/dist/element-preview.mjs

@@ -1,1079 +1,1071 @@
-import dt from "postcss";
-import ut from "postcss-prefix-selector";
-const gt = "code{white-space:pre}.example{display:flex;flex-wrap:wrap;flex-direction:row;align-items:center;gap:16px}.example>*{flex:1 1 500px}.example .tab-control{overflow:hidden}.example div[role=tab]{cursor:pointer;padding:8px 16px;display:inline-block;font-size:16px;border-bottom:2px solid transparent;background-clip:padding-box;-webkit-user-select:none;user-select:none}.example div[role=tab]:hover{background-color:#1467ba14}.example div[role=tab][selected]{background-color:#1467ba21;border-bottom:2px solid #1467ba}.tab-content{margin:16px 0}.tab-content>pre{padding-top:0}.tab-content.code{max-height:500px;overflow:auto}.tab-content.code pre{margin:0}", ft = "pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-variable,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id{color:#005cc5}.hljs-regexp,.hljs-string,.hljs-meta .hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-comment,.hljs-code,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-tag,.hljs-selector-pseudo{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0}";
-function pt(e) {
-  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+import nn from "postcss";
+import rn from "postcss-prefix-selector";
+const on = "code{white-space:pre}.example{display:flex;flex-wrap:wrap;flex-direction:row;align-items:center;gap:16px}.example>*{flex:1 1 500px}.example .tab-control{overflow:hidden}.example div[role=tab]{cursor:pointer;padding:8px 16px;display:inline-block;font-size:16px;border-bottom:2px solid transparent;background-clip:padding-box;-webkit-user-select:none;user-select:none}.example div[role=tab]:hover{background-color:#1467ba14}.example div[role=tab][selected]{background-color:#1467ba21;border-bottom:2px solid #1467ba}.tab-content{margin:16px 0}.tab-content>pre{padding-top:0}.tab-content.code{max-height:500px;overflow:auto}.tab-content.code pre{margin:0}", sn = "pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-variable,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id{color:#005cc5}.hljs-regexp,.hljs-string,.hljs-meta .hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-comment,.hljs-code,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-tag,.hljs-selector-pseudo{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0}";
+function an(i) {
+  return i && i.__esModule && Object.prototype.hasOwnProperty.call(i, "default") ? i.default : i;
 }
-function Pe(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 n = e[t], i = typeof n;
-    (i === "object" || i === "function") && !Object.isFrozen(n) && Pe(n);
-  }), e;
-}
-class ke {
-  /**
-   * @param {CompiledMode} mode
-   */
-  constructor(t) {
-    t.data === void 0 && (t.data = {}), this.data = t.data, this.isMatchIgnored = !1;
+var He, rt;
+function cn() {
+  if (rt) return He;
+  rt = 1;
+  function i(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 r = e[t], p = typeof r;
+      (p === "object" || p === "function") && !Object.isFrozen(r) && i(r);
+    }), e;
   }
-  ignoreMatch() {
-    this.isMatchIgnored = !0;
+  class s {
+    /**
+     * @param {CompiledMode} mode
+     */
+    constructor(t) {
+      t.data === void 0 && (t.data = {}), this.data = t.data, this.isMatchIgnored = !1;
+    }
+    ignoreMatch() {
+      this.isMatchIgnored = !0;
+    }
   }
-}
-function je(e) {
-  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
-}
-function D(e, ...t) {
-  const n = /* @__PURE__ */ Object.create(null);
-  for (const i in e)
-    n[i] = e[i];
-  return t.forEach(function(i) {
-    for (const u in i)
-      n[u] = i[u];
-  }), /** @type {T} */
-  n;
-}
-const ht = "</span>", ve = (e) => !!e.scope, bt = (e, { prefix: t }) => {
-  if (e.startsWith("language:"))
-    return e.replace("language:", "language-");
-  if (e.includes(".")) {
-    const n = e.split(".");
-    return [
-      `${t}${n.shift()}`,
-      ...n.map((i, u) => `${i}${"_".repeat(u + 1)}`)
-    ].join(" ");
+  function c(e) {
+    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
   }
-  return `${t}${e}`;
-};
-class Et {
-  /**
-   * Creates a new HTMLRenderer
-   *
-   * @param {Tree} parseTree - the parse tree (must support `walk` API)
-   * @param {{classPrefix: string}} options
-   */
-  constructor(t, n) {
-    this.buffer = "", this.classPrefix = n.classPrefix, t.walk(this);
+  function g(e, ...t) {
+    const r = /* @__PURE__ */ Object.create(null);
+    for (const p in e)
+      r[p] = e[p];
+    return t.forEach(function(p) {
+      for (const N in p)
+        r[N] = p[N];
+    }), /** @type {T} */
+    r;
   }
-  /**
-   * Adds texts to the output stream
-   *
-   * @param {string} text */
-  addText(t) {
-    this.buffer += je(t);
+  const E = "</span>", w = (e) => !!e.scope, S = (e, { prefix: t }) => {
+    if (e.startsWith("language:"))
+      return e.replace("language:", "language-");
+    if (e.includes(".")) {
+      const r = e.split(".");
+      return [
+        `${t}${r.shift()}`,
+        ...r.map((p, N) => `${p}${"_".repeat(N + 1)}`)
+      ].join(" ");
+    }
+    return `${t}${e}`;
+  };
+  class M {
+    /**
+     * Creates a new HTMLRenderer
+     *
+     * @param {Tree} parseTree - the parse tree (must support `walk` API)
+     * @param {{classPrefix: string}} options
+     */
+    constructor(t, r) {
+      this.buffer = "", this.classPrefix = r.classPrefix, t.walk(this);
+    }
+    /**
+     * Adds texts to the output stream
+     *
+     * @param {string} text */
+    addText(t) {
+      this.buffer += c(t);
+    }
+    /**
+     * Adds a node open to the output stream (if needed)
+     *
+     * @param {Node} node */
+    openNode(t) {
+      if (!w(t)) return;
+      const r = S(
+        t.scope,
+        { prefix: this.classPrefix }
+      );
+      this.span(r);
+    }
+    /**
+     * Adds a node close to the output stream (if needed)
+     *
+     * @param {Node} node */
+    closeNode(t) {
+      w(t) && (this.buffer += E);
+    }
+    /**
+     * returns the accumulated buffer
+    */
+    value() {
+      return this.buffer;
+    }
+    // helpers
+    /**
+     * Builds a span element
+     *
+     * @param {string} className */
+    span(t) {
+      this.buffer += `<span class="${t}">`;
+    }
   }
-  /**
-   * Adds a node open to the output stream (if needed)
-   *
-   * @param {Node} node */
-  openNode(t) {
-    if (!ve(t))
-      return;
-    const n = bt(
-      t.scope,
-      { prefix: this.classPrefix }
-    );
-    this.span(n);
+  const D = (e = {}) => {
+    const t = { children: [] };
+    return Object.assign(t, e), t;
+  };
+  class T {
+    constructor() {
+      this.rootNode = D(), this.stack = [this.rootNode];
+    }
+    get top() {
+      return this.stack[this.stack.length - 1];
+    }
+    get root() {
+      return this.rootNode;
+    }
+    /** @param {Node} node */
+    add(t) {
+      this.top.children.push(t);
+    }
+    /** @param {string} scope */
+    openNode(t) {
+      const r = D({ scope: t });
+      this.add(r), this.stack.push(r);
+    }
+    closeNode() {
+      if (this.stack.length > 1)
+        return this.stack.pop();
+    }
+    closeAllNodes() {
+      for (; this.closeNode(); ) ;
+    }
+    toJSON() {
+      return JSON.stringify(this.rootNode, null, 4);
+    }
+    /**
+     * @typedef { import("./html_renderer").Renderer } Renderer
+     * @param {Renderer} builder
+     */
+    walk(t) {
+      return this.constructor._walk(t, this.rootNode);
+    }
+    /**
+     * @param {Renderer} builder
+     * @param {Node} node
+     */
+    static _walk(t, r) {
+      return typeof r == "string" ? t.addText(r) : r.children && (t.openNode(r), r.children.forEach((p) => this._walk(t, p)), t.closeNode(r)), t;
+    }
+    /**
+     * @param {Node} node
+     */
+    static _collapse(t) {
+      typeof t != "string" && t.children && (t.children.every((r) => typeof r == "string") ? t.children = [t.children.join("")] : t.children.forEach((r) => {
+        T._collapse(r);
+      }));
+    }
   }
-  /**
-   * Adds a node close to the output stream (if needed)
-   *
-   * @param {Node} node */
-  closeNode(t) {
-    ve(t) && (this.buffer += ht);
+  class Z extends T {
+    /**
+     * @param {*} options
+     */
+    constructor(t) {
+      super(), this.options = t;
+    }
+    /**
+     * @param {string} text
+     */
+    addText(t) {
+      t !== "" && this.add(t);
+    }
+    /** @param {string} scope */
+    startScope(t) {
+      this.openNode(t);
+    }
+    endScope() {
+      this.closeNode();
+    }
+    /**
+     * @param {Emitter & {root: DataNode}} emitter
+     * @param {string} name
+     */
+    __addSublanguage(t, r) {
+      const p = t.root;
+      r && (p.scope = `language:${r}`), this.add(p);
+    }
+    toHTML() {
+      return new M(this, this.options).value();
+    }
+    finalize() {
+      return this.closeAllNodes(), !0;
+    }
   }
-  /**
-   * returns the accumulated buffer
-  */
-  value() {
-    return this.buffer;
+  function j(e) {
+    return e ? typeof e == "string" ? e : e.source : null;
   }
-  // helpers
-  /**
-   * Builds a span element
-   *
-   * @param {string} className */
-  span(t) {
-    this.buffer += `<span class="${t}">`;
+  function P(e) {
+    return R("(?=", e, ")");
   }
-}
-const Ce = (e = {}) => {
-  const t = { children: [] };
-  return Object.assign(t, e), t;
-};
-class ye {
-  constructor() {
-    this.rootNode = Ce(), this.stack = [this.rootNode];
+  function X(e) {
+    return R("(?:", e, ")*");
   }
-  get top() {
-    return this.stack[this.stack.length - 1];
+  function te(e) {
+    return R("(?:", e, ")?");
   }
-  get root() {
-    return this.rootNode;
+  function R(...e) {
+    return e.map((r) => j(r)).join("");
   }
-  /** @param {Node} node */
-  add(t) {
-    this.top.children.push(t);
+  function ne(e) {
+    const t = e[e.length - 1];
+    return typeof t == "object" && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {};
   }
-  /** @param {string} scope */
-  openNode(t) {
-    const n = Ce({ scope: t });
-    this.add(n), this.stack.push(n);
+  function ie(...e) {
+    return "(" + (ne(e).capture ? "" : "?:") + e.map((p) => j(p)).join("|") + ")";
   }
-  closeNode() {
-    if (this.stack.length > 1)
-      return this.stack.pop();
+  function G(e) {
+    return new RegExp(e.toString() + "|").exec("").length - 1;
   }
-  closeAllNodes() {
-    for (; this.closeNode(); )
-      ;
+  function re(e, t) {
+    const r = e && e.exec(t);
+    return r && r.index === 0;
   }
-  toJSON() {
-    return JSON.stringify(this.rootNode, null, 4);
+  const fe = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+  function Y(e, { joinWith: t }) {
+    let r = 0;
+    return e.map((p) => {
+      r += 1;
+      const N = r;
+      let k = j(p), l = "";
+      for (; k.length > 0; ) {
+        const a = fe.exec(k);
+        if (!a) {
+          l += k;
+          break;
+        }
+        l += k.substring(0, a.index), k = k.substring(a.index + a[0].length), a[0][0] === "\\" && a[1] ? l += "\\" + String(Number(a[1]) + N) : (l += a[0], a[0] === "(" && r++);
+      }
+      return l;
+    }).map((p) => `(${p})`).join(t);
   }
-  /**
-   * @typedef { import("./html_renderer").Renderer } Renderer
-   * @param {Renderer} builder
-   */
-  walk(t) {
-    return this.constructor._walk(t, this.rootNode);
+  const q = /\b\B/, pe = "[a-zA-Z]\\w*", oe = "[a-zA-Z_]\\w*", he = "\\b\\d+(\\.\\d+)?", be = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", me = "\\b(0b[01]+)", Oe = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", Re = (e = {}) => {
+    const t = /^#![ ]*\//;
+    return e.binary && (e.begin = R(
+      t,
+      /.*\b/,
+      e.binary,
+      /\b.*/
+    )), g({
+      scope: "meta",
+      begin: t,
+      end: /$/,
+      relevance: 0,
+      /** @type {ModeCallback} */
+      "on:begin": (r, p) => {
+        r.index !== 0 && p.ignoreMatch();
+      }
+    }, e);
+  }, V = {
+    begin: "\\\\[\\s\\S]",
+    relevance: 0
+  }, Ce = {
+    scope: "string",
+    begin: "'",
+    end: "'",
+    illegal: "\\n",
+    contains: [V]
+  }, Ee = {
+    scope: "string",
+    begin: '"',
+    end: '"',
+    illegal: "\\n",
+    contains: [V]
+  }, Ie = {
+    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/
+  }, C = function(e, t, r = {}) {
+    const p = g(
+      {
+        scope: "comment",
+        begin: e,
+        end: t,
+        contains: []
+      },
+      r
+    );
+    p.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,
+      relevance: 0
+    });
+    const N = ie(
+      // list of common 1 and 2 letter words in English
+      "I",
+      "a",
+      "is",
+      "so",
+      "us",
+      "to",
+      "at",
+      "if",
+      "in",
+      "it",
+      "on",
+      // note: this is not an exhaustive list of contractions, just popular ones
+      /[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
+      // contractions - can't we'd they're let's, etc
+      /[A-Za-z]+[-][a-z]+/,
+      // `no-way`, etc.
+      /[A-Za-z][a-z]{2,}/
+      // allow capitalized words at beginning of sentences
+    );
+    return p.contains.push(
+      {
+        // TODO: how to include ", (, ) without breaking grammars that use these for
+        // comment delimiters?
+        // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+        // ---
+        // this tries to find sequences of 3 english words in a row (without any
+        // "programming" type syntax) this gives us a strong signal that we've
+        // TRULY found a comment - vs perhaps scanning with the wrong language.
+        // It's possible to find something that LOOKS like the start of the
+        // comment - but then if there is no readable text - good chance it is a
+        // false match and not a comment.
+        //
+        // for a visual example please see:
+        // https://github.com/highlightjs/highlight.js/issues/2827
+        begin: R(
+          /[ ]+/,
+          // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+          "(",
+          N,
+          /[.]?[:]?([.][ ]|[ ])/,
+          "){3}"
+        )
+        // look for 3 words in a row
+      }
+    ), p;
+  }, F = C("//", "$"), J = C("/\\*", "\\*/"), se = C("#", "$"), le = {
+    scope: "number",
+    begin: he,
+    relevance: 0
+  }, _e = {
+    scope: "number",
+    begin: be,
+    relevance: 0
+  }, ft = {
+    scope: "number",
+    begin: me,
+    relevance: 0
+  }, pt = {
+    scope: "regexp",
+    begin: /\/(?=[^/\n]*\/)/,
+    end: /\/[gimuy]*/,
+    contains: [
+      V,
+      {
+        begin: /\[/,
+        end: /\]/,
+        relevance: 0,
+        contains: [V]
+      }
+    ]
+  }, ht = {
+    scope: "title",
+    begin: pe,
+    relevance: 0
+  }, bt = {
+    scope: "title",
+    begin: oe,
+    relevance: 0
+  }, mt = {
+    // excludes method names from keyword processing
+    begin: "\\.\\s*" + oe,
+    relevance: 0
+  };
+  var ye = /* @__PURE__ */ Object.freeze({
+    __proto__: null,
+    APOS_STRING_MODE: Ce,
+    BACKSLASH_ESCAPE: V,
+    BINARY_NUMBER_MODE: ft,
+    BINARY_NUMBER_RE: me,
+    COMMENT: C,
+    C_BLOCK_COMMENT_MODE: J,
+    C_LINE_COMMENT_MODE: F,
+    C_NUMBER_MODE: _e,
+    C_NUMBER_RE: be,
+    END_SAME_AS_BEGIN: function(e) {
+      return Object.assign(
+        e,
+        {
+          /** @type {ModeCallback} */
+          "on:begin": (t, r) => {
+            r.data._beginMatch = t[1];
+          },
+          /** @type {ModeCallback} */
+          "on:end": (t, r) => {
+            r.data._beginMatch !== t[1] && r.ignoreMatch();
+          }
+        }
+      );
+    },
+    HASH_COMMENT_MODE: se,
+    IDENT_RE: pe,
+    MATCH_NOTHING_RE: q,
+    METHOD_GUARD: mt,
+    NUMBER_MODE: le,
+    NUMBER_RE: he,
+    PHRASAL_WORDS_MODE: Ie,
+    QUOTE_STRING_MODE: Ee,
+    REGEXP_MODE: pt,
+    RE_STARTERS_RE: Oe,
+    SHEBANG: Re,
+    TITLE_MODE: ht,
+    UNDERSCORE_IDENT_RE: oe,
+    UNDERSCORE_TITLE_MODE: bt
+  });
+  function Et(e, t) {
+    e.input[e.index - 1] === "." && t.ignoreMatch();
   }
-  /**
-   * @param {Renderer} builder
-   * @param {Node} node
-   */
-  static _walk(t, n) {
-    return typeof n == "string" ? t.addText(n) : n.children && (t.openNode(n), n.children.forEach((i) => this._walk(t, i)), t.closeNode(n)), t;
+  function _t(e, t) {
+    e.className !== void 0 && (e.scope = e.className, delete e.className);
   }
-  /**
-   * @param {Node} node
-   */
-  static _collapse(t) {
-    typeof t != "string" && t.children && (t.children.every((n) => typeof n == "string") ? t.children = [t.children.join("")] : t.children.forEach((n) => {
-      ye._collapse(n);
-    }));
+  function yt(e, t) {
+    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = Et, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
   }
-}
-class mt extends ye {
-  /**
-   * @param {*} options
-   */
-  constructor(t) {
-    super(), this.options = t;
+  function xt(e, t) {
+    Array.isArray(e.illegal) && (e.illegal = ie(...e.illegal));
   }
-  /**
-   * @param {string} text
-   */
-  addText(t) {
-    t !== "" && this.add(t);
+  function wt(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;
+    }
   }
-  /** @param {string} scope */
-  startScope(t) {
-    this.openNode(t);
+  function St(e, t) {
+    e.relevance === void 0 && (e.relevance = 1);
   }
-  endScope() {
-    this.closeNode();
+  const Nt = (e, t) => {
+    if (!e.beforeMatch) return;
+    if (e.starts) throw new Error("beforeMatch cannot be used with starts");
+    const r = Object.assign({}, e);
+    Object.keys(e).forEach((p) => {
+      delete e[p];
+    }), e.keywords = r.keywords, e.begin = R(r.beforeMatch, P(r.begin)), e.starts = {
+      relevance: 0,
+      contains: [
+        Object.assign(r, { endsParent: !0 })
+      ]
+    }, e.relevance = 0, delete r.beforeMatch;
+  }, kt = [
+    "of",
+    "and",
+    "for",
+    "in",
+    "not",
+    "or",
+    "if",
+    "then",
+    "parent",
+    // common variable name
+    "list",
+    // common variable name
+    "value"
+    // common variable name
+  ], vt = "keyword";
+  function Ge(e, t, r = vt) {
+    const p = /* @__PURE__ */ Object.create(null);
+    return typeof e == "string" ? N(r, e.split(" ")) : Array.isArray(e) ? N(r, e) : Object.keys(e).forEach(function(k) {
+      Object.assign(
+        p,
+        Ge(e[k], t, k)
+      );
+    }), p;
+    function N(k, l) {
+      t && (l = l.map((a) => a.toLowerCase())), l.forEach(function(a) {
+        const f = a.split("|");
+        p[f[0]] = [k, Mt(f[0], f[1])];
+      });
+    }
   }
-  /**
-   * @param {Emitter & {root: DataNode}} emitter
-   * @param {string} name
-   */
-  __addSublanguage(t, n) {
-    const i = t.root;
-    n && (i.scope = `language:${n}`), this.add(i);
+  function Mt(e, t) {
+    return t ? Number(t) : At(e) ? 0 : 1;
   }
-  toHTML() {
-    return new Et(this, this.options).value();
+  function At(e) {
+    return kt.includes(e.toLowerCase());
   }
-  finalize() {
-    return this.closeAllNodes(), !0;
+  const $e = {}, Q = (e) => {
+    console.error(e);
+  }, Fe = (e, ...t) => {
+    console.log(`WARN: ${e}`, ...t);
+  }, ae = (e, t) => {
+    $e[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), $e[`${e}/${t}`] = !0);
+  }, xe = new Error();
+  function Ke(e, t, { key: r }) {
+    let p = 0;
+    const N = e[r], k = {}, l = {};
+    for (let a = 1; a <= t.length; a++)
+      l[a + p] = N[a], k[a + p] = !0, p += G(t[a - 1]);
+    e[r] = l, e[r]._emit = k, e[r]._multi = !0;
   }
-}
-function J(e) {
-  return e ? typeof e == "string" ? e : e.source : null;
-}
-function Ue(e) {
-  return z("(?=", e, ")");
-}
-function _t(e) {
-  return z("(?:", e, ")*");
-}
-function yt(e) {
-  return z("(?:", e, ")?");
-}
-function z(...e) {
-  return e.map((n) => J(n)).join("");
-}
-function xt(e) {
-  const t = e[e.length - 1];
-  return typeof t == "object" && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {};
-}
-function xe(...e) {
-  return "(" + (xt(e).capture ? "" : "?:") + e.map((i) => J(i)).join("|") + ")";
-}
-function ze(e) {
-  return new RegExp(e.toString() + "|").exec("").length - 1;
-}
-function wt(e, t) {
-  const n = e && e.exec(t);
-  return n && n.index === 0;
-}
-const Nt = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-function we(e, { joinWith: t }) {
-  let n = 0;
-  return e.map((i) => {
-    n += 1;
-    const u = n;
-    let f = J(i), o = "";
-    for (; f.length > 0; ) {
-      const s = Nt.exec(f);
-      if (!s) {
-        o += f;
-        break;
-      }
-      o += f.substring(0, s.index), f = f.substring(s.index + s[0].length), s[0][0] === "\\" && s[1] ? o += "\\" + String(Number(s[1]) + u) : (o += s[0], s[0] === "(" && n++);
-    }
-    return o;
-  }).map((i) => `(${i})`).join(t);
-}
-const St = /\b\B/, He = "[a-zA-Z]\\w*", Ne = "[a-zA-Z_]\\w*", $e = "\\b\\d+(\\.\\d+)?", Ge = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", Fe = "\\b(0b[01]+)", Mt = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", At = (e = {}) => {
-  const t = /^#![ ]*\//;
-  return e.binary && (e.begin = z(
-    t,
-    /.*\b/,
-    e.binary,
-    /\b.*/
-  )), D({
-    scope: "meta",
-    begin: t,
-    end: /$/,
-    relevance: 0,
-    /** @type {ModeCallback} */
-    "on:begin": (n, i) => {
-      n.index !== 0 && i.ignoreMatch();
-    }
-  }, e);
-}, V = {
-  begin: "\\\\[\\s\\S]",
-  relevance: 0
-}, Ot = {
-  scope: "string",
-  begin: "'",
-  end: "'",
-  illegal: "\\n",
-  contains: [V]
-}, Tt = {
-  scope: "string",
-  begin: '"',
-  end: '"',
-  illegal: "\\n",
-  contains: [V]
-}, Rt = {
-  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/
-}, de = function(e, t, n = {}) {
-  const i = D(
-    {
-      scope: "comment",
-      begin: e,
-      end: t,
-      contains: []
-    },
-    n
-  );
-  i.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,
-    relevance: 0
-  });
-  const u = xe(
-    // list of common 1 and 2 letter words in English
-    "I",
-    "a",
-    "is",
-    "so",
-    "us",
-    "to",
-    "at",
-    "if",
-    "in",
-    "it",
-    "on",
-    // note: this is not an exhaustive list of contractions, just popular ones
-    /[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
-    // contractions - can't we'd they're let's, etc
-    /[A-Za-z]+[-][a-z]+/,
-    // `no-way`, etc.
-    /[A-Za-z][a-z]{2,}/
-    // allow capitalized words at beginning of sentences
-  );
-  return i.contains.push(
-    {
-      // TODO: how to include ", (, ) without breaking grammars that use these for
-      // comment delimiters?
-      // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
-      // ---
-      // this tries to find sequences of 3 english words in a row (without any
-      // "programming" type syntax) this gives us a strong signal that we've
-      // TRULY found a comment - vs perhaps scanning with the wrong language.
-      // It's possible to find something that LOOKS like the start of the
-      // comment - but then if there is no readable text - good chance it is a
-      // false match and not a comment.
-      //
-      // for a visual example please see:
-      // https://github.com/highlightjs/highlight.js/issues/2827
-      begin: z(
-        /[ ]+/,
-        // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
-        "(",
-        u,
-        /[.]?[:]?([.][ ]|[ ])/,
-        "){3}"
-      )
-      // look for 3 words in a row
-    }
-  ), i;
-}, kt = de("//", "$"), vt = de("/\\*", "\\*/"), Ct = de("#", "$"), It = {
-  scope: "number",
-  begin: $e,
-  relevance: 0
-}, Lt = {
-  scope: "number",
-  begin: Ge,
-  relevance: 0
-}, Dt = {
-  scope: "number",
-  begin: Fe,
-  relevance: 0
-}, Bt = {
-  scope: "regexp",
-  begin: /\/(?=[^/\n]*\/)/,
-  end: /\/[gimuy]*/,
-  contains: [
-    V,
-    {
-      begin: /\[/,
-      end: /\]/,
-      relevance: 0,
-      contains: [V]
-    }
-  ]
-}, Pt = {
-  scope: "title",
-  begin: He,
-  relevance: 0
-}, jt = {
-  scope: "title",
-  begin: Ne,
-  relevance: 0
-}, Ut = {
-  // excludes method names from keyword processing
-  begin: "\\.\\s*" + Ne,
-  relevance: 0
-}, zt = function(e) {
-  return Object.assign(
-    e,
-    {
-      /** @type {ModeCallback} */
-      "on:begin": (t, n) => {
-        n.data._beginMatch = t[1];
-      },
-      /** @type {ModeCallback} */
-      "on:end": (t, n) => {
-        n.data._beginMatch !== t[1] && n.ignoreMatch();
-      }
+  function Tt(e) {
+    if (Array.isArray(e.begin)) {
+      if (e.skip || e.excludeBegin || e.returnBegin)
+        throw Q("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), xe;
+      if (typeof e.beginScope != "object" || e.beginScope === null)
+        throw Q("beginScope must be object"), xe;
+      Ke(e, e.begin, { key: "beginScope" }), e.begin = Y(e.begin, { joinWith: "" });
     }
-  );
-};
-var oe = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  APOS_STRING_MODE: Ot,
-  BACKSLASH_ESCAPE: V,
-  BINARY_NUMBER_MODE: Dt,
-  BINARY_NUMBER_RE: Fe,
-  COMMENT: de,
-  C_BLOCK_COMMENT_MODE: vt,
-  C_LINE_COMMENT_MODE: kt,
-  C_NUMBER_MODE: Lt,
-  C_NUMBER_RE: Ge,
-  END_SAME_AS_BEGIN: zt,
-  HASH_COMMENT_MODE: Ct,
-  IDENT_RE: He,
-  MATCH_NOTHING_RE: St,
-  METHOD_GUARD: Ut,
-  NUMBER_MODE: It,
-  NUMBER_RE: $e,
-  PHRASAL_WORDS_MODE: Rt,
-  QUOTE_STRING_MODE: Tt,
-  REGEXP_MODE: Bt,
-  RE_STARTERS_RE: Mt,
-  SHEBANG: At,
-  TITLE_MODE: Pt,
-  UNDERSCORE_IDENT_RE: Ne,
-  UNDERSCORE_TITLE_MODE: jt
-});
-function Ht(e, t) {
-  e.input[e.index - 1] === "." && t.ignoreMatch();
-}
-function $t(e, t) {
-  e.className !== void 0 && (e.scope = e.className, delete e.className);
-}
-function Gt(e, t) {
-  t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = Ht, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
-}
-function Ft(e, t) {
-  Array.isArray(e.illegal) && (e.illegal = xe(...e.illegal));
-}
-function Kt(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 Wt(e, t) {
-  e.relevance === void 0 && (e.relevance = 1);
-}
-const Zt = (e, t) => {
-  if (!e.beforeMatch)
-    return;
-  if (e.starts)
-    throw new Error("beforeMatch cannot be used with starts");
-  const n = Object.assign({}, e);
-  Object.keys(e).forEach((i) => {
-    delete e[i];
-  }), e.keywords = n.keywords, e.begin = z(n.beforeMatch, Ue(n.begin)), e.starts = {
-    relevance: 0,
-    contains: [
-      Object.assign(n, { endsParent: !0 })
-    ]
-  }, e.relevance = 0, delete n.beforeMatch;
-}, Xt = [
-  "of",
-  "and",
-  "for",
-  "in",
-  "not",
-  "or",
-  "if",
-  "then",
-  "parent",
-  // common variable name
-  "list",
-  // common variable name
-  "value"
-  // common variable name
-], Yt = "keyword";
-function Ke(e, t, n = Yt) {
-  const i = /* @__PURE__ */ Object.create(null);
-  return typeof e == "string" ? u(n, e.split(" ")) : Array.isArray(e) ? u(n, e) : Object.keys(e).forEach(function(f) {
-    Object.assign(
-      i,
-      Ke(e[f], t, f)
-    );
-  }), i;
-  function u(f, o) {
-    t && (o = o.map((s) => s.toLowerCase())), o.forEach(function(s) {
-      const l = s.split("|");
-      i[l[0]] = [f, qt(l[0], l[1])];
-    });
   }
-}
-function qt(e, t) {
-  return t ? Number(t) : Jt(e) ? 0 : 1;
-}
-function Jt(e) {
-  return Xt.includes(e.toLowerCase());
-}
-const Ie = {}, U = (e) => {
-  console.error(e);
-}, Le = (e, ...t) => {
-  console.log(`WARN: ${e}`, ...t);
-}, F = (e, t) => {
-  Ie[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), Ie[`${e}/${t}`] = !0);
-}, ce = new Error();
-function We(e, t, { key: n }) {
-  let i = 0;
-  const u = e[n], f = {}, o = {};
-  for (let s = 1; s <= t.length; s++)
-    o[s + i] = u[s], f[s + i] = !0, i += ze(t[s - 1]);
-  e[n] = o, e[n]._emit = f, e[n]._multi = !0;
-}
-function Vt(e) {
-  if (Array.isArray(e.begin)) {
-    if (e.skip || e.excludeBegin || e.returnBegin)
-      throw U("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), ce;
-    if (typeof e.beginScope != "object" || e.beginScope === null)
-      throw U("beginScope must be object"), ce;
-    We(e, e.begin, { key: "beginScope" }), e.begin = we(e.begin, { joinWith: "" });
+  function Ot(e) {
+    if (Array.isArray(e.end)) {
+      if (e.skip || e.excludeEnd || e.returnEnd)
+        throw Q("skip, excludeEnd, returnEnd not compatible with endScope: {}"), xe;
+      if (typeof e.endScope != "object" || e.endScope === null)
+        throw Q("endScope must be object"), xe;
+      Ke(e, e.end, { key: "endScope" }), e.end = Y(e.end, { joinWith: "" });
+    }
   }
-}
-function Qt(e) {
-  if (Array.isArray(e.end)) {
-    if (e.skip || e.excludeEnd || e.returnEnd)
-      throw U("skip, excludeEnd, returnEnd not compatible with endScope: {}"), ce;
-    if (typeof e.endScope != "object" || e.endScope === null)
-      throw U("endScope must be object"), ce;
-    We(e, e.end, { key: "endScope" }), e.end = we(e.end, { joinWith: "" });
+  function Rt(e) {
+    e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
   }
-}
-function en(e) {
-  e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
-}
-function tn(e) {
-  en(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Vt(e), Qt(e);
-}
-function nn(e) {
-  function t(o, s) {
-    return new RegExp(
-      J(o),
-      "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (s ? "g" : "")
-    );
+  function Ct(e) {
+    Rt(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Tt(e), Ot(e);
   }
-  class n {
-    constructor() {
-      this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
-    }
-    // @ts-ignore
-    addRule(s, l) {
-      l.position = this.position++, this.matchIndexes[this.matchAt] = l, this.regexes.push([l, s]), this.matchAt += ze(s) + 1;
-    }
-    compile() {
-      this.regexes.length === 0 && (this.exec = () => null);
-      const s = this.regexes.map((l) => l[1]);
-      this.matcherRe = t(we(s, { joinWith: "|" }), !0), this.lastIndex = 0;
-    }
-    /** @param {string} s */
-    exec(s) {
-      this.matcherRe.lastIndex = this.lastIndex;
-      const l = this.matcherRe.exec(s);
-      if (!l)
-        return null;
-      const b = l.findIndex((A, w) => w > 0 && A !== void 0), m = this.matchIndexes[b];
-      return l.splice(0, b), Object.assign(l, m);
+  function It(e) {
+    function t(l, a) {
+      return new RegExp(
+        j(l),
+        "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (a ? "g" : "")
+      );
     }
-  }
-  class i {
-    constructor() {
-      this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
-    }
-    // @ts-ignore
-    getMatcher(s) {
-      if (this.multiRegexes[s])
-        return this.multiRegexes[s];
-      const l = new n();
-      return this.rules.slice(s).forEach(([b, m]) => l.addRule(b, m)), l.compile(), this.multiRegexes[s] = l, l;
-    }
-    resumingScanAtSamePosition() {
-      return this.regexIndex !== 0;
-    }
-    considerAll() {
-      this.regexIndex = 0;
-    }
-    // @ts-ignore
-    addRule(s, l) {
-      this.rules.push([s, l]), l.type === "begin" && this.count++;
-    }
-    /** @param {string} s */
-    exec(s) {
-      const l = this.getMatcher(this.regexIndex);
-      l.lastIndex = this.lastIndex;
-      let b = l.exec(s);
-      if (this.resumingScanAtSamePosition() && !(b && b.index === this.lastIndex)) {
-        const m = this.getMatcher(0);
-        m.lastIndex = this.lastIndex + 1, b = m.exec(s);
+    class r {
+      constructor() {
+        this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+      }
+      // @ts-ignore
+      addRule(a, f) {
+        f.position = this.position++, this.matchIndexes[this.matchAt] = f, this.regexes.push([f, a]), this.matchAt += G(a) + 1;
+      }
+      compile() {
+        this.regexes.length === 0 && (this.exec = () => null);
+        const a = this.regexes.map((f) => f[1]);
+        this.matcherRe = t(Y(a, { joinWith: "|" }), !0), this.lastIndex = 0;
+      }
+      /** @param {string} s */
+      exec(a) {
+        this.matcherRe.lastIndex = this.lastIndex;
+        const f = this.matcherRe.exec(a);
+        if (!f)
+          return null;
+        const O = f.findIndex((de, De) => De > 0 && de !== void 0), v = this.matchIndexes[O];
+        return f.splice(0, O), Object.assign(f, v);
       }
-      return b && (this.regexIndex += b.position + 1, this.regexIndex === this.count && this.considerAll()), b;
     }
-  }
-  function u(o) {
-    const s = new i();
-    return o.contains.forEach((l) => s.addRule(l.begin, { rule: l, type: "begin" })), o.terminatorEnd && s.addRule(o.terminatorEnd, { type: "end" }), o.illegal && s.addRule(o.illegal, { type: "illegal" }), s;
-  }
-  function f(o, s) {
-    const l = (
-      /** @type CompiledMode */
-      o
-    );
-    if (o.isCompiled)
-      return l;
-    [
-      $t,
-      // do this early so compiler extensions generally don't have to worry about
-      // the distinction between match/begin
-      Kt,
-      tn,
-      Zt
-    ].forEach((m) => m(o, s)), e.compilerExtensions.forEach((m) => m(o, s)), o.__beforeBegin = null, [
-      Gt,
-      // do this later so compiler extensions that come earlier have access to the
-      // raw array if they wanted to perhaps manipulate it, etc.
-      Ft,
-      // default to 1 relevance if not specified
-      Wt
-    ].forEach((m) => m(o, s)), o.isCompiled = !0;
-    let b = null;
-    return typeof o.keywords == "object" && o.keywords.$pattern && (o.keywords = Object.assign({}, o.keywords), b = o.keywords.$pattern, delete o.keywords.$pattern), b = b || /\w+/, o.keywords && (o.keywords = Ke(o.keywords, e.case_insensitive)), l.keywordPatternRe = t(b, !0), s && (o.begin || (o.begin = /\B|\b/), l.beginRe = t(l.begin), !o.end && !o.endsWithParent && (o.end = /\B|\b/), o.end && (l.endRe = t(l.end)), l.terminatorEnd = J(l.end) || "", o.endsWithParent && s.terminatorEnd && (l.terminatorEnd += (o.end ? "|" : "") + s.terminatorEnd)), o.illegal && (l.illegalRe = t(
-      /** @type {RegExp | string} */
-      o.illegal
-    )), o.contains || (o.contains = []), o.contains = [].concat(...o.contains.map(function(m) {
-      return rn(m === "self" ? o : m);
-    })), o.contains.forEach(function(m) {
-      f(
-        /** @type Mode */
-        m,
+    class p {
+      constructor() {
+        this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+      }
+      // @ts-ignore
+      getMatcher(a) {
+        if (this.multiRegexes[a]) return this.multiRegexes[a];
+        const f = new r();
+        return this.rules.slice(a).forEach(([O, v]) => f.addRule(O, v)), f.compile(), this.multiRegexes[a] = f, f;
+      }
+      resumingScanAtSamePosition() {
+        return this.regexIndex !== 0;
+      }
+      considerAll() {
+        this.regexIndex = 0;
+      }
+      // @ts-ignore
+      addRule(a, f) {
+        this.rules.push([a, f]), f.type === "begin" && this.count++;
+      }
+      /** @param {string} s */
+      exec(a) {
+        const f = this.getMatcher(this.regexIndex);
+        f.lastIndex = this.lastIndex;
+        let O = f.exec(a);
+        if (this.resumingScanAtSamePosition() && !(O && O.index === this.lastIndex)) {
+          const v = this.getMatcher(0);
+          v.lastIndex = this.lastIndex + 1, O = v.exec(a);
+        }
+        return O && (this.regexIndex += O.position + 1, this.regexIndex === this.count && this.considerAll()), O;
+      }
+    }
+    function N(l) {
+      const a = new p();
+      return l.contains.forEach((f) => a.addRule(f.begin, { rule: f, type: "begin" })), l.terminatorEnd && a.addRule(l.terminatorEnd, { type: "end" }), l.illegal && a.addRule(l.illegal, { type: "illegal" }), a;
+    }
+    function k(l, a) {
+      const f = (
+        /** @type CompiledMode */
         l
       );
-    }), o.starts && f(o.starts, s), l.matcher = u(l), l;
+      if (l.isCompiled) return f;
+      [
+        _t,
+        // do this early so compiler extensions generally don't have to worry about
+        // the distinction between match/begin
+        wt,
+        Ct,
+        Nt
+      ].forEach((v) => v(l, a)), e.compilerExtensions.forEach((v) => v(l, a)), l.__beforeBegin = null, [
+        yt,
+        // do this later so compiler extensions that come earlier have access to the
+        // raw array if they wanted to perhaps manipulate it, etc.
+        xt,
+        // default to 1 relevance if not specified
+        St
+      ].forEach((v) => v(l, a)), l.isCompiled = !0;
+      let O = null;
+      return typeof l.keywords == "object" && l.keywords.$pattern && (l.keywords = Object.assign({}, l.keywords), O = l.keywords.$pattern, delete l.keywords.$pattern), O = O || /\w+/, l.keywords && (l.keywords = Ge(l.keywords, e.case_insensitive)), f.keywordPatternRe = t(O, !0), a && (l.begin || (l.begin = /\B|\b/), f.beginRe = t(f.begin), !l.end && !l.endsWithParent && (l.end = /\B|\b/), l.end && (f.endRe = t(f.end)), f.terminatorEnd = j(f.end) || "", l.endsWithParent && a.terminatorEnd && (f.terminatorEnd += (l.end ? "|" : "") + a.terminatorEnd)), l.illegal && (f.illegalRe = t(
+        /** @type {RegExp | string} */
+        l.illegal
+      )), l.contains || (l.contains = []), l.contains = [].concat(...l.contains.map(function(v) {
+        return Lt(v === "self" ? l : v);
+      })), l.contains.forEach(function(v) {
+        k(
+          /** @type Mode */
+          v,
+          f
+        );
+      }), l.starts && k(l.starts, a), f.matcher = N(f), f;
+    }
+    if (e.compilerExtensions || (e.compilerExtensions = []), e.contains && e.contains.includes("self"))
+      throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+    return e.classNameAliases = g(e.classNameAliases || {}), k(
+      /** @type Mode */
+      e
+    );
   }
-  if (e.compilerExtensions || (e.compilerExtensions = []), e.contains && e.contains.includes("self"))
-    throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
-  return e.classNameAliases = D(e.classNameAliases || {}), f(
-    /** @type Mode */
-    e
-  );
-}
-function Ze(e) {
-  return e ? e.endsWithParent || Ze(e.starts) : !1;
-}
-function rn(e) {
-  return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
-    return D(e, { variants: null }, t);
-  })), e.cachedVariants ? e.cachedVariants : Ze(e) ? D(e, { starts: e.starts ? D(e.starts) : null }) : Object.isFrozen(e) ? D(e) : e;
-}
-var sn = "11.9.0";
-class on extends Error {
-  constructor(t, n) {
-    super(t), this.name = "HTMLInjectionError", this.html = n;
+  function We(e) {
+    return e ? e.endsWithParent || We(e.starts) : !1;
   }
-}
-const _e = je, De = D, Be = Symbol("nomatch"), an = 7, Xe = function(e) {
-  const t = /* @__PURE__ */ Object.create(null), n = /* @__PURE__ */ Object.create(null), i = [];
-  let u = !0;
-  const f = "Could not find the language '{}', did you forget to load/include a language module?", o = { disableAutodetect: !0, name: "Plain text", contains: [] };
-  let s = {
-    ignoreUnescapedHTML: !1,
-    throwUnescapedHTML: !1,
-    noHighlightRe: /^(no-?highlight)$/i,
-    languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
-    classPrefix: "hljs-",
-    cssSelector: "pre code",
-    languages: null,
-    // beta configuration options, subject to change, welcome to discuss
-    // https://github.com/highlightjs/highlight.js/issues/1086
-    __emitter: mt
-  };
-  function l(r) {
-    return s.noHighlightRe.test(r);
+  function Lt(e) {
+    return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
+      return g(e, { variants: null }, t);
+    })), e.cachedVariants ? e.cachedVariants : We(e) ? g(e, { starts: e.starts ? g(e.starts) : null }) : Object.isFrozen(e) ? g(e) : e;
   }
-  function b(r) {
-    let c = r.className + " ";
-    c += r.parentNode ? r.parentNode.className : "";
-    const p = s.languageDetectRe.exec(c);
-    if (p) {
-      const E = R(p[1]);
-      return E || (Le(f.replace("{}", p[1])), Le("Falling back to no-highlight mode for this block.", r)), E ? p[1] : "no-highlight";
-    }
-    return c.split(/\s+/).find((E) => l(E) || R(E));
+  var Dt = "11.11.1";
+  class Bt extends Error {
+    constructor(t, r) {
+      super(t), this.name = "HTMLInjectionError", this.html = r;
+    }
   }
-  function m(r, c, p) {
-    let E = "", x = "";
-    typeof c == "object" ? (E = r, p = c.ignoreIllegals, x = c.language) : (F("10.7.0", "highlight(lang, code, ...args) has been deprecated."), F("10.7.0", `Please use highlight(code, options) instead.
-https://github.com/highlightjs/highlight.js/issues/2277`), x = r, E = c), p === void 0 && (p = !0);
-    const M = {
-      code: E,
-      language: x
+  const Le = c, Ze = g, Xe = Symbol("nomatch"), Pt = 7, Ye = function(e) {
+    const t = /* @__PURE__ */ Object.create(null), r = /* @__PURE__ */ Object.create(null), p = [];
+    let N = !0;
+    const k = "Could not find the language '{}', did you forget to load/include a language module?", l = { disableAutodetect: !0, name: "Plain text", contains: [] };
+    let a = {
+      ignoreUnescapedHTML: !1,
+      throwUnescapedHTML: !1,
+      noHighlightRe: /^(no-?highlight)$/i,
+      languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+      classPrefix: "hljs-",
+      cssSelector: "pre code",
+      languages: null,
+      // beta configuration options, subject to change, welcome to discuss
+      // https://github.com/highlightjs/highlight.js/issues/1086
+      __emitter: Z
     };
-    G("before:highlight", M);
-    const T = M.result ? M.result : A(M.language, M.code, p);
-    return T.code = M.code, G("after:highlight", T), T;
-  }
-  function A(r, c, p, E) {
-    const x = /* @__PURE__ */ Object.create(null);
-    function M(a, d) {
-      return a.keywords[d];
-    }
-    function T() {
-      if (!g.keywords) {
-        N.addText(y);
-        return;
-      }
-      let a = 0;
-      g.keywordPatternRe.lastIndex = 0;
-      let d = g.keywordPatternRe.exec(y), h = "";
-      for (; d; ) {
-        h += y.substring(a, d.index);
-        const _ = v.case_insensitive ? d[0].toLowerCase() : d[0], S = M(g, _);
-        if (S) {
-          const [I, ct] = S;
-          if (N.addText(h), h = "", x[_] = (x[_] || 0) + 1, x[_] <= an && (se += ct), I.startsWith("_"))
-            h += d[0];
-          else {
-            const lt = v.classNameAliases[I] || I;
-            k(d[0], lt);
-          }
-        } else
-          h += d[0];
-        a = g.keywordPatternRe.lastIndex, d = g.keywordPatternRe.exec(y);
+    function f(n) {
+      return a.noHighlightRe.test(n);
+    }
+    function O(n) {
+      let u = n.className + " ";
+      u += n.parentNode ? n.parentNode.className : "";
+      const m = a.languageDetectRe.exec(u);
+      if (m) {
+        const y = K(m[1]);
+        return y || (Fe(k.replace("{}", m[1])), Fe("Falling back to no-highlight mode for this block.", n)), y ? m[1] : "no-highlight";
       }
-      h += y.substring(a), N.addText(h);
+      return u.split(/\s+/).find((y) => f(y) || K(y));
     }
-    function ie() {
-      if (y === "")
-        return;
-      let a = null;
-      if (typeof g.subLanguage == "string") {
-        if (!t[g.subLanguage]) {
-          N.addText(y);
+    function v(n, u, m) {
+      let y = "", A = "";
+      typeof u == "object" ? (y = n, m = u.ignoreIllegals, A = u.language) : (ae("10.7.0", "highlight(lang, code, ...args) has been deprecated."), ae("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`), A = n, y = u), m === void 0 && (m = !0);
+      const z = {
+        code: y,
+        language: A
+      };
+      Se("before:highlight", z);
+      const W = z.result ? z.result : de(z.language, z.code, m);
+      return W.code = z.code, Se("after:highlight", W), W;
+    }
+    function de(n, u, m, y) {
+      const A = /* @__PURE__ */ Object.create(null);
+      function z(o, d) {
+        return o.keywords[d];
+      }
+      function W() {
+        if (!h.keywords) {
+          I.addText(x);
           return;
         }
-        a = A(g.subLanguage, y, !0, Re[g.subLanguage]), Re[g.subLanguage] = /** @type {CompiledMode} */
-        a._top;
-      } else
-        a = L(y, g.subLanguage.length ? g.subLanguage : null);
-      g.relevance > 0 && (se += a.relevance), N.__addSublanguage(a._emitter, a.language);
-    }
-    function O() {
-      g.subLanguage != null ? ie() : T(), y = "";
-    }
-    function k(a, d) {
-      a !== "" && (N.startScope(d), N.addText(a), N.endScope());
-    }
-    function Me(a, d) {
-      let h = 1;
-      const _ = d.length - 1;
-      for (; h <= _; ) {
-        if (!a._emit[h]) {
-          h++;
-          continue;
+        let o = 0;
+        h.keywordPatternRe.lastIndex = 0;
+        let d = h.keywordPatternRe.exec(x), b = "";
+        for (; d; ) {
+          b += x.substring(o, d.index);
+          const _ = H.case_insensitive ? d[0].toLowerCase() : d[0], L = z(h, _);
+          if (L) {
+            const [$, en] = L;
+            if (I.addText(b), b = "", A[_] = (A[_] || 0) + 1, A[_] <= Pt && (ve += en), $.startsWith("_"))
+              b += d[0];
+            else {
+              const tn = H.classNameAliases[$] || $;
+              U(d[0], tn);
+            }
+          } else
+            b += d[0];
+          o = h.keywordPatternRe.lastIndex, d = h.keywordPatternRe.exec(x);
         }
-        const S = v.classNameAliases[a[h]] || a[h], I = d[h];
-        S ? k(I, S) : (y = I, T(), y = ""), h++;
+        b += x.substring(o), I.addText(b);
       }
-    }
-    function Ae(a, d) {
-      return a.scope && typeof a.scope == "string" && N.openNode(v.classNameAliases[a.scope] || a.scope), a.beginScope && (a.beginScope._wrap ? (k(y, v.classNameAliases[a.beginScope._wrap] || a.beginScope._wrap), y = "") : a.beginScope._multi && (Me(a.beginScope, d), y = "")), g = Object.create(a, { parent: { value: g } }), g;
-    }
-    function Oe(a, d, h) {
-      let _ = wt(a.endRe, h);
-      if (_) {
-        if (a["on:end"]) {
-          const S = new ke(a);
-          a["on:end"](d, S), S.isMatchIgnored && (_ = !1);
+      function Ne() {
+        if (x === "") return;
+        let o = null;
+        if (typeof h.subLanguage == "string") {
+          if (!t[h.subLanguage]) {
+            I.addText(x);
+            return;
+          }
+          o = de(h.subLanguage, x, !0, it[h.subLanguage]), it[h.subLanguage] = /** @type {CompiledMode} */
+          o._top;
+        } else
+          o = Be(x, h.subLanguage.length ? h.subLanguage : null);
+        h.relevance > 0 && (ve += o.relevance), I.__addSublanguage(o._emitter, o.language);
+      }
+      function B() {
+        h.subLanguage != null ? Ne() : W(), x = "";
+      }
+      function U(o, d) {
+        o !== "" && (I.startScope(d), I.addText(o), I.endScope());
+      }
+      function Qe(o, d) {
+        let b = 1;
+        const _ = d.length - 1;
+        for (; b <= _; ) {
+          if (!o._emit[b]) {
+            b++;
+            continue;
+          }
+          const L = H.classNameAliases[o[b]] || o[b], $ = d[b];
+          L ? U($, L) : (x = $, W(), x = ""), b++;
         }
+      }
+      function et(o, d) {
+        return o.scope && typeof o.scope == "string" && I.openNode(H.classNameAliases[o.scope] || o.scope), o.beginScope && (o.beginScope._wrap ? (U(x, H.classNameAliases[o.beginScope._wrap] || o.beginScope._wrap), x = "") : o.beginScope._multi && (Qe(o.beginScope, d), x = "")), h = Object.create(o, { parent: { value: h } }), h;
+      }
+      function tt(o, d, b) {
+        let _ = re(o.endRe, b);
         if (_) {
-          for (; a.endsParent && a.parent; )
-            a = a.parent;
-          return a;
+          if (o["on:end"]) {
+            const L = new s(o);
+            o["on:end"](d, L), L.isMatchIgnored && (_ = !1);
+          }
+          if (_) {
+            for (; o.endsParent && o.parent; )
+              o = o.parent;
+            return o;
+          }
         }
+        if (o.endsWithParent)
+          return tt(o.parent, d, b);
       }
-      if (a.endsWithParent)
-        return Oe(a.parent, d, h);
-    }
-    function it(a) {
-      return g.matcher.regexIndex === 0 ? (y += a[0], 1) : (me = !0, 0);
-    }
-    function rt(a) {
-      const d = a[0], h = a.rule, _ = new ke(h), S = [h.__beforeBegin, h["on:begin"]];
-      for (const I of S)
-        if (I && (I(a, _), _.isMatchIgnored))
-          return it(d);
-      return h.skip ? y += d : (h.excludeBegin && (y += d), O(), !h.returnBegin && !h.excludeBegin && (y = d)), Ae(h, a), h.returnBegin ? 0 : d.length;
-    }
-    function st(a) {
-      const d = a[0], h = c.substring(a.index), _ = Oe(g, a, h);
-      if (!_)
-        return Be;
-      const S = g;
-      g.endScope && g.endScope._wrap ? (O(), k(d, g.endScope._wrap)) : g.endScope && g.endScope._multi ? (O(), Me(g.endScope, a)) : S.skip ? y += d : (S.returnEnd || S.excludeEnd || (y += d), O(), S.excludeEnd && (y = d));
-      do
-        g.scope && N.closeNode(), !g.skip && !g.subLanguage && (se += g.relevance), g = g.parent;
-      while (g !== _.parent);
-      return _.starts && Ae(_.starts, a), S.returnEnd ? 0 : d.length;
-    }
-    function ot() {
-      const a = [];
-      for (let d = g; d !== v; d = d.parent)
-        d.scope && a.unshift(d.scope);
-      a.forEach((d) => N.openNode(d));
-    }
-    let re = {};
-    function Te(a, d) {
-      const h = d && d[0];
-      if (y += a, h == null)
-        return O(), 0;
-      if (re.type === "begin" && d.type === "end" && re.index === d.index && h === "") {
-        if (y += c.slice(d.index, d.index + 1), !u) {
-          const _ = new Error(`0 width match regex (${r})`);
-          throw _.languageName = r, _.badRule = re.rule, _;
-        }
-        return 1;
+      function Yt(o) {
+        return h.matcher.regexIndex === 0 ? (x += o[0], 1) : (Ue = !0, 0);
+      }
+      function qt(o) {
+        const d = o[0], b = o.rule, _ = new s(b), L = [b.__beforeBegin, b["on:begin"]];
+        for (const $ of L)
+          if ($ && ($(o, _), _.isMatchIgnored))
+            return Yt(d);
+        return b.skip ? x += d : (b.excludeBegin && (x += d), B(), !b.returnBegin && !b.excludeBegin && (x = d)), et(b, o), b.returnBegin ? 0 : d.length;
+      }
+      function Vt(o) {
+        const d = o[0], b = u.substring(o.index), _ = tt(h, o, b);
+        if (!_)
+          return Xe;
+        const L = h;
+        h.endScope && h.endScope._wrap ? (B(), U(d, h.endScope._wrap)) : h.endScope && h.endScope._multi ? (B(), Qe(h.endScope, o)) : L.skip ? x += d : (L.returnEnd || L.excludeEnd || (x += d), B(), L.excludeEnd && (x = d));
+        do
+          h.scope && I.closeNode(), !h.skip && !h.subLanguage && (ve += h.relevance), h = h.parent;
+        while (h !== _.parent);
+        return _.starts && et(_.starts, o), L.returnEnd ? 0 : d.length;
       }
-      if (re = d, d.type === "begin")
-        return rt(d);
-      if (d.type === "illegal" && !p) {
-        const _ = new Error('Illegal lexeme "' + h + '" for mode "' + (g.scope || "<unnamed>") + '"');
-        throw _.mode = g, _;
-      } else if (d.type === "end") {
-        const _ = st(d);
-        if (_ !== Be)
-          return _;
+      function Jt() {
+        const o = [];
+        for (let d = h; d !== H; d = d.parent)
+          d.scope && o.unshift(d.scope);
+        o.forEach((d) => I.openNode(d));
       }
-      if (d.type === "illegal" && h === "")
-        return 1;
-      if (Ee > 1e5 && Ee > d.index * 3)
-        throw new Error("potential infinite loop, way more iterations than matches");
-      return y += h, h.length;
-    }
-    const v = R(r);
-    if (!v)
-      throw U(f.replace("{}", r)), new Error('Unknown language: "' + r + '"');
-    const at = nn(v);
-    let be = "", g = E || at;
-    const Re = {}, N = new s.__emitter(s);
-    ot();
-    let y = "", se = 0, j = 0, Ee = 0, me = !1;
-    try {
-      if (v.__emitTokens)
-        v.__emitTokens(c, N);
-      else {
-        for (g.matcher.considerAll(); ; ) {
-          Ee++, me ? me = !1 : g.matcher.considerAll(), g.matcher.lastIndex = j;
-          const a = g.matcher.exec(c);
-          if (!a)
-            break;
-          const d = c.substring(j, a.index), h = Te(d, a);
-          j = a.index + h;
+      let ke = {};
+      function nt(o, d) {
+        const b = d && d[0];
+        if (x += o, b == null)
+          return B(), 0;
+        if (ke.type === "begin" && d.type === "end" && ke.index === d.index && b === "") {
+          if (x += u.slice(d.index, d.index + 1), !N) {
+            const _ = new Error(`0 width match regex (${n})`);
+            throw _.languageName = n, _.badRule = ke.rule, _;
+          }
+          return 1;
+        }
+        if (ke = d, d.type === "begin")
+          return qt(d);
+        if (d.type === "illegal" && !m) {
+          const _ = new Error('Illegal lexeme "' + b + '" for mode "' + (h.scope || "<unnamed>") + '"');
+          throw _.mode = h, _;
+        } else if (d.type === "end") {
+          const _ = Vt(d);
+          if (_ !== Xe)
+            return _;
         }
-        Te(c.substring(j));
+        if (d.type === "illegal" && b === "")
+          return x += `
+`, 1;
+        if (ze > 1e5 && ze > d.index * 3)
+          throw new Error("potential infinite loop, way more iterations than matches");
+        return x += b, b.length;
       }
-      return N.finalize(), be = N.toHTML(), {
-        language: r,
-        value: be,
-        relevance: se,
-        illegal: !1,
-        _emitter: N,
-        _top: g
-      };
-    } catch (a) {
-      if (a.message && a.message.includes("Illegal"))
-        return {
-          language: r,
-          value: _e(c),
-          illegal: !0,
-          relevance: 0,
-          _illegalBy: {
-            message: a.message,
-            index: j,
-            context: c.slice(j - 100, j + 100),
-            mode: a.mode,
-            resultSoFar: be
-          },
-          _emitter: N
-        };
-      if (u)
-        return {
-          language: r,
-          value: _e(c),
+      const H = K(n);
+      if (!H)
+        throw Q(k.replace("{}", n)), new Error('Unknown language: "' + n + '"');
+      const Qt = It(H);
+      let je = "", h = y || Qt;
+      const it = {}, I = new a.__emitter(a);
+      Jt();
+      let x = "", ve = 0, ee = 0, ze = 0, Ue = !1;
+      try {
+        if (H.__emitTokens)
+          H.__emitTokens(u, I);
+        else {
+          for (h.matcher.considerAll(); ; ) {
+            ze++, Ue ? Ue = !1 : h.matcher.considerAll(), h.matcher.lastIndex = ee;
+            const o = h.matcher.exec(u);
+            if (!o) break;
+            const d = u.substring(ee, o.index), b = nt(d, o);
+            ee = o.index + b;
+          }
+          nt(u.substring(ee));
+        }
+        return I.finalize(), je = I.toHTML(), {
+          language: n,
+          value: je,
+          relevance: ve,
           illegal: !1,
-          relevance: 0,
-          errorRaised: a,
-          _emitter: N,
-          _top: g
+          _emitter: I,
+          _top: h
         };
-      throw a;
+      } catch (o) {
+        if (o.message && o.message.includes("Illegal"))
+          return {
+            language: n,
+            value: Le(u),
+            illegal: !0,
+            relevance: 0,
+            _illegalBy: {
+              message: o.message,
+              index: ee,
+              context: u.slice(ee - 100, ee + 100),
+              mode: o.mode,
+              resultSoFar: je
+            },
+            _emitter: I
+          };
+        if (N)
+          return {
+            language: n,
+            value: Le(u),
+            illegal: !1,
+            relevance: 0,
+            errorRaised: o,
+            _emitter: I,
+            _top: h
+          };
+        throw o;
+      }
     }
-  }
-  function w(r) {
-    const c = {
-      value: _e(r),
-      illegal: !1,
-      relevance: 0,
-      _top: o,
-      _emitter: new s.__emitter(s)
+    function De(n) {
+      const u = {
+        value: Le(n),
+        illegal: !1,
+        relevance: 0,
+        _top: l,
+        _emitter: new a.__emitter(a)
+      };
+      return u._emitter.addText(n), u;
+    }
+    function Be(n, u) {
+      u = u || a.languages || Object.keys(t);
+      const m = De(n), y = u.filter(K).filter(Je).map(
+        (B) => de(B, n, !1)
+      );
+      y.unshift(m);
+      const A = y.sort((B, U) => {
+        if (B.relevance !== U.relevance) return U.relevance - B.relevance;
+        if (B.language && U.language) {
+          if (K(B.language).supersetOf === U.language)
+            return 1;
+          if (K(U.language).supersetOf === B.language)
+            return -1;
+        }
+        return 0;
+      }), [z, W] = A, Ne = z;
+      return Ne.secondBest = W, Ne;
+    }
+    function jt(n, u, m) {
+      const y = u && r[u] || m;
+      n.classList.add("hljs"), n.classList.add(`language-${y}`);
+    }
+    function Pe(n) {
+      let u = null;
+      const m = O(n);
+      if (f(m)) return;
+      if (Se(
+        "before:highlightElement",
+        { el: n, language: m }
+      ), n.dataset.highlighted) {
+        console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", n);
+        return;
+      }
+      if (n.children.length > 0 && (a.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)), a.throwUnescapedHTML))
+        throw new Bt(
+          "One of your code blocks includes unescaped HTML.",
+          n.innerHTML
+        );
+      u = n;
+      const y = u.textContent, A = m ? v(y, { language: m, ignoreIllegals: !0 }) : Be(y);
+      n.innerHTML = A.value, n.dataset.highlighted = "yes", jt(n, m, A.language), n.result = {
+        language: A.language,
+        // TODO: remove with version 11.0
+        re: A.relevance,
+        relevance: A.relevance
+      }, A.secondBest && (n.secondBest = {
+        language: A.secondBest.language,
+        relevance: A.secondBest.relevance
+      }), Se("after:highlightElement", { el: n, result: A, text: y });
+    }
+    function zt(n) {
+      a = Ze(a, n);
+    }
+    const Ut = () => {
+      we(), ae("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
     };
-    return c._emitter.addText(r), c;
-  }
-  function L(r, c) {
-    c = c || s.languages || Object.keys(t);
-    const p = w(r), E = c.filter(R).filter(te).map(
-      (O) => A(O, r, !1)
-    );
-    E.unshift(p);
-    const x = E.sort((O, k) => {
-      if (O.relevance !== k.relevance)
-        return k.relevance - O.relevance;
-      if (O.language && k.language) {
-        if (R(O.language).supersetOf === k.language)
-          return 1;
-        if (R(k.language).supersetOf === O.language)
-          return -1;
+    function Ht() {
+      we(), ae("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+    }
+    let qe = !1;
+    function we() {
+      function n() {
+        we();
       }
-      return 0;
-    }), [M, T] = x, ie = M;
-    return ie.secondBest = T, ie;
-  }
-  function H(r, c, p) {
-    const E = c && n[c] || p;
-    r.classList.add("hljs"), r.classList.add(`language-${E}`);
-  }
-  function C(r) {
-    let c = null;
-    const p = b(r);
-    if (l(p))
-      return;
-    if (G(
-      "before:highlightElement",
-      { el: r, language: p }
-    ), r.dataset.highlighted) {
-      console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", r);
-      return;
-    }
-    if (r.children.length > 0 && (s.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(r)), s.throwUnescapedHTML))
-      throw new on(
-        "One of your code blocks includes unescaped HTML.",
-        r.innerHTML
-      );
-    c = r;
-    const E = c.textContent, x = p ? m(E, { language: p, ignoreIllegals: !0 }) : L(E);
-    r.innerHTML = x.value, r.dataset.highlighted = "yes", H(r, p, x.language), r.result = {
-      language: x.language,
-      // TODO: remove with version 11.0
-      re: x.relevance,
-      relevance: x.relevance
-    }, x.secondBest && (r.secondBest = {
-      language: x.secondBest.language,
-      relevance: x.secondBest.relevance
-    }), G("after:highlightElement", { el: r, result: x, text: E });
-  }
-  function $(r) {
-    s = De(s, r);
-  }
-  const Se = () => {
-    B(), F("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
-  };
-  function W() {
-    B(), F("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
-  }
-  let Z = !1;
-  function B() {
-    if (document.readyState === "loading") {
-      Z = !0;
-      return;
+      if (document.readyState === "loading") {
+        qe || window.addEventListener("DOMContentLoaded", n, !1), qe = !0;
+        return;
+      }
+      document.querySelectorAll(a.cssSelector).forEach(Pe);
     }
-    document.querySelectorAll(s.cssSelector).forEach(C);
-  }
-  function X() {
-    Z && B();
-  }
-  typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", X, !1);
-  function P(r, c) {
-    let p = null;
-    try {
-      p = c(e);
-    } catch (E) {
-      if (U("Language definition for '{}' could not be registered.".replace("{}", r)), u)
-        U(E);
-      else
-        throw E;
-      p = o;
-    }
-    p.name || (p.name = r), t[r] = p, p.rawDefinition = c.bind(null, e), p.aliases && ee(p.aliases, { languageName: r });
-  }
-  function ge(r) {
-    delete t[r];
-    for (const c of Object.keys(n))
-      n[c] === r && delete n[c];
-  }
-  function Q() {
-    return Object.keys(t);
-  }
-  function R(r) {
-    return r = (r || "").toLowerCase(), t[r] || t[n[r]];
-  }
-  function ee(r, { languageName: c }) {
-    typeof r == "string" && (r = [r]), r.forEach((p) => {
-      n[p.toLowerCase()] = c;
-    });
-  }
-  function te(r) {
-    const c = R(r);
-    return c && !c.disableAutodetect;
-  }
-  function fe(r) {
-    r["before:highlightBlock"] && !r["before:highlightElement"] && (r["before:highlightElement"] = (c) => {
-      r["before:highlightBlock"](
-        Object.assign({ block: c.el }, c)
-      );
-    }), r["after:highlightBlock"] && !r["after:highlightElement"] && (r["after:highlightElement"] = (c) => {
-      r["after:highlightBlock"](
-        Object.assign({ block: c.el }, c)
-      );
-    });
-  }
-  function pe(r) {
-    fe(r), i.push(r);
-  }
-  function he(r) {
-    const c = i.indexOf(r);
-    c !== -1 && i.splice(c, 1);
-  }
-  function G(r, c) {
-    const p = r;
-    i.forEach(function(E) {
-      E[p] && E[p](c);
-    });
-  }
-  function ne(r) {
-    return F("10.7.0", "highlightBlock will be removed entirely in v12.0"), F("10.7.0", "Please use highlightElement now."), C(r);
-  }
-  Object.assign(e, {
-    highlight: m,
-    highlightAuto: L,
-    highlightAll: B,
-    highlightElement: C,
-    // TODO: Remove with v12 API
-    highlightBlock: ne,
-    configure: $,
-    initHighlighting: Se,
-    initHighlightingOnLoad: W,
-    registerLanguage: P,
-    unregisterLanguage: ge,
-    listLanguages: Q,
-    getLanguage: R,
-    registerAliases: ee,
-    autoDetection: te,
-    inherit: De,
-    addPlugin: pe,
-    removePlugin: he
-  }), e.debugMode = function() {
-    u = !1;
-  }, e.safeMode = function() {
-    u = !0;
-  }, e.versionString = sn, e.regex = {
-    concat: z,
-    lookahead: Ue,
-    either: xe,
-    optional: yt,
-    anyNumberOfTimes: _t
-  };
-  for (const r in oe)
-    typeof oe[r] == "object" && Pe(oe[r]);
-  return Object.assign(e, oe), e;
-}, K = Xe({});
-K.newInstance = () => Xe({});
-var cn = K;
-K.HighlightJS = K;
-K.default = K;
-const ue = /* @__PURE__ */ pt(cn), le = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
+    function Gt(n, u) {
+      let m = null;
+      try {
+        m = u(e);
+      } catch (y) {
+        if (Q("Language definition for '{}' could not be registered.".replace("{}", n)), N)
+          Q(y);
+        else
+          throw y;
+        m = l;
+      }
+      m.name || (m.name = n), t[n] = m, m.rawDefinition = u.bind(null, e), m.aliases && Ve(m.aliases, { languageName: n });
+    }
+    function $t(n) {
+      delete t[n];
+      for (const u of Object.keys(r))
+        r[u] === n && delete r[u];
+    }
+    function Ft() {
+      return Object.keys(t);
+    }
+    function K(n) {
+      return n = (n || "").toLowerCase(), t[n] || t[r[n]];
+    }
+    function Ve(n, { languageName: u }) {
+      typeof n == "string" && (n = [n]), n.forEach((m) => {
+        r[m.toLowerCase()] = u;
+      });
+    }
+    function Je(n) {
+      const u = K(n);
+      return u && !u.disableAutodetect;
+    }
+    function Kt(n) {
+      n["before:highlightBlock"] && !n["before:highlightElement"] && (n["before:highlightElement"] = (u) => {
+        n["before:highlightBlock"](
+          Object.assign({ block: u.el }, u)
+        );
+      }), n["after:highlightBlock"] && !n["after:highlightElement"] && (n["after:highlightElement"] = (u) => {
+        n["after:highlightBlock"](
+          Object.assign({ block: u.el }, u)
+        );
+      });
+    }
+    function Wt(n) {
+      Kt(n), p.push(n);
+    }
+    function Zt(n) {
+      const u = p.indexOf(n);
+      u !== -1 && p.splice(u, 1);
+    }
+    function Se(n, u) {
+      const m = n;
+      p.forEach(function(y) {
+        y[m] && y[m](u);
+      });
+    }
+    function Xt(n) {
+      return ae("10.7.0", "highlightBlock will be removed entirely in v12.0"), ae("10.7.0", "Please use highlightElement now."), Pe(n);
+    }
+    Object.assign(e, {
+      highlight: v,
+      highlightAuto: Be,
+      highlightAll: we,
+      highlightElement: Pe,
+      // TODO: Remove with v12 API
+      highlightBlock: Xt,
+      configure: zt,
+      initHighlighting: Ut,
+      initHighlightingOnLoad: Ht,
+      registerLanguage: Gt,
+      unregisterLanguage: $t,
+      listLanguages: Ft,
+      getLanguage: K,
+      registerAliases: Ve,
+      autoDetection: Je,
+      inherit: Ze,
+      addPlugin: Wt,
+      removePlugin: Zt
+    }), e.debugMode = function() {
+      N = !1;
+    }, e.safeMode = function() {
+      N = !0;
+    }, e.versionString = Dt, e.regex = {
+      concat: R,
+      lookahead: P,
+      either: ie,
+      optional: te,
+      anyNumberOfTimes: X
+    };
+    for (const n in ye)
+      typeof ye[n] == "object" && i(ye[n]);
+    return Object.assign(e, ye), e;
+  }, ce = Ye({});
+  return ce.newInstance = () => Ye({}), He = ce, ce.HighlightJS = ce, ce.default = ce, He;
+}
+var ln = /* @__PURE__ */ cn();
+const Te = /* @__PURE__ */ an(ln), Ae = "[A-Za-z$_][0-9A-Za-z$_]*", ot = [
   "as",
   // for exports
   "in",
@@ -1115,15 +1107,17 @@ const ue = /* @__PURE__ */ pt(cn), le = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
   "import",
   "from",
   "export",
-  "extends"
-], qe = [
+  "extends",
+  // It's reached stage 3, which is "recommended for implementation":
+  "using"
+], st = [
   "true",
   "false",
   "null",
   "undefined",
   "NaN",
   "Infinity"
-], Je = [
+], at = [
   // Fundamental objects
   "Object",
   "Function",
@@ -1173,7 +1167,7 @@ const ue = /* @__PURE__ */ pt(cn), le = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
   "Intl",
   // WebAssembly
   "WebAssembly"
-], Ve = [
+], ct = [
   "Error",
   "EvalError",
   "InternalError",
@@ -1182,7 +1176,7 @@ const ue = /* @__PURE__ */ pt(cn), le = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
   "SyntaxError",
   "TypeError",
   "URIError"
-], Qe = [
+], lt = [
   "setInterval",
   "setTimeout",
   "clearInterval",
@@ -1200,7 +1194,7 @@ const ue = /* @__PURE__ */ pt(cn), le = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
   "encodeURIComponent",
   "escape",
   "unescape"
-], et = [
+], dt = [
   "arguments",
   "this",
   "super",
@@ -1212,62 +1206,62 @@ const ue = /* @__PURE__ */ pt(cn), le = "[A-Za-z$_][0-9A-Za-z$_]*", Ye = [
   "module",
   "global"
   // Node.js
-], tt = [].concat(
-  Qe,
-  Je,
-  Ve
+], ut = [].concat(
+  lt,
+  at,
+  ct
 );
-function ln(e) {
-  const t = e.regex, n = (c, { after: p }) => {
-    const E = "</" + c[0].slice(1);
-    return c.input.indexOf(E, p) !== -1;
-  }, i = le, u = {
+function dn(i) {
+  const s = i.regex, c = (C, { after: F }) => {
+    const J = "</" + C[0].slice(1);
+    return C.input.indexOf(J, F) !== -1;
+  }, g = Ae, E = {
     begin: "<>",
     end: "</>"
-  }, f = /<[A-Za-z0-9\\._:-]+\s*\/>/, o = {
+  }, w = /<[A-Za-z0-9\\._:-]+\s*\/>/, S = {
     begin: /<[A-Za-z0-9\\._:-]+/,
     end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
     /**
      * @param {RegExpMatchArray} match
      * @param {CallbackResponse} response
      */
-    isTrulyOpeningTag: (c, p) => {
-      const E = c[0].length + c.index, x = c.input[E];
+    isTrulyOpeningTag: (C, F) => {
+      const J = C[0].length + C.index, se = C.input[J];
       if (
         // HTML should not include another raw `<` inside a tag
         // nested type?
         // `<Array<Array<number>>`, etc.
-        x === "<" || // the , gives away that this is not HTML
+        se === "<" || // the , gives away that this is not HTML
         // `<T, A extends keyof T, V>`
-        x === ","
+        se === ","
       ) {
-        p.ignoreMatch();
+        F.ignoreMatch();
         return;
       }
-      x === ">" && (n(c, { after: E }) || p.ignoreMatch());
-      let M;
-      const T = c.input.substring(E);
-      if (M = T.match(/^\s*=/)) {
-        p.ignoreMatch();
+      se === ">" && (c(C, { after: J }) || F.ignoreMatch());
+      let le;
+      const _e = C.input.substring(J);
+      if (le = _e.match(/^\s*=/)) {
+        F.ignoreMatch();
         return;
       }
-      if ((M = T.match(/^\s+extends\s+/)) && M.index === 0) {
-        p.ignoreMatch();
+      if ((le = _e.match(/^\s+extends\s+/)) && le.index === 0) {
+        F.ignoreMatch();
         return;
       }
     }
-  }, s = {
-    $pattern: le,
-    keyword: Ye,
-    literal: qe,
-    built_in: tt,
-    "variable.language": et
-  }, l = "[0-9](_?[0-9])*", b = `\\.(${l})`, m = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", A = {
+  }, M = {
+    $pattern: Ae,
+    keyword: ot,
+    literal: st,
+    built_in: ut,
+    "variable.language": dt
+  }, D = "[0-9](_?[0-9])*", T = `\\.(${D})`, Z = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", j = {
     className: "number",
     variants: [
       // DecimalLiteral
-      { begin: `(\\b(${m})((${b})|\\.)?|(${b}))[eE][+-]?(${l})\\b` },
-      { begin: `\\b(${m})\\b((${b})\\b|\\.)?|(${b})\\b` },
+      { begin: `(\\b(${Z})((${T})|\\.)?|(${T}))[eE][+-]?(${D})\\b` },
+      { begin: `\\b(${Z})\\b((${T})\\b|\\.)?|(${T})\\b` },
       // DecimalBigIntegerLiteral
       { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
       // NonDecimalIntegerLiteral
@@ -1279,61 +1273,61 @@ function ln(e) {
       { begin: "\\b0[0-7]+n?\\b" }
     ],
     relevance: 0
-  }, w = {
+  }, P = {
     className: "subst",
     begin: "\\$\\{",
     end: "\\}",
-    keywords: s,
+    keywords: M,
     contains: []
     // defined later
-  }, L = {
-    begin: "html`",
+  }, X = {
+    begin: ".?html`",
     end: "",
     starts: {
       end: "`",
       returnEnd: !1,
       contains: [
-        e.BACKSLASH_ESCAPE,
-        w
+        i.BACKSLASH_ESCAPE,
+        P
       ],
       subLanguage: "xml"
     }
-  }, H = {
-    begin: "css`",
+  }, te = {
+    begin: ".?css`",
     end: "",
     starts: {
       end: "`",
       returnEnd: !1,
       contains: [
-        e.BACKSLASH_ESCAPE,
-        w
+        i.BACKSLASH_ESCAPE,
+        P
       ],
       subLanguage: "css"
     }
-  }, C = {
-    begin: "gql`",
+  }, R = {
+    begin: ".?gql`",
     end: "",
     starts: {
       end: "`",
       returnEnd: !1,
       contains: [
-        e.BACKSLASH_ESCAPE,
-        w
+        i.BACKSLASH_ESCAPE,
+        P
       ],
       subLanguage: "graphql"
     }
-  }, $ = {
+  }, ne = {
     className: "string",
     begin: "`",
     end: "`",
     contains: [
-      e.BACKSLASH_ESCAPE,
-      w
+      i.BACKSLASH_ESCAPE,
+      P
     ]
-  }, W = {
+  }, G = {
     className: "comment",
     variants: [
-      e.COMMENT(
+      i.COMMENT(
         /\/\*\*(?!\/)/,
         "\\*/",
         {
@@ -1357,7 +1351,7 @@ function ln(e) {
                 },
                 {
                   className: "variable",
-                  begin: i + "(?=\\s*(-)|$)",
+                  begin: g + "(?=\\s*(-)|$)",
                   endsParent: !0,
                   relevance: 0
                 },
@@ -1372,61 +1366,63 @@ function ln(e) {
           ]
         }
       ),
-      e.C_BLOCK_COMMENT_MODE,
-      e.C_LINE_COMMENT_MODE
+      i.C_BLOCK_COMMENT_MODE,
+      i.C_LINE_COMMENT_MODE
     ]
-  }, Z = [
-    e.APOS_STRING_MODE,
-    e.QUOTE_STRING_MODE,
-    L,
-    H,
-    C,
-    $,
+  }, re = [
+    i.APOS_STRING_MODE,
+    i.QUOTE_STRING_MODE,
+    X,
+    te,
+    R,
+    ne,
     // Skip numbers when they are part of a variable name
     { match: /\$\d+/ },
-    A
+    j
     // This is intentional:
     // See https://github.com/highlightjs/highlight.js/issues/3288
     // hljs.REGEXP_MODE
   ];
-  w.contains = Z.concat({
+  P.contains = re.concat({
     // we need to pair up {} inside our subst to prevent
     // it from ending too early by matching another }
     begin: /\{/,
     end: /\}/,
-    keywords: s,
+    keywords: M,
     contains: [
       "self"
-    ].concat(Z)
+    ].concat(re)
   });
-  const B = [].concat(W, w.contains), X = B.concat([
+  const fe = [].concat(G, P.contains), Y = fe.concat([
     // eat recursive parens in sub expressions
     {
-      begin: /\(/,
+      begin: /(\s*)\(/,
       end: /\)/,
-      keywords: s,
-      contains: ["self"].concat(B)
+      keywords: M,
+      contains: ["self"].concat(fe)
     }
-  ]), P = {
+  ]), q = {
     className: "params",
-    begin: /\(/,
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with
     end: /\)/,
     excludeBegin: !0,
     excludeEnd: !0,
-    keywords: s,
-    contains: X
-  }, ge = {
+    keywords: M,
+    contains: Y
+  }, pe = {
     variants: [
       // class Car extends vehicle
       {
         match: [
           /class/,
           /\s+/,
-          i,
+          g,
           /\s+/,
           /extends/,
           /\s+/,
-          t.concat(i, "(", t.concat(/\./, i), ")*")
+          s.concat(g, "(", s.concat(/\./, g), ")*")
         ],
         scope: {
           1: "keyword",
@@ -1440,7 +1436,7 @@ function ln(e) {
         match: [
           /class/,
           /\s+/,
-          i
+          g
         ],
         scope: {
           1: "keyword",
@@ -1448,9 +1444,9 @@ function ln(e) {
         }
       }
     ]
-  }, Q = {
+  }, oe = {
     relevance: 0,
-    match: t.either(
+    match: s.either(
       // Hard coded exceptions
       /\bJSON/,
       // Float32Array, OutT
@@ -1468,22 +1464,22 @@ function ln(e) {
     keywords: {
       _: [
         // se we still get relevance credit for JS library classes
-        ...Je,
-        ...Ve
+        ...at,
+        ...ct
       ]
     }
-  }, R = {
+  }, he = {
     label: "use_strict",
     className: "meta",
     relevance: 10,
     begin: /^\s*['"]use (strict|asm)['"]/
-  }, ee = {
+  }, be = {
     variants: [
       {
         match: [
           /function/,
           /\s+/,
-          i,
+          g,
           /(?=\s*\()/
         ]
       },
@@ -1500,43 +1496,43 @@ function ln(e) {
       3: "title.function"
     },
     label: "func.def",
-    contains: [P],
+    contains: [q],
     illegal: /%/
-  }, te = {
+  }, me = {
     relevance: 0,
     match: /\b[A-Z][A-Z_0-9]+\b/,
     className: "variable.constant"
   };
-  function fe(c) {
-    return t.concat("(?!", c.join("|"), ")");
+  function Oe(C) {
+    return s.concat("(?!", C.join("|"), ")");
   }
-  const pe = {
-    match: t.concat(
+  const Re = {
+    match: s.concat(
       /\b/,
-      fe([
-        ...Qe,
+      Oe([
+        ...lt,
         "super",
         "import"
-      ]),
-      i,
-      t.lookahead(/\(/)
+      ].map((C) => `${C}\\s*\\(`)),
+      g,
+      s.lookahead(/\s*\(/)
     ),
     className: "title.function",
     relevance: 0
-  }, he = {
-    begin: t.concat(/\./, t.lookahead(
-      t.concat(i, /(?![0-9A-Za-z$_(])/)
+  }, V = {
+    begin: s.concat(/\./, s.lookahead(
+      s.concat(g, /(?![0-9A-Za-z$_(])/)
     )),
-    end: i,
+    end: g,
     excludeBegin: !0,
     keywords: "prototype",
     className: "property",
     relevance: 0
-  }, G = {
+  }, Ce = {
     match: [
       /get|set/,
       /\s+/,
-      i,
+      g,
       /(?=\()/
     ],
     className: {
@@ -1548,18 +1544,18 @@ function ln(e) {
         // eat to avoid empty params
         begin: /\(\)/
       },
-      P
+      q
     ]
-  }, ne = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", r = {
+  }, Ee = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + i.UNDERSCORE_IDENT_RE + ")\\s*=>", Ie = {
     match: [
       /const|var|let/,
       /\s+/,
-      i,
+      g,
       /\s*/,
       /=\s*/,
       /(async\s*)?/,
       // async is optional
-      t.lookahead(ne)
+      s.lookahead(Ee)
     ],
     keywords: "async",
     className: {
@@ -1567,54 +1563,54 @@ function ln(e) {
       3: "title.function"
     },
     contains: [
-      P
+      q
     ]
   };
   return {
     name: "JavaScript",
     aliases: ["js", "jsx", "mjs", "cjs"],
-    keywords: s,
+    keywords: M,
     // this will be extended by TypeScript
-    exports: { PARAMS_CONTAINS: X, CLASS_REFERENCE: Q },
+    exports: { PARAMS_CONTAINS: Y, CLASS_REFERENCE: oe },
     illegal: /#(?![$_A-z])/,
     contains: [
-      e.SHEBANG({
+      i.SHEBANG({
         label: "shebang",
         binary: "node",
         relevance: 5
       }),
+      he,
+      i.APOS_STRING_MODE,
+      i.QUOTE_STRING_MODE,
+      X,
+      te,
       R,
-      e.APOS_STRING_MODE,
-      e.QUOTE_STRING_MODE,
-      L,
-      H,
-      C,
-      $,
-      W,
+      ne,
+      G,
       // Skip numbers when they are part of a variable name
       { match: /\$\d+/ },
-      A,
-      Q,
+      j,
+      oe,
       {
-        className: "attr",
-        begin: i + t.lookahead(":"),
+        scope: "attr",
+        match: g + s.lookahead(":"),
         relevance: 0
       },
-      r,
+      Ie,
       {
         // "value" container
-        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        begin: "(" + i.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
         keywords: "return throw case",
         relevance: 0,
         contains: [
-          W,
-          e.REGEXP_MODE,
+          G,
+          i.REGEXP_MODE,
           {
             className: "function",
             // we have to count the parens to make sure we actually have the
             // correct bounding ( ) before the =>.  There could be any number of
             // sub-expressions inside also surrounded by parens.
-            begin: ne,
+            begin: Ee,
             returnBegin: !0,
             end: "\\s*=>",
             contains: [
@@ -1622,7 +1618,7 @@ function ln(e) {
                 className: "params",
                 variants: [
                   {
-                    begin: e.UNDERSCORE_IDENT_RE,
+                    begin: i.UNDERSCORE_IDENT_RE,
                     relevance: 0
                   },
                   {
@@ -1631,12 +1627,12 @@ function ln(e) {
                     skip: !0
                   },
                   {
-                    begin: /\(/,
+                    begin: /(\s*)\(/,
                     end: /\)/,
                     excludeBegin: !0,
                     excludeEnd: !0,
-                    keywords: s,
-                    contains: X
+                    keywords: M,
+                    contains: Y
                   }
                 ]
               }
@@ -1654,21 +1650,21 @@ function ln(e) {
           {
             // JSX
             variants: [
-              { begin: u.begin, end: u.end },
-              { match: f },
+              { begin: E.begin, end: E.end },
+              { match: w },
               {
-                begin: o.begin,
+                begin: S.begin,
                 // we carefully check the opening tag to see if it truly
                 // is a tag and not a false positive
-                "on:begin": o.isTrulyOpeningTag,
-                end: o.end
+                "on:begin": S.isTrulyOpeningTag,
+                end: S.end
               }
             ],
             subLanguage: "xml",
             contains: [
               {
-                begin: o.begin,
-                end: o.end,
+                begin: S.begin,
+                end: S.end,
                 skip: !0,
                 contains: ["self"]
               }
@@ -1676,7 +1672,7 @@ function ln(e) {
           }
         ]
       },
-      ee,
+      be,
       {
         // prevent this from getting swallowed up by function
         // since they appear "function like"
@@ -1686,13 +1682,13 @@ function ln(e) {
         // we have to count the parens to make sure we actually have the correct
         // bounding ( ).  There could be any number of sub-expressions inside
         // also surrounded by parens.
-        begin: "\\b(?!function)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        begin: "\\b(?!function)" + i.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
         // end parens
         returnBegin: !0,
         label: "func.def",
         contains: [
-          P,
-          e.inherit(e.TITLE_MODE, { begin: i, className: "title.function" })
+          q,
+          i.inherit(i.TITLE_MODE, { begin: g, className: "title.function" })
         ]
       },
       // catch ... so it won't trigger the property rule below
@@ -1700,23 +1696,23 @@ function ln(e) {
         match: /\.\.\./,
         relevance: 0
       },
-      he,
+      V,
       // hack: prevents detection of keywords in some circumstances
       // .keyword()
       // $keyword = x
       {
-        match: "\\$" + i,
+        match: "\\$" + g,
         relevance: 0
       },
       {
         match: [/\bconstructor(?=\s*\()/],
         className: { 1: "title.function" },
-        contains: [P]
+        contains: [q]
       },
+      Re,
+      me,
       pe,
-      te,
-      ge,
-      G,
+      Ce,
       {
         match: /\$[(.]/
         // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
@@ -1724,8 +1720,8 @@ function ln(e) {
     ]
   };
 }
-function dn(e) {
-  const t = ln(e), n = le, i = [
+function un(i) {
+  const s = i.regex, c = dn(i), g = Ae, E = [
     "any",
     "void",
     "number",
@@ -1736,27 +1732,32 @@ function dn(e) {
     "symbol",
     "bigint",
     "unknown"
-  ], u = {
-    beginKeywords: "namespace",
-    end: /\{/,
-    excludeEnd: !0,
-    contains: [t.exports.CLASS_REFERENCE]
-  }, f = {
+  ], w = {
+    begin: [
+      /namespace/,
+      /\s+/,
+      i.IDENT_RE
+    ],
+    beginScope: {
+      1: "keyword",
+      3: "title.class"
+    }
+  }, S = {
     beginKeywords: "interface",
     end: /\{/,
     excludeEnd: !0,
     keywords: {
       keyword: "interface extends",
-      built_in: i
+      built_in: E
     },
-    contains: [t.exports.CLASS_REFERENCE]
-  }, o = {
+    contains: [c.exports.CLASS_REFERENCE]
+  }, M = {
     className: "meta",
     relevance: 10,
     begin: /^\s*['"]use strict['"]/
-  }, s = [
+  }, D = [
     "type",
-    "namespace",
+    // "namespace",
     "interface",
     "public",
     "private",
@@ -1766,29 +1767,45 @@ function dn(e) {
     "abstract",
     "readonly",
     "enum",
-    "override"
-  ], l = {
-    $pattern: le,
-    keyword: Ye.concat(s),
-    literal: qe,
-    built_in: tt.concat(i),
-    "variable.language": et
-  }, b = {
+    "override",
+    "satisfies"
+  ], T = {
+    $pattern: Ae,
+    keyword: ot.concat(D),
+    literal: st,
+    built_in: ut.concat(E),
+    "variable.language": dt
+  }, Z = {
     className: "meta",
-    begin: "@" + n
-  }, m = (w, L, H) => {
-    const C = w.contains.findIndex(($) => $.label === L);
-    if (C === -1)
+    begin: "@" + g
+  }, j = (R, ne, ie) => {
+    const G = R.contains.findIndex((re) => re.label === ne);
+    if (G === -1)
       throw new Error("can not find mode to replace");
-    w.contains.splice(C, 1, H);
+    R.contains.splice(G, 1, ie);
   };
-  Object.assign(t.keywords, l), t.exports.PARAMS_CONTAINS.push(b), t.contains = t.contains.concat([
-    b,
-    u,
-    f
-  ]), m(t, "shebang", e.SHEBANG()), m(t, "use_strict", o);
-  const A = t.contains.find((w) => w.label === "func.def");
-  return A.relevance = 0, Object.assign(t, {
+  Object.assign(c.keywords, T), c.exports.PARAMS_CONTAINS.push(Z);
+  const P = c.contains.find((R) => R.scope === "attr"), X = Object.assign(
+    {},
+    P,
+    { match: s.concat(g, s.lookahead(/\s*\?:/)) }
+  );
+  c.exports.PARAMS_CONTAINS.push([
+    c.exports.CLASS_REFERENCE,
+    // class reference for highlighting the params types
+    P,
+    // highlight the params key
+    X
+    // Added for optional property assignment highlighting
+  ]), c.contains = c.contains.concat([
+    Z,
+    w,
+    S,
+    X
+    // Added for optional property assignment highlighting
+  ]), j(c, "shebang", i.SHEBANG()), j(c, "use_strict", M);
+  const te = c.contains.find((R) => R.label === "func.def");
+  return te.relevance = 0, Object.assign(c, {
     name: "TypeScript",
     aliases: [
       "ts",
@@ -1796,13 +1813,13 @@ function dn(e) {
       "mts",
       "cts"
     ]
-  }), t;
+  }), c;
 }
-function un(e) {
-  const t = e.regex, n = t.concat(/[\p{L}_]/u, t.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u), i = /[\p{L}0-9._:-]+/u, u = {
+function gn(i) {
+  const s = i.regex, c = s.concat(/[\p{L}_]/u, s.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u), g = /[\p{L}0-9._:-]+/u, E = {
     className: "symbol",
     begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
-  }, f = {
+  }, w = {
     begin: /\s/,
     contains: [
       {
@@ -1811,17 +1828,17 @@ function un(e) {
         illegal: /\n/
       }
     ]
-  }, o = e.inherit(f, {
+  }, S = i.inherit(w, {
     begin: /\(/,
     end: /\)/
-  }), s = e.inherit(e.APOS_STRING_MODE, { className: "string" }), l = e.inherit(e.QUOTE_STRING_MODE, { className: "string" }), b = {
+  }), M = i.inherit(i.APOS_STRING_MODE, { className: "string" }), D = i.inherit(i.QUOTE_STRING_MODE, { className: "string" }), T = {
     endsWithParent: !0,
     illegal: /</,
     relevance: 0,
     contains: [
       {
         className: "attr",
-        begin: i,
+        begin: g,
         relevance: 0
       },
       {
@@ -1835,12 +1852,12 @@ function un(e) {
               {
                 begin: /"/,
                 end: /"/,
-                contains: [u]
+                contains: [E]
               },
               {
                 begin: /'/,
                 end: /'/,
-                contains: [u]
+                contains: [E]
               },
               { begin: /[^\s"'=<>`]+/ }
             ]
@@ -1872,10 +1889,10 @@ function un(e) {
         end: />/,
         relevance: 10,
         contains: [
-          f,
-          l,
-          s,
-          o,
+          w,
+          D,
+          M,
+          S,
           {
             begin: /\[/,
             end: /\]/,
@@ -1885,17 +1902,17 @@ function un(e) {
                 begin: /<![a-z]/,
                 end: />/,
                 contains: [
-                  f,
-                  o,
-                  l,
-                  s
+                  w,
+                  S,
+                  D,
+                  M
                 ]
               }
             ]
           }
         ]
       },
-      e.COMMENT(
+      i.COMMENT(
         /<!--/,
         /-->/,
         { relevance: 10 }
@@ -1905,7 +1922,7 @@ function un(e) {
         end: /\]\]>/,
         relevance: 10
       },
-      u,
+      E,
       // xml processing instructions
       {
         className: "meta",
@@ -1915,7 +1932,7 @@ function un(e) {
             begin: /<\?xml/,
             relevance: 10,
             contains: [
-              l
+              D
             ]
           },
           {
@@ -1933,7 +1950,7 @@ function un(e) {
         begin: /<style(?=\s|>)/,
         end: />/,
         keywords: { name: "style" },
-        contains: [b],
+        contains: [T],
         starts: {
           end: /<\/style>/,
           returnEnd: !0,
@@ -1949,7 +1966,7 @@ function un(e) {
         begin: /<script(?=\s|>)/,
         end: />/,
         keywords: { name: "script" },
-        contains: [b],
+        contains: [T],
         starts: {
           end: /<\/script>/,
           returnEnd: !0,
@@ -1968,40 +1985,40 @@ function un(e) {
       // open tag
       {
         className: "tag",
-        begin: t.concat(
+        begin: s.concat(
           /</,
-          t.lookahead(t.concat(
-            n,
+          s.lookahead(s.concat(
+            c,
             // <tag/>
             // <tag>
             // <tag ...
-            t.either(/\/>/, />/, /\s/)
+            s.either(/\/>/, />/, /\s/)
           ))
         ),
         end: /\/?>/,
         contains: [
           {
             className: "name",
-            begin: n,
+            begin: c,
             relevance: 0,
-            starts: b
+            starts: T
           }
         ]
       },
       // close tag
       {
         className: "tag",
-        begin: t.concat(
+        begin: s.concat(
           /<\//,
-          t.lookahead(t.concat(
-            n,
+          s.lookahead(s.concat(
+            c,
             />/
           ))
         ),
         contains: [
           {
             className: "name",
-            begin: n,
+            begin: c,
             relevance: 0
           },
           {
@@ -2014,12 +2031,12 @@ function un(e) {
     ]
   };
 }
-const gn = (e) => ({
+const fn = (i) => ({
   IMPORTANT: {
     scope: "meta",
     begin: "!important"
   },
-  BLOCK_COMMENT: e.C_BLOCK_COMMENT_MODE,
+  BLOCK_COMMENT: i.C_BLOCK_COMMENT_MODE,
   HEXCOLOR: {
     scope: "number",
     begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
@@ -2034,20 +2051,20 @@ const gn = (e) => ({
     end: /\]/,
     illegal: "$",
     contains: [
-      e.APOS_STRING_MODE,
-      e.QUOTE_STRING_MODE
+      i.APOS_STRING_MODE,
+      i.QUOTE_STRING_MODE
     ]
   },
   CSS_NUMBER_MODE: {
     scope: "number",
-    begin: e.NUMBER_RE + "(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",
+    begin: i.NUMBER_RE + "(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",
     relevance: 0
   },
   CSS_VARIABLE: {
     className: "attr",
     begin: /--[A-Za-z_][A-Za-z0-9_-]*/
   }
-}), fn = [
+}), pn = [
   "a",
   "abbr",
   "address",
@@ -2099,11 +2116,16 @@ const gn = (e) => ({
   "nav",
   "object",
   "ol",
+  "optgroup",
+  "option",
   "p",
+  "picture",
   "q",
   "quote",
   "samp",
   "section",
+  "select",
+  "source",
   "span",
   "strong",
   "summary",
@@ -2120,7 +2142,52 @@ const gn = (e) => ({
   "ul",
   "var",
   "video"
-], pn = [
+], hn = [
+  "defs",
+  "g",
+  "marker",
+  "mask",
+  "pattern",
+  "svg",
+  "switch",
+  "symbol",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feFlood",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMorphology",
+  "feOffset",
+  "feSpecularLighting",
+  "feTile",
+  "feTurbulence",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "circle",
+  "ellipse",
+  "image",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "text",
+  "use",
+  "textPath",
+  "tspan",
+  "foreignObject",
+  "clipPath"
+], bn = [
+  ...pn,
+  ...hn
+], mn = [
   "any-hover",
   "any-pointer",
   "aspect-ratio",
@@ -2155,7 +2222,7 @@ const gn = (e) => ({
   "max-width",
   "min-height",
   "max-height"
-], hn = [
+].sort().reverse(), En = [
   "active",
   "any-link",
   "blank",
@@ -2229,7 +2296,7 @@ const gn = (e) => ({
   "visited",
   "where"
   // where()
-], bn = [
+].sort().reverse(), _n = [
   "after",
   "backdrop",
   "before",
@@ -2244,12 +2311,16 @@ const gn = (e) => ({
   "selection",
   "slotted",
   "spelling-error"
-], En = [
+].sort().reverse(), yn = [
+  "accent-color",
   "align-content",
   "align-items",
   "align-self",
+  "alignment-baseline",
   "all",
+  "anchor-name",
   "animation",
+  "animation-composition",
   "animation-delay",
   "animation-direction",
   "animation-duration",
@@ -2257,7 +2328,14 @@ const gn = (e) => ({
   "animation-iteration-count",
   "animation-name",
   "animation-play-state",
+  "animation-range",
+  "animation-range-end",
+  "animation-range-start",
+  "animation-timeline",
   "animation-timing-function",
+  "appearance",
+  "aspect-ratio",
+  "backdrop-filter",
   "backface-visibility",
   "background",
   "background-attachment",
@@ -2267,8 +2345,11 @@ const gn = (e) => ({
   "background-image",
   "background-origin",
   "background-position",
+  "background-position-x",
+  "background-position-y",
   "background-repeat",
   "background-size",
+  "baseline-shift",
   "block-size",
   "border",
   "border-block",
@@ -2291,6 +2372,8 @@ const gn = (e) => ({
   "border-bottom-width",
   "border-collapse",
   "border-color",
+  "border-end-end-radius",
+  "border-end-start-radius",
   "border-image",
   "border-image-outset",
   "border-image-repeat",
@@ -2319,6 +2402,8 @@ const gn = (e) => ({
   "border-right-style",
   "border-right-width",
   "border-spacing",
+  "border-start-end-radius",
+  "border-start-start-radius",
   "border-style",
   "border-top",
   "border-top-color",
@@ -2328,7 +2413,15 @@ const gn = (e) => ({
   "border-top-width",
   "border-width",
   "bottom",
+  "box-align",
   "box-decoration-break",
+  "box-direction",
+  "box-flex",
+  "box-flex-group",
+  "box-lines",
+  "box-ordinal-group",
+  "box-orient",
+  "box-pack",
   "box-shadow",
   "box-sizing",
   "break-after",
@@ -2341,6 +2434,11 @@ const gn = (e) => ({
   "clip-path",
   "clip-rule",
   "color",
+  "color-interpolation",
+  "color-interpolation-filters",
+  "color-profile",
+  "color-rendering",
+  "color-scheme",
   "column-count",
   "column-fill",
   "column-gap",
@@ -2352,17 +2450,34 @@ const gn = (e) => ({
   "column-width",
   "columns",
   "contain",
+  "contain-intrinsic-block-size",
+  "contain-intrinsic-height",
+  "contain-intrinsic-inline-size",
+  "contain-intrinsic-size",
+  "contain-intrinsic-width",
+  "container",
+  "container-name",
+  "container-type",
   "content",
   "content-visibility",
   "counter-increment",
   "counter-reset",
+  "counter-set",
   "cue",
   "cue-after",
   "cue-before",
   "cursor",
+  "cx",
+  "cy",
   "direction",
   "display",
+  "dominant-baseline",
   "empty-cells",
+  "enable-background",
+  "field-sizing",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
   "filter",
   "flex",
   "flex-basis",
@@ -2372,6 +2487,8 @@ const gn = (e) => ({
   "flex-shrink",
   "flex-wrap",
   "float",
+  "flood-color",
+  "flood-opacity",
   "flow",
   "font",
   "font-display",
@@ -2379,21 +2496,32 @@ const gn = (e) => ({
   "font-feature-settings",
   "font-kerning",
   "font-language-override",
+  "font-optical-sizing",
+  "font-palette",
   "font-size",
   "font-size-adjust",
+  "font-smooth",
   "font-smoothing",
   "font-stretch",
   "font-style",
   "font-synthesis",
+  "font-synthesis-position",
+  "font-synthesis-small-caps",
+  "font-synthesis-style",
+  "font-synthesis-weight",
   "font-variant",
+  "font-variant-alternates",
   "font-variant-caps",
   "font-variant-east-asian",
+  "font-variant-emoji",
   "font-variant-ligatures",
   "font-variant-numeric",
   "font-variant-position",
   "font-variation-settings",
   "font-weight",
+  "forced-color-adjust",
   "gap",
+  "glyph-orientation-horizontal",
   "glyph-orientation-vertical",
   "grid",
   "grid-area",
@@ -2413,19 +2541,36 @@ const gn = (e) => ({
   "grid-template-rows",
   "hanging-punctuation",
   "height",
+  "hyphenate-character",
+  "hyphenate-limit-chars",
   "hyphens",
   "icon",
   "image-orientation",
   "image-rendering",
   "image-resolution",
   "ime-mode",
+  "initial-letter",
+  "initial-letter-align",
   "inline-size",
+  "inset",
+  "inset-area",
+  "inset-block",
+  "inset-block-end",
+  "inset-block-start",
+  "inset-inline",
+  "inset-inline-end",
+  "inset-inline-start",
   "isolation",
   "justify-content",
+  "justify-items",
+  "justify-self",
+  "kerning",
   "left",
   "letter-spacing",
+  "lighting-color",
   "line-break",
   "line-height",
+  "line-height-step",
   "list-style",
   "list-style-image",
   "list-style-position",
@@ -2441,6 +2586,11 @@ const gn = (e) => ({
   "margin-left",
   "margin-right",
   "margin-top",
+  "margin-trim",
+  "marker",
+  "marker-end",
+  "marker-mid",
+  "marker-start",
   "marks",
   "mask",
   "mask-border",
@@ -2459,6 +2609,10 @@ const gn = (e) => ({
   "mask-repeat",
   "mask-size",
   "mask-type",
+  "masonry-auto-flow",
+  "math-depth",
+  "math-shift",
+  "math-style",
   "max-block-size",
   "max-height",
   "max-inline-size",
@@ -2477,6 +2631,12 @@ const gn = (e) => ({
   "normal",
   "object-fit",
   "object-position",
+  "offset",
+  "offset-anchor",
+  "offset-distance",
+  "offset-path",
+  "offset-position",
+  "offset-rotate",
   "opacity",
   "order",
   "orphans",
@@ -2486,9 +2646,19 @@ const gn = (e) => ({
   "outline-style",
   "outline-width",
   "overflow",
+  "overflow-anchor",
+  "overflow-block",
+  "overflow-clip-margin",
+  "overflow-inline",
   "overflow-wrap",
   "overflow-x",
   "overflow-y",
+  "overlay",
+  "overscroll-behavior",
+  "overscroll-behavior-block",
+  "overscroll-behavior-inline",
+  "overscroll-behavior-x",
+  "overscroll-behavior-y",
   "padding",
   "padding-block",
   "padding-block-end",
@@ -2500,23 +2670,37 @@ const gn = (e) => ({
   "padding-left",
   "padding-right",
   "padding-top",
+  "page",
   "page-break-after",
   "page-break-before",
   "page-break-inside",
+  "paint-order",
   "pause",
   "pause-after",
   "pause-before",
   "perspective",
   "perspective-origin",
+  "place-content",
+  "place-items",
+  "place-self",
   "pointer-events",
   "position",
+  "position-anchor",
+  "position-visibility",
+  "print-color-adjust",
   "quotes",
+  "r",
   "resize",
   "rest",
   "rest-after",
   "rest-before",
   "right",
+  "rotate",
   "row-gap",
+  "ruby-align",
+  "ruby-position",
+  "scale",
+  "scroll-behavior",
   "scroll-margin",
   "scroll-margin-block",
   "scroll-margin-block-end",
@@ -2542,26 +2726,44 @@ const gn = (e) => ({
   "scroll-snap-align",
   "scroll-snap-stop",
   "scroll-snap-type",
+  "scroll-timeline",
+  "scroll-timeline-axis",
+  "scroll-timeline-name",
   "scrollbar-color",
   "scrollbar-gutter",
   "scrollbar-width",
   "shape-image-threshold",
   "shape-margin",
   "shape-outside",
+  "shape-rendering",
   "speak",
   "speak-as",
   "src",
   // @font-face
+  "stop-color",
+  "stop-opacity",
+  "stroke",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-opacity",
+  "stroke-width",
   "tab-size",
   "table-layout",
   "text-align",
   "text-align-all",
   "text-align-last",
+  "text-anchor",
   "text-combine-upright",
   "text-decoration",
   "text-decoration-color",
   "text-decoration-line",
+  "text-decoration-skip",
+  "text-decoration-skip-ink",
   "text-decoration-style",
+  "text-decoration-thickness",
   "text-emphasis",
   "text-emphasis-color",
   "text-emphasis-position",
@@ -2572,20 +2774,37 @@ const gn = (e) => ({
   "text-overflow",
   "text-rendering",
   "text-shadow",
+  "text-size-adjust",
   "text-transform",
+  "text-underline-offset",
   "text-underline-position",
+  "text-wrap",
+  "text-wrap-mode",
+  "text-wrap-style",
+  "timeline-scope",
   "top",
+  "touch-action",
   "transform",
   "transform-box",
   "transform-origin",
   "transform-style",
   "transition",
+  "transition-behavior",
   "transition-delay",
   "transition-duration",
   "transition-property",
   "transition-timing-function",
+  "translate",
   "unicode-bidi",
+  "user-modify",
+  "user-select",
+  "vector-effect",
   "vertical-align",
+  "view-timeline",
+  "view-timeline-axis",
+  "view-timeline-inset",
+  "view-timeline-name",
+  "view-transition-name",
   "visibility",
   "voice-balance",
   "voice-duration",
@@ -2596,6 +2815,7 @@ const gn = (e) => ({
   "voice-stress",
   "voice-volume",
   "white-space",
+  "white-space-collapse",
   "widows",
   "width",
   "will-change",
@@ -2603,14 +2823,15 @@ const gn = (e) => ({
   "word-spacing",
   "word-wrap",
   "writing-mode",
-  "z-index"
-  // reverse makes sure longer attributes `font-weight` are matched fully
-  // instead of getting false positives on say `font`
-].reverse();
-function mn(e) {
-  const t = e.regex, n = gn(e), i = { begin: /-(webkit|moz|ms|o)-(?=[a-z])/ }, u = "and or not only", f = /@-?\w[\w]*(-\w+)*/, o = "[a-zA-Z-][a-zA-Z0-9_-]*", s = [
-    e.APOS_STRING_MODE,
-    e.QUOTE_STRING_MODE
+  "x",
+  "y",
+  "z-index",
+  "zoom"
+].sort().reverse();
+function xn(i) {
+  const s = i.regex, c = fn(i), g = { begin: /-(webkit|moz|ms|o)-(?=[a-z])/ }, E = "and or not only", w = /@-?\w[\w]*(-\w+)*/, S = "[a-zA-Z-][a-zA-Z0-9_-]*", M = [
+    i.APOS_STRING_MODE,
+    i.QUOTE_STRING_MODE
   ];
   return {
     name: "CSS",
@@ -2623,11 +2844,11 @@ function mn(e) {
       keyframePosition: "selector-tag"
     },
     contains: [
-      n.BLOCK_COMMENT,
-      i,
+      c.BLOCK_COMMENT,
+      g,
       // to recognize keyframe 40% etc which are outside the scope of our
       // attribute value mode
-      n.CSS_NUMBER_MODE,
+      c.CSS_NUMBER_MODE,
       {
         className: "selector-id",
         begin: /#[A-Za-z0-9_-]+/,
@@ -2635,15 +2856,15 @@ function mn(e) {
       },
       {
         className: "selector-class",
-        begin: "\\." + o,
+        begin: "\\." + S,
         relevance: 0
       },
-      n.ATTRIBUTE_SELECTOR_MODE,
+      c.ATTRIBUTE_SELECTOR_MODE,
       {
         className: "selector-pseudo",
         variants: [
-          { begin: ":(" + hn.join("|") + ")" },
-          { begin: ":(:)?(" + bn.join("|") + ")" }
+          { begin: ":(" + En.join("|") + ")" },
+          { begin: ":(:)?(" + _n.join("|") + ")" }
         ]
       },
       // we may actually need this (12/2020)
@@ -2652,21 +2873,21 @@ function mn(e) {
       //   end: /\)/,
       //   contains: [ hljs.CSS_NUMBER_MODE ]
       // },
-      n.CSS_VARIABLE,
+      c.CSS_VARIABLE,
       {
         className: "attribute",
-        begin: "\\b(" + En.join("|") + ")\\b"
+        begin: "\\b(" + yn.join("|") + ")\\b"
       },
       // attribute values
       {
         begin: /:/,
         end: /[;}{]/,
         contains: [
-          n.BLOCK_COMMENT,
-          n.HEXCOLOR,
-          n.IMPORTANT,
-          n.CSS_NUMBER_MODE,
-          ...s,
+          c.BLOCK_COMMENT,
+          c.HEXCOLOR,
+          c.IMPORTANT,
+          c.CSS_NUMBER_MODE,
+          ...M,
           // needed to highlight these as strings and to avoid issues with
           // illegal characters that might be inside urls that would tigger the
           // languages illegal stack
@@ -2677,7 +2898,7 @@ function mn(e) {
             // from keywords
             keywords: { built_in: "url data-uri" },
             contains: [
-              ...s,
+              ...M,
               {
                 className: "string",
                 // any character other than `)` as in `url()` will be the start
@@ -2688,11 +2909,11 @@ function mn(e) {
               }
             ]
           },
-          n.FUNCTION_DISPATCH
+          c.FUNCTION_DISPATCH
         ]
       },
       {
-        begin: t.lookahead(/@/),
+        begin: s.lookahead(/@/),
         end: "[{;]",
         relevance: 0,
         illegal: /:/,
@@ -2700,7 +2921,7 @@ function mn(e) {
         contains: [
           {
             className: "keyword",
-            begin: f
+            begin: w
           },
           {
             begin: /\s/,
@@ -2709,112 +2930,111 @@ function mn(e) {
             relevance: 0,
             keywords: {
               $pattern: /[a-z-]+/,
-              keyword: u,
-              attribute: pn.join(" ")
+              keyword: E,
+              attribute: mn.join(" ")
             },
             contains: [
               {
                 begin: /[a-z-]+(?=:)/,
                 className: "attribute"
               },
-              ...s,
-              n.CSS_NUMBER_MODE
+              ...M,
+              c.CSS_NUMBER_MODE
             ]
           }
         ]
       },
       {
         className: "selector-tag",
-        begin: "\\b(" + fn.join("|") + ")\\b"
+        begin: "\\b(" + bn.join("|") + ")\\b"
       }
     ]
   };
 }
-const nt = document.createElement("style");
-nt.innerText = [gt, ft].join(`
+const gt = document.createElement("style");
+gt.innerText = [on, sn].join(`
 `);
-document.head.appendChild(nt);
-ue.registerLanguage("typescript", dn);
-ue.registerLanguage("html", un);
-ue.registerLanguage("css", mn);
-function _n(...e) {
-  const t = document.createElement("div"), n = document.createElement("div");
-  n.classList.add("tab-control");
-  const i = document.createElement("div");
-  return e.forEach((u) => {
-    t.appendChild(u), u.addEventListener("click", () => {
-      e.forEach((f) => f.removeAttribute("selected")), u.setAttribute("selected", ""), i.innerHTML = "", i.appendChild(u.content), i.className = u.className, i.classList.add("tab-content");
+document.head.appendChild(gt);
+Te.registerLanguage("typescript", un);
+Te.registerLanguage("html", gn);
+Te.registerLanguage("css", xn);
+function wn(...i) {
+  const s = document.createElement("div"), c = document.createElement("div");
+  c.classList.add("tab-control");
+  const g = document.createElement("div");
+  return i.forEach((E) => {
+    s.appendChild(E), E.addEventListener("click", () => {
+      i.forEach((w) => w.removeAttribute("selected")), E.setAttribute("selected", ""), g.innerHTML = "", g.appendChild(E.content), g.className = E.className, g.classList.add("tab-content");
     });
-  }), n.appendChild(t), n.appendChild(i), i.classList.add("tab-content"), e[0].setAttribute("selected", ""), i.appendChild(e[0].content), n;
+  }), c.appendChild(s), c.appendChild(g), g.classList.add("tab-content"), i[0].setAttribute("selected", ""), g.appendChild(i[0].content), c;
 }
-function Y(e, t) {
-  const n = document.createElement("div");
-  return n.role = "tab", n.tabIndex = 0, n.innerText = e, n.content = t, t.tagName == "PRE" && n.classList.add("code"), n;
+function ue(i, s) {
+  const c = document.createElement("div");
+  return c.role = "tab", c.tabIndex = 0, c.innerText = i, c.content = s, s.tagName == "PRE" && c.classList.add("code"), c;
 }
-function q(e, t) {
-  const n = document.createElement(e);
-  return typeof t == "string" ? n.innerHTML = t : t.forEach((i) => {
-    n.appendChild(i);
-  }), n;
+function ge(i, s) {
+  const c = document.createElement(i);
+  return typeof s == "string" ? c.innerHTML = s : s.forEach((g) => {
+    c.appendChild(g);
+  }), c;
 }
-async function yn(e, t, n) {
-  var b, m, A;
-  const i = t.mainContent, u = q("div", i);
-  u.id = `example-preview-${n}`;
-  const f = typeof t.css == "string" || (b = t.css) == null ? void 0 : b.label, o = typeof t.css == "string" ? t.css : (m = t.css) == null ? void 0 : m.content, s = _n(
-    Y("Preview", u),
-    Y("HTML", ae("html", i)),
-    ...o ? [Y(f ?? "CSS", ae("css", o))] : [],
-    ...t.initializer && t.initializer.content ? [
-      Y(
-        t.initializer.label ?? "TS",
-        ae("typescript", t.initializer.content)
+async function Sn(i, s, c) {
+  const g = s.mainContent, E = ge("div", g);
+  E.id = `example-preview-${c}`;
+  const w = typeof s.css == "string" ? void 0 : s.css?.label, S = typeof s.css == "string" ? s.css : s.css?.content, M = wn(
+    ue("Preview", E),
+    ue("HTML", Me("html", g)),
+    ...S ? [ue(w ?? "CSS", Me("css", S))] : [],
+    ...s.initializer && s.initializer.content ? [
+      ue(
+        s.initializer.label ?? "TS",
+        Me("typescript", s.initializer.content)
       )
     ] : [],
-    ...(t.additionalSources || []).map((w) => Y(w.label, ae(w.language, w.content)))
+    ...(s.additionalSources || []).map((T) => ue(T.label, Me(T.language, T.content)))
   );
-  t.description && e.appendChild(q("div", t.description));
-  const l = q("div", [s]);
-  l.classList.add("example"), e.appendChild(l), o && xn(`#${u.id}`, o), (A = t.initializer) != null && A.initialize && await t.initializer.initialize(u);
+  s.description && i.appendChild(ge("div", s.description));
+  const D = ge("div", [M]);
+  D.classList.add("example"), i.appendChild(D), S && Nn(`#${E.id}`, S), s.initializer?.initialize && await s.initializer.initialize(E);
 }
-function ae(e, t) {
-  let n = t.split(/\r?\n/).map((i) => {
-    const u = i.indexOf("///");
-    if (u > -1) {
-      const f = i.substring(u + 3).trimStart();
-      return f ? i.replace(/^(\s*)([^\s].*)$/, `$1${f}`) : void 0;
-    }
-    return i;
-  }).filter((i) => typeof i < "u").join(`
+function Me(i, s) {
+  let c = s.split(/\r?\n/).map((g) => {
+    const E = g.indexOf("///");
+    if (E > -1) {
+      const w = g.substring(E + 3).trimStart();
+      return w ? g.replace(/^(\s*)([^\s].*)$/, `$1${w}`) : void 0;
+    }
+    return g;
+  }).filter((g) => typeof g < "u").join(`
 `).trim();
-  return e && e != "raw" && (n = ue.highlight(n, { language: e }).value), q("pre", [q("code", n)]);
+  return i && i != "raw" && (c = Te.highlight(c, { language: i }).value), ge("pre", [ge("code", c)]);
 }
-function xn(e, t) {
-  const n = document.createElement("style");
-  n.innerHTML = dt().use(ut({ prefix: e })).process(t).css, document.head.appendChild(n);
+function Nn(i, s) {
+  const c = document.createElement("style");
+  c.innerHTML = nn().use(rn({ prefix: i })).process(s).css, document.head.appendChild(c);
 }
-async function An(e, t = document.body) {
-  const n = Nn(t);
-  let i = 0;
-  Object.keys(e).forEach(async (u) => {
-    const f = document.createElement("div");
-    f.className = "example-container", n.appendChild(f);
-    const o = e[u].default;
-    yn(f, o, i++);
+async function On(i, s = document.body) {
+  const c = vn(s);
+  let g = 0;
+  Object.keys(i).sort().forEach(async (E) => {
+    const w = document.createElement("div");
+    w.className = "example-container", c.appendChild(w);
+    const S = i[E].default;
+    Sn(w, S, g++);
   });
 }
-function wn(e) {
-  const t = document.createElement("div");
-  t.id = "examples-container";
-  const n = e.querySelector("#examples");
-  return n ? n.after(t) : e.appendChild(t), t;
+function kn(i) {
+  const s = document.createElement("div");
+  s.id = "examples-container";
+  const c = i.querySelector("#examples");
+  return c ? c.after(s) : i.appendChild(s), s;
 }
-function Nn(e) {
-  return e.children ? wn(e) : e;
+function vn(i) {
+  return i.children ? kn(i) : i;
 }
 export {
-  yn as initialize,
-  An as initializeExamplesForModules,
-  xn as loadPrefixedStylesheet
+  Sn as initialize,
+  On as initializeExamplesForModules,
+  Nn as loadPrefixedStylesheet
 };
 //# sourceMappingURL=element-preview.mjs.map