@cas-smartdesign/element-preview 0.2.1

package/dist/element-preview.mjs

@@ -0,0 +1,2820 @@
+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;
+}
+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;
+  }
+  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(" ");
+  }
+  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);
+  }
+  /**
+   * Adds texts to the output stream
+   *
+   * @param {string} text */
+  addText(t) {
+    this.buffer += je(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);
+  }
+  /**
+   * Adds a node close to the output stream (if needed)
+   *
+   * @param {Node} node */
+  closeNode(t) {
+    ve(t) && (this.buffer += ht);
+  }
+  /**
+   * returns the accumulated buffer
+  */
+  value() {
+    return this.buffer;
+  }
+  // helpers
+  /**
+   * Builds a span element
+   *
+   * @param {string} className */
+  span(t) {
+    this.buffer += `<span class="${t}">`;
+  }
+}
+const Ce = (e = {}) => {
+  const t = { children: [] };
+  return Object.assign(t, e), t;
+};
+class ye {
+  constructor() {
+    this.rootNode = Ce(), 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 n = Ce({ scope: t });
+    this.add(n), this.stack.push(n);
+  }
+  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, 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;
+  }
+  /**
+   * @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);
+    }));
+  }
+}
+class mt extends ye {
+  /**
+   * @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, n) {
+    const i = t.root;
+    n && (i.scope = `language:${n}`), this.add(i);
+  }
+  toHTML() {
+    return new Et(this, this.options).value();
+  }
+  finalize() {
+    return this.closeAllNodes(), !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();
+      }
+    }
+  );
+};
+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 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 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" : "")
+    );
+  }
+  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);
+    }
+  }
+  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);
+      }
+      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,
+        l
+      );
+    }), o.starts && f(o.starts, s), l.matcher = u(l), l;
+  }
+  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;
+  }
+}
+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 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));
+  }
+  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
+    };
+    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);
+      }
+      h += y.substring(a), N.addText(h);
+    }
+    function ie() {
+      if (y === "")
+        return;
+      let a = null;
+      if (typeof g.subLanguage == "string") {
+        if (!t[g.subLanguage]) {
+          N.addText(y);
+          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;
+        }
+        const S = v.classNameAliases[a[h]] || a[h], I = d[h];
+        S ? k(I, S) : (y = I, T(), y = ""), h++;
+      }
+    }
+    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);
+        }
+        if (_) {
+          for (; a.endsParent && a.parent; )
+            a = a.parent;
+          return a;
+        }
+      }
+      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;
+      }
+      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 _;
+      }
+      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;
+        }
+        Te(c.substring(j));
+      }
+      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),
+          illegal: !1,
+          relevance: 0,
+          errorRaised: a,
+          _emitter: N,
+          _top: g
+        };
+      throw a;
+    }
+  }
+  function w(r) {
+    const c = {
+      value: _e(r),
+      illegal: !1,
+      relevance: 0,
+      _top: o,
+      _emitter: new s.__emitter(s)
+    };
+    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;
+      }
+      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;
+    }
+    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 = [
+  "as",
+  // for exports
+  "in",
+  "of",
+  "if",
+  "for",
+  "while",
+  "finally",
+  "var",
+  "new",
+  "function",
+  "do",
+  "return",
+  "void",
+  "else",
+  "break",
+  "catch",
+  "instanceof",
+  "with",
+  "throw",
+  "case",
+  "default",
+  "try",
+  "switch",
+  "continue",
+  "typeof",
+  "delete",
+  "let",
+  "yield",
+  "const",
+  "class",
+  // JS handles these with a special rule
+  // "get",
+  // "set",
+  "debugger",
+  "async",
+  "await",
+  "static",
+  "import",
+  "from",
+  "export",
+  "extends"
+], qe = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], Je = [
+  // Fundamental objects
+  "Object",
+  "Function",
+  "Boolean",
+  "Symbol",
+  // numbers and dates
+  "Math",
+  "Date",
+  "Number",
+  "BigInt",
+  // text
+  "String",
+  "RegExp",
+  // Indexed collections
+  "Array",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Int32Array",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Keyed collections
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  // Structured data
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Atomics",
+  "DataView",
+  "JSON",
+  // Control abstraction objects
+  "Promise",
+  "Generator",
+  "GeneratorFunction",
+  "AsyncFunction",
+  // Reflection
+  "Reflect",
+  "Proxy",
+  // Internationalization
+  "Intl",
+  // WebAssembly
+  "WebAssembly"
+], Ve = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], Qe = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], et = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "global"
+  // Node.js
+], tt = [].concat(
+  Qe,
+  Je,
+  Ve
+);
+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 = {
+    begin: "<>",
+    end: "</>"
+  }, f = /<[A-Za-z0-9\\._:-]+\s*\/>/, o = {
+    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];
+      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
+        // `<T, A extends keyof T, V>`
+        x === ","
+      ) {
+        p.ignoreMatch();
+        return;
+      }
+      x === ">" && (n(c, { after: E }) || p.ignoreMatch());
+      let M;
+      const T = c.input.substring(E);
+      if (M = T.match(/^\s*=/)) {
+        p.ignoreMatch();
+        return;
+      }
+      if ((M = T.match(/^\s+extends\s+/)) && M.index === 0) {
+        p.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 = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${m})((${b})|\\.)?|(${b}))[eE][+-]?(${l})\\b` },
+      { begin: `\\b(${m})\\b((${b})\\b|\\.)?|(${b})\\b` },
+      // DecimalBigIntegerLiteral
+      { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+      // NonDecimalIntegerLiteral
+      { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+      { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+      { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+      // LegacyOctalIntegerLiteral (does not include underscore separators)
+      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+      { begin: "\\b0[0-7]+n?\\b" }
+    ],
+    relevance: 0
+  }, w = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: s,
+    contains: []
+    // defined later
+  }, L = {
+    begin: "html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        w
+      ],
+      subLanguage: "xml"
+    }
+  }, H = {
+    begin: "css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        w
+      ],
+      subLanguage: "css"
+    }
+  }, C = {
+    begin: "gql`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        w
+      ],
+      subLanguage: "graphql"
+    }
+  }, $ = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      w
+    ]
+  }, W = {
+    className: "comment",
+    variants: [
+      e.COMMENT(
+        /\/\*\*(?!\/)/,
+        "\\*/",
+        {
+          relevance: 0,
+          contains: [
+            {
+              begin: "(?=@[A-Za-z]+)",
+              relevance: 0,
+              contains: [
+                {
+                  className: "doctag",
+                  begin: "@[A-Za-z]+"
+                },
+                {
+                  className: "type",
+                  begin: "\\{",
+                  end: "\\}",
+                  excludeEnd: !0,
+                  excludeBegin: !0,
+                  relevance: 0
+                },
+                {
+                  className: "variable",
+                  begin: i + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_BLOCK_COMMENT_MODE,
+      e.C_LINE_COMMENT_MODE
+    ]
+  }, Z = [
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    L,
+    H,
+    C,
+    $,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    A
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  w.contains = Z.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: s,
+    contains: [
+      "self"
+    ].concat(Z)
+  });
+  const B = [].concat(W, w.contains), X = B.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /\(/,
+      end: /\)/,
+      keywords: s,
+      contains: ["self"].concat(B)
+    }
+  ]), P = {
+    className: "params",
+    begin: /\(/,
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: s,
+    contains: X
+  }, ge = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          i,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          t.concat(i, "(", t.concat(/\./, i), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          i
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, Q = {
+    relevance: 0,
+    match: t.either(
+      // Hard coded exceptions
+      /\bJSON/,
+      // Float32Array, OutT
+      /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+      // CSSFactory, CSSFactoryT
+      /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+      // FPs, FPsT
+      /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/
+      // P
+      // single letters are not highlighted
+      // BLAH
+      // this will be flagged as a UPPER_CASE_CONSTANT instead
+    ),
+    className: "title.class",
+    keywords: {
+      _: [
+        // se we still get relevance credit for JS library classes
+        ...Je,
+        ...Ve
+      ]
+    }
+  }, R = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, ee = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          i,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [P],
+    illegal: /%/
+  }, te = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function fe(c) {
+    return t.concat("(?!", c.join("|"), ")");
+  }
+  const pe = {
+    match: t.concat(
+      /\b/,
+      fe([
+        ...Qe,
+        "super",
+        "import"
+      ]),
+      i,
+      t.lookahead(/\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, he = {
+    begin: t.concat(/\./, t.lookahead(
+      t.concat(i, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: i,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, G = {
+    match: [
+      /get|set/,
+      /\s+/,
+      i,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      P
+    ]
+  }, ne = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", r = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      i,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      t.lookahead(ne)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      P
+    ]
+  };
+  return {
+    name: "JavaScript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: s,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: X, CLASS_REFERENCE: Q },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      e.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      R,
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      L,
+      H,
+      C,
+      $,
+      W,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      A,
+      Q,
+      {
+        className: "attr",
+        begin: i + t.lookahead(":"),
+        relevance: 0
+      },
+      r,
+      {
+        // "value" container
+        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          W,
+          e.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,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: e.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: s,
+                    contains: X
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: u.begin, end: u.end },
+              { match: f },
+              {
+                begin: o.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
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: o.begin,
+                end: o.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      ee,
+      {
+        // prevent this from getting swallowed up by function
+        // since they appear "function like"
+        beginKeywords: "while if switch catch for"
+      },
+      {
+        // 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*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          P,
+          e.inherit(e.TITLE_MODE, { begin: i, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      he,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + i,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [P]
+      },
+      pe,
+      te,
+      ge,
+      G,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function dn(e) {
+  const t = ln(e), n = le, i = [
+    "any",
+    "void",
+    "number",
+    "boolean",
+    "string",
+    "object",
+    "never",
+    "symbol",
+    "bigint",
+    "unknown"
+  ], u = {
+    beginKeywords: "namespace",
+    end: /\{/,
+    excludeEnd: !0,
+    contains: [t.exports.CLASS_REFERENCE]
+  }, f = {
+    beginKeywords: "interface",
+    end: /\{/,
+    excludeEnd: !0,
+    keywords: {
+      keyword: "interface extends",
+      built_in: i
+    },
+    contains: [t.exports.CLASS_REFERENCE]
+  }, o = {
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use strict['"]/
+  }, s = [
+    "type",
+    "namespace",
+    "interface",
+    "public",
+    "private",
+    "protected",
+    "implements",
+    "declare",
+    "abstract",
+    "readonly",
+    "enum",
+    "override"
+  ], l = {
+    $pattern: le,
+    keyword: Ye.concat(s),
+    literal: qe,
+    built_in: tt.concat(i),
+    "variable.language": et
+  }, b = {
+    className: "meta",
+    begin: "@" + n
+  }, m = (w, L, H) => {
+    const C = w.contains.findIndex(($) => $.label === L);
+    if (C === -1)
+      throw new Error("can not find mode to replace");
+    w.contains.splice(C, 1, H);
+  };
+  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, {
+    name: "TypeScript",
+    aliases: [
+      "ts",
+      "tsx",
+      "mts",
+      "cts"
+    ]
+  }), t;
+}
+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 = {
+    className: "symbol",
+    begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
+  }, f = {
+    begin: /\s/,
+    contains: [
+      {
+        className: "keyword",
+        begin: /#?[a-z_][a-z1-9_-]+/,
+        illegal: /\n/
+      }
+    ]
+  }, o = e.inherit(f, {
+    begin: /\(/,
+    end: /\)/
+  }), s = e.inherit(e.APOS_STRING_MODE, { className: "string" }), l = e.inherit(e.QUOTE_STRING_MODE, { className: "string" }), b = {
+    endsWithParent: !0,
+    illegal: /</,
+    relevance: 0,
+    contains: [
+      {
+        className: "attr",
+        begin: i,
+        relevance: 0
+      },
+      {
+        begin: /=\s*/,
+        relevance: 0,
+        contains: [
+          {
+            className: "string",
+            endsParent: !0,
+            variants: [
+              {
+                begin: /"/,
+                end: /"/,
+                contains: [u]
+              },
+              {
+                begin: /'/,
+                end: /'/,
+                contains: [u]
+              },
+              { begin: /[^\s"'=<>`]+/ }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+  return {
+    name: "HTML, XML",
+    aliases: [
+      "html",
+      "xhtml",
+      "rss",
+      "atom",
+      "xjb",
+      "xsd",
+      "xsl",
+      "plist",
+      "wsf",
+      "svg"
+    ],
+    case_insensitive: !0,
+    unicodeRegex: !0,
+    contains: [
+      {
+        className: "meta",
+        begin: /<![a-z]/,
+        end: />/,
+        relevance: 10,
+        contains: [
+          f,
+          l,
+          s,
+          o,
+          {
+            begin: /\[/,
+            end: /\]/,
+            contains: [
+              {
+                className: "meta",
+                begin: /<![a-z]/,
+                end: />/,
+                contains: [
+                  f,
+                  o,
+                  l,
+                  s
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      e.COMMENT(
+        /<!--/,
+        /-->/,
+        { relevance: 10 }
+      ),
+      {
+        begin: /<!\[CDATA\[/,
+        end: /\]\]>/,
+        relevance: 10
+      },
+      u,
+      // xml processing instructions
+      {
+        className: "meta",
+        end: /\?>/,
+        variants: [
+          {
+            begin: /<\?xml/,
+            relevance: 10,
+            contains: [
+              l
+            ]
+          },
+          {
+            begin: /<\?[a-z][a-z0-9]+/
+          }
+        ]
+      },
+      {
+        className: "tag",
+        /*
+        The lookahead pattern (?=...) ensures that 'begin' only matches
+        '<style' as a single word, followed by a whitespace or an
+        ending bracket.
+        */
+        begin: /<style(?=\s|>)/,
+        end: />/,
+        keywords: { name: "style" },
+        contains: [b],
+        starts: {
+          end: /<\/style>/,
+          returnEnd: !0,
+          subLanguage: [
+            "css",
+            "xml"
+          ]
+        }
+      },
+      {
+        className: "tag",
+        // See the comment in the <style tag about the lookahead pattern
+        begin: /<script(?=\s|>)/,
+        end: />/,
+        keywords: { name: "script" },
+        contains: [b],
+        starts: {
+          end: /<\/script>/,
+          returnEnd: !0,
+          subLanguage: [
+            "javascript",
+            "handlebars",
+            "xml"
+          ]
+        }
+      },
+      // we need this for now for jSX
+      {
+        className: "tag",
+        begin: /<>|<\/>/
+      },
+      // open tag
+      {
+        className: "tag",
+        begin: t.concat(
+          /</,
+          t.lookahead(t.concat(
+            n,
+            // <tag/>
+            // <tag>
+            // <tag ...
+            t.either(/\/>/, />/, /\s/)
+          ))
+        ),
+        end: /\/?>/,
+        contains: [
+          {
+            className: "name",
+            begin: n,
+            relevance: 0,
+            starts: b
+          }
+        ]
+      },
+      // close tag
+      {
+        className: "tag",
+        begin: t.concat(
+          /<\//,
+          t.lookahead(t.concat(
+            n,
+            />/
+          ))
+        ),
+        contains: [
+          {
+            className: "name",
+            begin: n,
+            relevance: 0
+          },
+          {
+            begin: />/,
+            relevance: 0,
+            endsParent: !0
+          }
+        ]
+      }
+    ]
+  };
+}
+const gn = (e) => ({
+  IMPORTANT: {
+    scope: "meta",
+    begin: "!important"
+  },
+  BLOCK_COMMENT: e.C_BLOCK_COMMENT_MODE,
+  HEXCOLOR: {
+    scope: "number",
+    begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
+  },
+  FUNCTION_DISPATCH: {
+    className: "built_in",
+    begin: /[\w-]+(?=\()/
+  },
+  ATTRIBUTE_SELECTOR_MODE: {
+    scope: "selector-attr",
+    begin: /\[/,
+    end: /\]/,
+    illegal: "$",
+    contains: [
+      e.APOS_STRING_MODE,
+      e.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)?",
+    relevance: 0
+  },
+  CSS_VARIABLE: {
+    className: "attr",
+    begin: /--[A-Za-z_][A-Za-z0-9_-]*/
+  }
+}), fn = [
+  "a",
+  "abbr",
+  "address",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "blockquote",
+  "body",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "main",
+  "mark",
+  "menu",
+  "nav",
+  "object",
+  "ol",
+  "p",
+  "q",
+  "quote",
+  "samp",
+  "section",
+  "span",
+  "strong",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "ul",
+  "var",
+  "video"
+], pn = [
+  "any-hover",
+  "any-pointer",
+  "aspect-ratio",
+  "color",
+  "color-gamut",
+  "color-index",
+  "device-aspect-ratio",
+  "device-height",
+  "device-width",
+  "display-mode",
+  "forced-colors",
+  "grid",
+  "height",
+  "hover",
+  "inverted-colors",
+  "monochrome",
+  "orientation",
+  "overflow-block",
+  "overflow-inline",
+  "pointer",
+  "prefers-color-scheme",
+  "prefers-contrast",
+  "prefers-reduced-motion",
+  "prefers-reduced-transparency",
+  "resolution",
+  "scan",
+  "scripting",
+  "update",
+  "width",
+  // TODO: find a better solution?
+  "min-width",
+  "max-width",
+  "min-height",
+  "max-height"
+], hn = [
+  "active",
+  "any-link",
+  "blank",
+  "checked",
+  "current",
+  "default",
+  "defined",
+  "dir",
+  // dir()
+  "disabled",
+  "drop",
+  "empty",
+  "enabled",
+  "first",
+  "first-child",
+  "first-of-type",
+  "fullscreen",
+  "future",
+  "focus",
+  "focus-visible",
+  "focus-within",
+  "has",
+  // has()
+  "host",
+  // host or host()
+  "host-context",
+  // host-context()
+  "hover",
+  "indeterminate",
+  "in-range",
+  "invalid",
+  "is",
+  // is()
+  "lang",
+  // lang()
+  "last-child",
+  "last-of-type",
+  "left",
+  "link",
+  "local-link",
+  "not",
+  // not()
+  "nth-child",
+  // nth-child()
+  "nth-col",
+  // nth-col()
+  "nth-last-child",
+  // nth-last-child()
+  "nth-last-col",
+  // nth-last-col()
+  "nth-last-of-type",
+  //nth-last-of-type()
+  "nth-of-type",
+  //nth-of-type()
+  "only-child",
+  "only-of-type",
+  "optional",
+  "out-of-range",
+  "past",
+  "placeholder-shown",
+  "read-only",
+  "read-write",
+  "required",
+  "right",
+  "root",
+  "scope",
+  "target",
+  "target-within",
+  "user-invalid",
+  "valid",
+  "visited",
+  "where"
+  // where()
+], bn = [
+  "after",
+  "backdrop",
+  "before",
+  "cue",
+  "cue-region",
+  "first-letter",
+  "first-line",
+  "grammar-error",
+  "marker",
+  "part",
+  "placeholder",
+  "selection",
+  "slotted",
+  "spelling-error"
+], En = [
+  "align-content",
+  "align-items",
+  "align-self",
+  "all",
+  "animation",
+  "animation-delay",
+  "animation-direction",
+  "animation-duration",
+  "animation-fill-mode",
+  "animation-iteration-count",
+  "animation-name",
+  "animation-play-state",
+  "animation-timing-function",
+  "backface-visibility",
+  "background",
+  "background-attachment",
+  "background-blend-mode",
+  "background-clip",
+  "background-color",
+  "background-image",
+  "background-origin",
+  "background-position",
+  "background-repeat",
+  "background-size",
+  "block-size",
+  "border",
+  "border-block",
+  "border-block-color",
+  "border-block-end",
+  "border-block-end-color",
+  "border-block-end-style",
+  "border-block-end-width",
+  "border-block-start",
+  "border-block-start-color",
+  "border-block-start-style",
+  "border-block-start-width",
+  "border-block-style",
+  "border-block-width",
+  "border-bottom",
+  "border-bottom-color",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  "border-bottom-style",
+  "border-bottom-width",
+  "border-collapse",
+  "border-color",
+  "border-image",
+  "border-image-outset",
+  "border-image-repeat",
+  "border-image-slice",
+  "border-image-source",
+  "border-image-width",
+  "border-inline",
+  "border-inline-color",
+  "border-inline-end",
+  "border-inline-end-color",
+  "border-inline-end-style",
+  "border-inline-end-width",
+  "border-inline-start",
+  "border-inline-start-color",
+  "border-inline-start-style",
+  "border-inline-start-width",
+  "border-inline-style",
+  "border-inline-width",
+  "border-left",
+  "border-left-color",
+  "border-left-style",
+  "border-left-width",
+  "border-radius",
+  "border-right",
+  "border-right-color",
+  "border-right-style",
+  "border-right-width",
+  "border-spacing",
+  "border-style",
+  "border-top",
+  "border-top-color",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-top-style",
+  "border-top-width",
+  "border-width",
+  "bottom",
+  "box-decoration-break",
+  "box-shadow",
+  "box-sizing",
+  "break-after",
+  "break-before",
+  "break-inside",
+  "caption-side",
+  "caret-color",
+  "clear",
+  "clip",
+  "clip-path",
+  "clip-rule",
+  "color",
+  "column-count",
+  "column-fill",
+  "column-gap",
+  "column-rule",
+  "column-rule-color",
+  "column-rule-style",
+  "column-rule-width",
+  "column-span",
+  "column-width",
+  "columns",
+  "contain",
+  "content",
+  "content-visibility",
+  "counter-increment",
+  "counter-reset",
+  "cue",
+  "cue-after",
+  "cue-before",
+  "cursor",
+  "direction",
+  "display",
+  "empty-cells",
+  "filter",
+  "flex",
+  "flex-basis",
+  "flex-direction",
+  "flex-flow",
+  "flex-grow",
+  "flex-shrink",
+  "flex-wrap",
+  "float",
+  "flow",
+  "font",
+  "font-display",
+  "font-family",
+  "font-feature-settings",
+  "font-kerning",
+  "font-language-override",
+  "font-size",
+  "font-size-adjust",
+  "font-smoothing",
+  "font-stretch",
+  "font-style",
+  "font-synthesis",
+  "font-variant",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-ligatures",
+  "font-variant-numeric",
+  "font-variant-position",
+  "font-variation-settings",
+  "font-weight",
+  "gap",
+  "glyph-orientation-vertical",
+  "grid",
+  "grid-area",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "grid-auto-rows",
+  "grid-column",
+  "grid-column-end",
+  "grid-column-start",
+  "grid-gap",
+  "grid-row",
+  "grid-row-end",
+  "grid-row-start",
+  "grid-template",
+  "grid-template-areas",
+  "grid-template-columns",
+  "grid-template-rows",
+  "hanging-punctuation",
+  "height",
+  "hyphens",
+  "icon",
+  "image-orientation",
+  "image-rendering",
+  "image-resolution",
+  "ime-mode",
+  "inline-size",
+  "isolation",
+  "justify-content",
+  "left",
+  "letter-spacing",
+  "line-break",
+  "line-height",
+  "list-style",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "margin",
+  "margin-block",
+  "margin-block-end",
+  "margin-block-start",
+  "margin-bottom",
+  "margin-inline",
+  "margin-inline-end",
+  "margin-inline-start",
+  "margin-left",
+  "margin-right",
+  "margin-top",
+  "marks",
+  "mask",
+  "mask-border",
+  "mask-border-mode",
+  "mask-border-outset",
+  "mask-border-repeat",
+  "mask-border-slice",
+  "mask-border-source",
+  "mask-border-width",
+  "mask-clip",
+  "mask-composite",
+  "mask-image",
+  "mask-mode",
+  "mask-origin",
+  "mask-position",
+  "mask-repeat",
+  "mask-size",
+  "mask-type",
+  "max-block-size",
+  "max-height",
+  "max-inline-size",
+  "max-width",
+  "min-block-size",
+  "min-height",
+  "min-inline-size",
+  "min-width",
+  "mix-blend-mode",
+  "nav-down",
+  "nav-index",
+  "nav-left",
+  "nav-right",
+  "nav-up",
+  "none",
+  "normal",
+  "object-fit",
+  "object-position",
+  "opacity",
+  "order",
+  "orphans",
+  "outline",
+  "outline-color",
+  "outline-offset",
+  "outline-style",
+  "outline-width",
+  "overflow",
+  "overflow-wrap",
+  "overflow-x",
+  "overflow-y",
+  "padding",
+  "padding-block",
+  "padding-block-end",
+  "padding-block-start",
+  "padding-bottom",
+  "padding-inline",
+  "padding-inline-end",
+  "padding-inline-start",
+  "padding-left",
+  "padding-right",
+  "padding-top",
+  "page-break-after",
+  "page-break-before",
+  "page-break-inside",
+  "pause",
+  "pause-after",
+  "pause-before",
+  "perspective",
+  "perspective-origin",
+  "pointer-events",
+  "position",
+  "quotes",
+  "resize",
+  "rest",
+  "rest-after",
+  "rest-before",
+  "right",
+  "row-gap",
+  "scroll-margin",
+  "scroll-margin-block",
+  "scroll-margin-block-end",
+  "scroll-margin-block-start",
+  "scroll-margin-bottom",
+  "scroll-margin-inline",
+  "scroll-margin-inline-end",
+  "scroll-margin-inline-start",
+  "scroll-margin-left",
+  "scroll-margin-right",
+  "scroll-margin-top",
+  "scroll-padding",
+  "scroll-padding-block",
+  "scroll-padding-block-end",
+  "scroll-padding-block-start",
+  "scroll-padding-bottom",
+  "scroll-padding-inline",
+  "scroll-padding-inline-end",
+  "scroll-padding-inline-start",
+  "scroll-padding-left",
+  "scroll-padding-right",
+  "scroll-padding-top",
+  "scroll-snap-align",
+  "scroll-snap-stop",
+  "scroll-snap-type",
+  "scrollbar-color",
+  "scrollbar-gutter",
+  "scrollbar-width",
+  "shape-image-threshold",
+  "shape-margin",
+  "shape-outside",
+  "speak",
+  "speak-as",
+  "src",
+  // @font-face
+  "tab-size",
+  "table-layout",
+  "text-align",
+  "text-align-all",
+  "text-align-last",
+  "text-combine-upright",
+  "text-decoration",
+  "text-decoration-color",
+  "text-decoration-line",
+  "text-decoration-style",
+  "text-emphasis",
+  "text-emphasis-color",
+  "text-emphasis-position",
+  "text-emphasis-style",
+  "text-indent",
+  "text-justify",
+  "text-orientation",
+  "text-overflow",
+  "text-rendering",
+  "text-shadow",
+  "text-transform",
+  "text-underline-position",
+  "top",
+  "transform",
+  "transform-box",
+  "transform-origin",
+  "transform-style",
+  "transition",
+  "transition-delay",
+  "transition-duration",
+  "transition-property",
+  "transition-timing-function",
+  "unicode-bidi",
+  "vertical-align",
+  "visibility",
+  "voice-balance",
+  "voice-duration",
+  "voice-family",
+  "voice-pitch",
+  "voice-range",
+  "voice-rate",
+  "voice-stress",
+  "voice-volume",
+  "white-space",
+  "widows",
+  "width",
+  "will-change",
+  "word-break",
+  "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
+  ];
+  return {
+    name: "CSS",
+    case_insensitive: !0,
+    illegal: /[=|'\$]/,
+    keywords: { keyframePosition: "from to" },
+    classNameAliases: {
+      // for visual continuity with `tag {}` and because we
+      // don't have a great class for this?
+      keyframePosition: "selector-tag"
+    },
+    contains: [
+      n.BLOCK_COMMENT,
+      i,
+      // to recognize keyframe 40% etc which are outside the scope of our
+      // attribute value mode
+      n.CSS_NUMBER_MODE,
+      {
+        className: "selector-id",
+        begin: /#[A-Za-z0-9_-]+/,
+        relevance: 0
+      },
+      {
+        className: "selector-class",
+        begin: "\\." + o,
+        relevance: 0
+      },
+      n.ATTRIBUTE_SELECTOR_MODE,
+      {
+        className: "selector-pseudo",
+        variants: [
+          { begin: ":(" + hn.join("|") + ")" },
+          { begin: ":(:)?(" + bn.join("|") + ")" }
+        ]
+      },
+      // we may actually need this (12/2020)
+      // { // pseudo-selector params
+      //   begin: /\(/,
+      //   end: /\)/,
+      //   contains: [ hljs.CSS_NUMBER_MODE ]
+      // },
+      n.CSS_VARIABLE,
+      {
+        className: "attribute",
+        begin: "\\b(" + En.join("|") + ")\\b"
+      },
+      // attribute values
+      {
+        begin: /:/,
+        end: /[;}{]/,
+        contains: [
+          n.BLOCK_COMMENT,
+          n.HEXCOLOR,
+          n.IMPORTANT,
+          n.CSS_NUMBER_MODE,
+          ...s,
+          // 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
+          {
+            begin: /(url|data-uri)\(/,
+            end: /\)/,
+            relevance: 0,
+            // from keywords
+            keywords: { built_in: "url data-uri" },
+            contains: [
+              ...s,
+              {
+                className: "string",
+                // any character other than `)` as in `url()` will be the start
+                // of a string, which ends with `)` (from the parent mode)
+                begin: /[^)]/,
+                endsWithParent: !0,
+                excludeEnd: !0
+              }
+            ]
+          },
+          n.FUNCTION_DISPATCH
+        ]
+      },
+      {
+        begin: t.lookahead(/@/),
+        end: "[{;]",
+        relevance: 0,
+        illegal: /:/,
+        // break on Less variables @var: ...
+        contains: [
+          {
+            className: "keyword",
+            begin: f
+          },
+          {
+            begin: /\s/,
+            endsWithParent: !0,
+            excludeEnd: !0,
+            relevance: 0,
+            keywords: {
+              $pattern: /[a-z-]+/,
+              keyword: u,
+              attribute: pn.join(" ")
+            },
+            contains: [
+              {
+                begin: /[a-z-]+(?=:)/,
+                className: "attribute"
+              },
+              ...s,
+              n.CSS_NUMBER_MODE
+            ]
+          }
+        ]
+      },
+      {
+        className: "selector-tag",
+        begin: "\\b(" + fn.join("|") + ")\\b"
+      }
+    ]
+  };
+}
+const nt = document.createElement("style");
+nt.innerText = [gt, ft].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");
+    });
+  }), n.appendChild(t), n.appendChild(i), i.classList.add("tab-content"), e[0].setAttribute("selected", ""), i.appendChild(e[0].content), n;
+}
+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 q(e, t) {
+  const n = document.createElement(e);
+  return typeof t == "string" ? n.innerHTML = t : t.forEach((i) => {
+    n.appendChild(i);
+  }), n;
+}
+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)
+      )
+    ] : [],
+    ...(t.additionalSources || []).map((w) => Y(w.label, ae(w.language, w.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);
+}
+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(`
+`).trim();
+  return e && e != "raw" && (n = ue.highlight(n, { language: e }).value), q("pre", [q("code", n)]);
+}
+function xn(e, t) {
+  const n = document.createElement("style");
+  n.innerHTML = dt().use(ut({ prefix: e })).process(t).css, document.head.appendChild(n);
+}
+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++);
+  });
+}
+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 Nn(e) {
+  return e.children ? wn(e) : e;
+}
+export {
+  yn as initialize,
+  An as initializeExamplesForModules,
+  xn as loadPrefixedStylesheet
+};
+//# sourceMappingURL=element-preview.mjs.map