import {
  a as n,
  c as te
} from "./chunk-IO47FP3U.js";

// ../node_modules/highlight.js/lib/core.js
var ze = te((vn, Fe) => {
  function ve(e) {
    return e instanceof Map ? e.clear = e.delete = e.set = function() {
      throw new Error("map is read-only");
    } : e instanceof Set && (e.add = e.clear = e.delete = function() {
      throw new Error("set is read-only");
    }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach(function(t) {
      var r = e[t];
      typeof r == "object" && !Object.isFrozen(r) && ve(r);
    }), e;
  }
  n(ve, "deepFreeze");
  var Ce = ve, Et = ve;
  Ce.default = Et;
  var ye = class ye {
    /**
     * @param {CompiledMode} mode
     */
    constructor(t) {
      t.data === void 0 && (t.data = {}), this.data = t.data, this.isMatchIgnored = !1;
    }
    ignoreMatch() {
      this.isMatchIgnored = !0;
    }
  };
  n(ye, "Response");
  var re = ye;
  function z(e) {
    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
  }
  n(z, "escapeHTML");
  function H(e, ...t) {
    let r = /* @__PURE__ */ Object.create(null);
    for (let s in e)
      r[s] = e[s];
    return t.forEach(function(s) {
      for (let u in s)
        r[u] = s[u];
    }), /** @type {T} */
    r;
  }
  n(H, "inherit");
  var bt = "</span>", Ie = /* @__PURE__ */ n((e) => !!e.kind, "emitsWrappingTags"), we = class we {
    /**
     * 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 += z(t);
    }
    /**
     * Adds a node open to the output stream (if needed)
     *
     * @param {Node} node */
    openNode(t) {
      if (!Ie(t)) return;
      let r = t.kind;
      t.sublanguage || (r = `${this.classPrefix}${r}`), this.span(r);
    }
    /**
     * Adds a node close to the output stream (if needed)
     *
     * @param {Node} node */
    closeNode(t) {
      Ie(t) && (this.buffer += bt);
    }
    /**
     * returns the accumulated buffer
    */
    value() {
      return this.buffer;
    }
    // helpers
    /**
     * Builds a span element
     *
     * @param {string} className */
    span(t) {
      this.buffer += `<span class="${t}">`;
    }
  };
  n(we, "HTMLRenderer");
  var pe = we, ie = class ie {
    constructor() {
      this.rootNode = { children: [] }, 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} kind */
    openNode(t) {
      let r = { kind: t, children: [] };
      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((s) => this._walk(t, s)), 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) => {
        ie._collapse(r);
      }));
    }
  };
  n(ie, "TokenTree");
  var Ee = ie, Re = class Re extends Ee {
    /**
     * @param {*} options
     */
    constructor(t) {
      super(), this.options = t;
    }
    /**
     * @param {string} text
     * @param {string} kind
     */
    addKeyword(t, r) {
      t !== "" && (this.openNode(r), this.addText(t), this.closeNode());
    }
    /**
     * @param {string} text
     */
    addText(t) {
      t !== "" && this.add(t);
    }
    /**
     * @param {Emitter & {root: DataNode}} emitter
     * @param {string} name
     */
    addSublanguage(t, r) {
      let s = t.root;
      s.kind = r, s.sublanguage = !0, this.add(s);
    }
    toHTML() {
      return new pe(this, this.options).value();
    }
    finalize() {
      return !0;
    }
  };
  n(Re, "TokenTreeEmitter");
  var be = Re;
  function xt(e) {
    return new RegExp(e.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"), "m");
  }
  n(xt, "escape");
  function q(e) {
    return e ? typeof e == "string" ? e : e.source : null;
  }
  n(q, "source");
  function vt(...e) {
    return e.map((r) => q(r)).join("");
  }
  n(vt, "concat");
  function Nt(...e) {
    return "(" + e.map((r) => q(r)).join("|") + ")";
  }
  n(Nt, "either");
  function _t(e) {
    return new RegExp(e.toString() + "|").exec("").length - 1;
  }
  n(_t, "countMatchGroups");
  function yt(e, t) {
    let r = e && e.exec(t);
    return r && r.index === 0;
  }
  n(yt, "startsWith");
  var wt = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
  function Rt(e, t = "|") {
    let r = 0;
    return e.map((s) => {
      r += 1;
      let u = r, h = q(s), v = "";
      for (; h.length > 0; ) {
        let d = wt.exec(h);
        if (!d) {
          v += h;
          break;
        }
        v += h.substring(0, d.index), h = h.substring(d.index + d[0].length), d[0][0] === "\\" && d[1] ? v += "\\" + String(Number(d[1]) + u) : (v += d[0], d[0] === "(" && r++);
      }
      return v;
    }).map((s) => `(${s})`).join(t);
  }
  n(Rt, "join");
  var Mt = /\b\B/, He = "[a-zA-Z]\\w*", Ne = "[a-zA-Z_]\\w*", _e = "\\b\\d+(\\.\\d+)?", Ue = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", je = "\\b(0b[01]+)", mt = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", Ot = /* @__PURE__ */ n((e = {}) => {
    let t = /^#![ ]*\//;
    return e.binary && (e.begin = vt(
      t,
      /.*\b/,
      e.binary,
      /\b.*/
    )), H({
      className: "meta",
      begin: t,
      end: /$/,
      relevance: 0,
      /** @type {ModeCallback} */
      "on:begin": /* @__PURE__ */ n((r, s) => {
        r.index !== 0 && s.ignoreMatch();
      }, "on:begin")
    }, e);
  }, "SHEBANG"), X = {
    begin: "\\\\[\\s\\S]",
    relevance: 0
  }, At = {
    className: "string",
    begin: "'",
    end: "'",
    illegal: "\\n",
    contains: [X]
  }, kt = {
    className: "string",
    begin: '"',
    end: '"',
    illegal: "\\n",
    contains: [X]
  }, $e = {
    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/
  }, se = /* @__PURE__ */ n(function(e, t, r = {}) {
    let s = H(
      {
        className: "comment",
        begin: e,
        end: t,
        contains: []
      },
      r
    );
    return s.contains.push($e), s.contains.push({
      className: "doctag",
      begin: "(?:TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):",
      relevance: 0
    }), s;
  }, "COMMENT"), St = se("//", "$"), It = se("/\\*", "\\*/"), Lt = se("#", "$"), Bt = {
    className: "number",
    begin: _e,
    relevance: 0
  }, Dt = {
    className: "number",
    begin: Ue,
    relevance: 0
  }, Pt = {
    className: "number",
    begin: je,
    relevance: 0
  }, Tt = {
    className: "number",
    begin: _e + "(%|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
  }, Ct = {
    // this outer rule makes sure we actually have a WHOLE regex and not simply
    // an expression such as:
    //
    //     3 / something
    //
    // (which will then blow up when regex's `illegal` sees the newline)
    begin: /(?=\/[^/\n]*\/)/,
    contains: [{
      className: "regexp",
      begin: /\//,
      end: /\/[gimuy]*/,
      illegal: /\n/,
      contains: [
        X,
        {
          begin: /\[/,
          end: /\]/,
          relevance: 0,
          contains: [X]
        }
      ]
    }]
  }, Ht = {
    className: "title",
    begin: He,
    relevance: 0
  }, Ut = {
    className: "title",
    begin: Ne,
    relevance: 0
  }, jt = {
    // excludes method names from keyword processing
    begin: "\\.\\s*" + Ne,
    relevance: 0
  }, $t = /* @__PURE__ */ n(function(e) {
    return Object.assign(
      e,
      {
        /** @type {ModeCallback} */
        "on:begin": /* @__PURE__ */ n((t, r) => {
          r.data._beginMatch = t[1];
        }, "on:begin"),
        /** @type {ModeCallback} */
        "on:end": /* @__PURE__ */ n((t, r) => {
          r.data._beginMatch !== t[1] && r.ignoreMatch();
        }, "on:end")
      }
    );
  }, "END_SAME_AS_BEGIN"), ne = Object.freeze({
    __proto__: null,
    MATCH_NOTHING_RE: Mt,
    IDENT_RE: He,
    UNDERSCORE_IDENT_RE: Ne,
    NUMBER_RE: _e,
    C_NUMBER_RE: Ue,
    BINARY_NUMBER_RE: je,
    RE_STARTERS_RE: mt,
    SHEBANG: Ot,
    BACKSLASH_ESCAPE: X,
    APOS_STRING_MODE: At,
    QUOTE_STRING_MODE: kt,
    PHRASAL_WORDS_MODE: $e,
    COMMENT: se,
    C_LINE_COMMENT_MODE: St,
    C_BLOCK_COMMENT_MODE: It,
    HASH_COMMENT_MODE: Lt,
    NUMBER_MODE: Bt,
    C_NUMBER_MODE: Dt,
    BINARY_NUMBER_MODE: Pt,
    CSS_NUMBER_MODE: Tt,
    REGEXP_MODE: Ct,
    TITLE_MODE: Ht,
    UNDERSCORE_TITLE_MODE: Ut,
    METHOD_GUARD: jt,
    END_SAME_AS_BEGIN: $t
  });
  function Gt(e, t) {
    e.input[e.index - 1] === "." && t.ignoreMatch();
  }
  n(Gt, "skipIfhasPrecedingDot");
  function Kt(e, t) {
    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = Gt, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
  }
  n(Kt, "beginKeywords");
  function Ft(e, t) {
    Array.isArray(e.illegal) && (e.illegal = Nt(...e.illegal));
  }
  n(Ft, "compileIllegal");
  function zt(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;
    }
  }
  n(zt, "compileMatch");
  function Wt(e, t) {
    e.relevance === void 0 && (e.relevance = 1);
  }
  n(Wt, "compileRelevance");
  var Vt = [
    "of",
    "and",
    "for",
    "in",
    "not",
    "or",
    "if",
    "then",
    "parent",
    // common variable name
    "list",
    // common variable name
    "value"
    // common variable name
  ], qt = "keyword";
  function Ge(e, t, r = qt) {
    let s = {};
    return typeof e == "string" ? u(r, e.split(" ")) : Array.isArray(e) ? u(r, e) : Object.keys(e).forEach(function(h) {
      Object.assign(
        s,
        Ge(e[h], t, h)
      );
    }), s;
    function u(h, v) {
      t && (v = v.map((d) => d.toLowerCase())), v.forEach(function(d) {
        let p = d.split("|");
        s[p[0]] = [h, Xt(p[0], p[1])];
      });
    }
    n(u, "compileList");
  }
  n(Ge, "compileKeywords");
  function Xt(e, t) {
    return t ? Number(t) : Yt(e) ? 0 : 1;
  }
  n(Xt, "scoreForKeyword");
  function Yt(e) {
    return Vt.includes(e.toLowerCase());
  }
  n(Yt, "commonKeyword");
  function Jt(e, { plugins: t }) {
    function r(a, l) {
      return new RegExp(
        q(a),
        "m" + (e.case_insensitive ? "i" : "") + (l ? "g" : "")
      );
    }
    n(r, "langRe");
    let d = class d {
      constructor() {
        this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
      }
      // @ts-ignore
      addRule(l, f) {
        f.position = this.position++, this.matchIndexes[this.matchAt] = f, this.regexes.push([f, l]), this.matchAt += _t(l) + 1;
      }
      compile() {
        this.regexes.length === 0 && (this.exec = () => null);
        let l = this.regexes.map((f) => f[1]);
        this.matcherRe = r(Rt(l), !0), this.lastIndex = 0;
      }
      /** @param {string} s */
      exec(l) {
        this.matcherRe.lastIndex = this.lastIndex;
        let f = this.matcherRe.exec(l);
        if (!f)
          return null;
        let N = f.findIndex((S, G) => G > 0 && S !== void 0), w = this.matchIndexes[N];
        return f.splice(0, N), Object.assign(f, w);
      }
    };
    n(d, "MultiRegex");
    let s = d, p = class p {
      constructor() {
        this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
      }
      // @ts-ignore
      getMatcher(l) {
        if (this.multiRegexes[l]) return this.multiRegexes[l];
        let f = new s();
        return this.rules.slice(l).forEach(([N, w]) => f.addRule(N, w)), f.compile(), this.multiRegexes[l] = f, f;
      }
      resumingScanAtSamePosition() {
        return this.regexIndex !== 0;
      }
      considerAll() {
        this.regexIndex = 0;
      }
      // @ts-ignore
      addRule(l, f) {
        this.rules.push([l, f]), f.type === "begin" && this.count++;
      }
      /** @param {string} s */
      exec(l) {
        let f = this.getMatcher(this.regexIndex);
        f.lastIndex = this.lastIndex;
        let N = f.exec(l);
        if (this.resumingScanAtSamePosition() && !(N && N.index === this.lastIndex)) {
          let w = this.getMatcher(0);
          w.lastIndex = this.lastIndex + 1, N = w.exec(l);
        }
        return N && (this.regexIndex += N.position + 1, this.regexIndex === this.count && this.considerAll()), N;
      }
    };
    n(p, "ResumableMultiRegex");
    let u = p;
    function h(a) {
      let l = new u();
      return a.contains.forEach((f) => l.addRule(f.begin, { rule: f, type: "begin" })), a.terminatorEnd && l.addRule(a.terminatorEnd, { type: "end" }), a.illegal && l.addRule(a.illegal, { type: "illegal" }), l;
    }
    n(h, "buildModeRegex");
    function v(a, l) {
      let f = (
        /** @type CompiledMode */
        a
      );
      if (a.isCompiled) return f;
      [
        // do this early so compiler extensions generally don't have to worry about
        // the distinction between match/begin
        zt
      ].forEach((w) => w(a, l)), e.compilerExtensions.forEach((w) => w(a, l)), a.__beforeBegin = null, [
        Kt,
        // 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((w) => w(a, l)), a.isCompiled = !0;
      let N = null;
      if (typeof a.keywords == "object" && (N = a.keywords.$pattern, delete a.keywords.$pattern), a.keywords && (a.keywords = Ge(a.keywords, e.case_insensitive)), a.lexemes && N)
        throw new Error("ERR: Prefer `keywords.$pattern` to `mode.lexemes`, BOTH are not allowed. (see mode reference) ");
      return N = N || a.lexemes || /\w+/, f.keywordPatternRe = r(N, !0), l && (a.begin || (a.begin = /\B|\b/), f.beginRe = r(a.begin), a.endSameAsBegin && (a.end = a.begin), !a.end && !a.endsWithParent && (a.end = /\B|\b/), a.end && (f.endRe = r(a.end)), f.terminatorEnd = q(a.end) || "", a.endsWithParent && l.terminatorEnd && (f.terminatorEnd += (a.end ? "|" : "") + l.terminatorEnd)), a.illegal && (f.illegalRe = r(
        /** @type {RegExp | string} */
        a.illegal
      )), a.contains || (a.contains = []), a.contains = [].concat(...a.contains.map(function(w) {
        return Zt(w === "self" ? a : w);
      })), a.contains.forEach(function(w) {
        v(
          /** @type Mode */
          w,
          f
        );
      }), a.starts && v(a.starts, l), f.matcher = h(f), f;
    }
    if (n(v, "compileMode"), 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 = H(e.classNameAliases || {}), v(
      /** @type Mode */
      e
    );
  }
  n(Jt, "compileLanguage");
  function Ke(e) {
    return e ? e.endsWithParent || Ke(e.starts) : !1;
  }
  n(Ke, "dependencyOnParent");
  function Zt(e) {
    return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
      return H(e, { variants: null }, t);
    })), e.cachedVariants ? e.cachedVariants : Ke(e) ? H(e, { starts: e.starts ? H(e.starts) : null }) : Object.isFrozen(e) ? H(e) : e;
  }
  n(Zt, "expandOrCloneMode");
  var Qt = "10.7.3";
  function en(e) {
    return !!(e || e === "");
  }
  n(en, "hasValueOrEmptyAttribute");
  function tn(e) {
    let t = {
      props: ["language", "code", "autodetect"],
      data: /* @__PURE__ */ n(function() {
        return {
          detectedLanguage: "",
          unknownLanguage: !1
        };
      }, "data"),
      computed: {
        className() {
          return this.unknownLanguage ? "" : "hljs " + this.detectedLanguage;
        },
        highlighted() {
          if (!this.autoDetect && !e.getLanguage(this.language))
            return console.warn(`The language "${this.language}" you specified could not be found.`), this.unknownLanguage = !0, z(this.code);
          let s = {};
          return this.autoDetect ? (s = e.highlightAuto(this.code), this.detectedLanguage = s.language) : (s = e.highlight(this.language, this.code, this.ignoreIllegals), this.detectedLanguage = this.language), s.value;
        },
        autoDetect() {
          return !this.language || en(this.autodetect);
        },
        ignoreIllegals() {
          return !0;
        }
      },
      // this avoids needing to use a whole Vue compilation pipeline just
      // to build Highlight.js
      render(s) {
        return s("pre", {}, [
          s("code", {
            class: this.className,
            domProps: { innerHTML: this.highlighted }
          })
        ]);
      }
      // template: `<pre><code :class="className" v-html="highlighted"></code></pre>`
    };
    return { Component: t, VuePlugin: {
      install(s) {
        s.component("highlightjs", t);
      }
    } };
  }
  n(tn, "BuildVuePlugin");
  var nn = {
    "after:highlightElement": /* @__PURE__ */ n(({ el: e, result: t, text: r }) => {
      let s = Le(e);
      if (!s.length) return;
      let u = document.createElement("div");
      u.innerHTML = t.value, t.value = rn(s, Le(u), r);
    }, "after:highlightElement")
  };
  function xe(e) {
    return e.nodeName.toLowerCase();
  }
  n(xe, "tag");
  function Le(e) {
    let t = [];
    return (/* @__PURE__ */ n(function r(s, u) {
      for (let h = s.firstChild; h; h = h.nextSibling)
        h.nodeType === 3 ? u += h.nodeValue.length : h.nodeType === 1 && (t.push({
          event: "start",
          offset: u,
          node: h
        }), u = r(h, u), xe(h).match(/br|hr|img|input/) || t.push({
          event: "stop",
          offset: u,
          node: h
        }));
      return u;
    }, "_nodeStream"))(e, 0), t;
  }
  n(Le, "nodeStream");
  function rn(e, t, r) {
    let s = 0, u = "", h = [];
    function v() {
      return !e.length || !t.length ? e.length ? e : t : e[0].offset !== t[0].offset ? e[0].offset < t[0].offset ? e : t : t[0].event === "start" ? e : t;
    }
    n(v, "selectStream");
    function d(l) {
      function f(N) {
        return " " + N.nodeName + '="' + z(N.value) + '"';
      }
      n(f, "attributeString"), u += "<" + xe(l) + [].map.call(l.attributes, f).join("") + ">";
    }
    n(d, "open");
    function p(l) {
      u += "</" + xe(l) + ">";
    }
    n(p, "close");
    function a(l) {
      (l.event === "start" ? d : p)(l.node);
    }
    for (n(a, "render"); e.length || t.length; ) {
      let l = v();
      if (u += z(r.substring(s, l[0].offset)), s = l[0].offset, l === e) {
        h.reverse().forEach(p);
        do
          a(l.splice(0, 1)[0]), l = v();
        while (l === e && l.length && l[0].offset === s);
        h.reverse().forEach(d);
      } else
        l[0].event === "start" ? h.push(l[0].node) : h.pop(), a(l.splice(0, 1)[0]);
    }
    return u + z(r.substr(s));
  }
  n(rn, "mergeStreams");
  var Be = {}, he = /* @__PURE__ */ n((e) => {
    console.error(e);
  }, "error"), De = /* @__PURE__ */ n((e, ...t) => {
    console.log(`WARN: ${e}`, ...t);
  }, "warn"), A = /* @__PURE__ */ n((e, t) => {
    Be[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), Be[`${e}/${t}`] = !0);
  }, "deprecated"), de = z, Pe = H, Te = Symbol("nomatch"), sn = /* @__PURE__ */ n(function(e) {
    let t = /* @__PURE__ */ Object.create(null), r = /* @__PURE__ */ Object.create(null), s = [], u = !0, h = /(^(<[^>]+>|\t|)+|\n)/gm, v = "Could not find the language '{}', did you forget to load/include a language module?", d = { disableAutodetect: !0, name: "Plain text", contains: [] }, p = {
      noHighlightRe: /^(no-?highlight)$/i,
      languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
      classPrefix: "hljs-",
      tabReplace: null,
      useBR: !1,
      languages: null,
      // beta configuration options, subject to change, welcome to discuss
      // https://github.com/highlightjs/highlight.js/issues/1086
      __emitter: be
    };
    function a(i) {
      return p.noHighlightRe.test(i);
    }
    n(a, "shouldNotHighlight");
    function l(i) {
      let o = i.className + " ";
      o += i.parentNode ? i.parentNode.className : "";
      let x = p.languageDetectRe.exec(o);
      if (x) {
        let y = P(x[1]);
        return y || (De(v.replace("{}", x[1])), De("Falling back to no-highlight mode for this block.", i)), y ? x[1] : "no-highlight";
      }
      return o.split(/\s+/).find((y) => a(y) || P(y));
    }
    n(l, "blockLanguage");
    function f(i, o, x, y) {
      let M = "", $ = "";
      typeof o == "object" ? (M = i, x = o.ignoreIllegals, $ = o.language, y = void 0) : (A("10.7.0", "highlight(lang, code, ...args) has been deprecated."), A("10.7.0", `Please use highlight(code, options) instead.
https://github.com/highlightjs/highlight.js/issues/2277`), $ = i, M = o);
      let I = {
        code: M,
        language: $
      };
      J("before:highlight", I);
      let L = I.result ? I.result : N(I.language, I.code, x, y);
      return L.code = I.code, J("after:highlight", L), L;
    }
    n(f, "highlight");
    function N(i, o, x, y) {
      function M(c, g) {
        let b = K.case_insensitive ? g[0].toLowerCase() : g[0];
        return Object.prototype.hasOwnProperty.call(c.keywords, b) && c.keywords[b];
      }
      n(M, "keywordData");
      function $() {
        if (!E.keywords) {
          m.addText(R);
          return;
        }
        let c = 0;
        E.keywordPatternRe.lastIndex = 0;
        let g = E.keywordPatternRe.exec(R), b = "";
        for (; g; ) {
          b += R.substring(c, g.index);
          let _ = M(E, g);
          if (_) {
            let [O, ee] = _;
            if (m.addText(b), b = "", Q += ee, O.startsWith("_"))
              b += g[0];
            else {
              let pt = K.classNameAliases[O] || O;
              m.addKeyword(g[0], pt);
            }
          } else
            b += g[0];
          c = E.keywordPatternRe.lastIndex, g = E.keywordPatternRe.exec(R);
        }
        b += R.substr(c), m.addText(b);
      }
      n($, "processKeywords");
      function I() {
        if (R === "") return;
        let c = null;
        if (typeof E.subLanguage == "string") {
          if (!t[E.subLanguage]) {
            m.addText(R);
            return;
          }
          c = N(E.subLanguage, R, !0, Se[E.subLanguage]), Se[E.subLanguage] = /** @type {CompiledMode} */
          c.top;
        } else
          c = S(R, E.subLanguage.length ? E.subLanguage : null);
        E.relevance > 0 && (Q += c.relevance), m.addSublanguage(c.emitter, c.language);
      }
      n(I, "processSubLanguage");
      function L() {
        E.subLanguage != null ? I() : $(), R = "";
      }
      n(L, "processBuffer");
      function B(c) {
        return c.className && m.openNode(K.classNameAliases[c.className] || c.className), E = Object.create(c, { parent: { value: E } }), E;
      }
      n(B, "startNewMode");
      function C(c, g, b) {
        let _ = yt(c.endRe, b);
        if (_) {
          if (c["on:end"]) {
            let O = new re(c);
            c["on:end"](g, O), O.isMatchIgnored && (_ = !1);
          }
          if (_) {
            for (; c.endsParent && c.parent; )
              c = c.parent;
            return c;
          }
        }
        if (c.endsWithParent)
          return C(c.parent, g, b);
      }
      n(C, "endOfMode");
      function ut(c) {
        return E.matcher.regexIndex === 0 ? (R += c[0], 1) : (fe = !0, 0);
      }
      n(ut, "doIgnore");
      function gt(c) {
        let g = c[0], b = c.rule, _ = new re(b), O = [b.__beforeBegin, b["on:begin"]];
        for (let ee of O)
          if (ee && (ee(c, _), _.isMatchIgnored))
            return ut(g);
        return b && b.endSameAsBegin && (b.endRe = xt(g)), b.skip ? R += g : (b.excludeBegin && (R += g), L(), !b.returnBegin && !b.excludeBegin && (R = g)), B(b), b.returnBegin ? 0 : g.length;
      }
      n(gt, "doBeginMatch");
      function ft(c) {
        let g = c[0], b = o.substr(c.index), _ = C(E, c, b);
        if (!_)
          return Te;
        let O = E;
        O.skip ? R += g : (O.returnEnd || O.excludeEnd || (R += g), L(), O.excludeEnd && (R = g));
        do
          E.className && m.closeNode(), !E.skip && !E.subLanguage && (Q += E.relevance), E = E.parent;
        while (E !== _.parent);
        return _.starts && (_.endSameAsBegin && (_.starts.endRe = _.endRe), B(_.starts)), O.returnEnd ? 0 : g.length;
      }
      n(ft, "doEndMatch");
      function ht() {
        let c = [];
        for (let g = E; g !== K; g = g.parent)
          g.className && c.unshift(g.className);
        c.forEach((g) => m.openNode(g));
      }
      n(ht, "processContinuations");
      let Z = {};
      function ke(c, g) {
        let b = g && g[0];
        if (R += c, b == null)
          return L(), 0;
        if (Z.type === "begin" && g.type === "end" && Z.index === g.index && b === "") {
          if (R += o.slice(g.index, g.index + 1), !u) {
            let _ = new Error("0 width match regex");
            throw _.languageName = i, _.badRule = Z.rule, _;
          }
          return 1;
        }
        if (Z = g, g.type === "begin")
          return gt(g);
        if (g.type === "illegal" && !x) {
          let _ = new Error('Illegal lexeme "' + b + '" for mode "' + (E.className || "<unnamed>") + '"');
          throw _.mode = E, _;
        } else if (g.type === "end") {
          let _ = ft(g);
          if (_ !== Te)
            return _;
        }
        if (g.type === "illegal" && b === "")
          return 1;
        if (ge > 1e5 && ge > g.index * 3)
          throw new Error("potential infinite loop, way more iterations than matches");
        return R += b, b.length;
      }
      n(ke, "processLexeme");
      let K = P(i);
      if (!K)
        throw he(v.replace("{}", i)), new Error('Unknown language: "' + i + '"');
      let dt = Jt(K, { plugins: s }), ue = "", E = y || dt, Se = {}, m = new p.__emitter(p);
      ht();
      let R = "", Q = 0, F = 0, ge = 0, fe = !1;
      try {
        for (E.matcher.considerAll(); ; ) {
          ge++, fe ? fe = !1 : E.matcher.considerAll(), E.matcher.lastIndex = F;
          let c = E.matcher.exec(o);
          if (!c) break;
          let g = o.substring(F, c.index), b = ke(g, c);
          F = c.index + b;
        }
        return ke(o.substr(F)), m.closeAllNodes(), m.finalize(), ue = m.toHTML(), {
          // avoid possible breakage with v10 clients expecting
          // this to always be an integer
          relevance: Math.floor(Q),
          value: ue,
          language: i,
          illegal: !1,
          emitter: m,
          top: E
        };
      } catch (c) {
        if (c.message && c.message.includes("Illegal"))
          return {
            illegal: !0,
            illegalBy: {
              msg: c.message,
              context: o.slice(F - 100, F + 100),
              mode: c.mode
            },
            sofar: ue,
            relevance: 0,
            value: de(o),
            emitter: m
          };
        if (u)
          return {
            illegal: !1,
            relevance: 0,
            value: de(o),
            emitter: m,
            language: i,
            top: E,
            errorRaised: c
          };
        throw c;
      }
    }
    n(N, "_highlight");
    function w(i) {
      let o = {
        relevance: 0,
        emitter: new p.__emitter(p),
        value: de(i),
        illegal: !1,
        top: d
      };
      return o.emitter.addText(i), o;
    }
    n(w, "justTextHighlightResult");
    function S(i, o) {
      o = o || p.languages || Object.keys(t);
      let x = w(i), y = o.filter(P).filter(Ae).map(
        (B) => N(B, i, !1)
      );
      y.unshift(x);
      let M = y.sort((B, C) => {
        if (B.relevance !== C.relevance) return C.relevance - B.relevance;
        if (B.language && C.language) {
          if (P(B.language).supersetOf === C.language)
            return 1;
          if (P(C.language).supersetOf === B.language)
            return -1;
        }
        return 0;
      }), [$, I] = M, L = $;
      return L.second_best = I, L;
    }
    n(S, "highlightAuto");
    function G(i) {
      return p.tabReplace || p.useBR ? i.replace(h, (o) => o === `
` ? p.useBR ? "<br>" : o : p.tabReplace ? o.replace(/\t/g, p.tabReplace) : o) : i;
    }
    n(G, "fixMarkup");
    function k(i, o, x) {
      let y = o ? r[o] : x;
      i.classList.add("hljs"), y && i.classList.add(y);
    }
    n(k, "updateClassName");
    let le = {
      "before:highlightElement": /* @__PURE__ */ n(({ el: i }) => {
        p.useBR && (i.innerHTML = i.innerHTML.replace(/\n/g, "").replace(/<br[ /]*>/g, `
`));
      }, "before:highlightElement"),
      "after:highlightElement": /* @__PURE__ */ n(({ result: i }) => {
        p.useBR && (i.value = i.value.replace(/\n/g, "<br>"));
      }, "after:highlightElement")
    }, V = /^(<[^>]+>|\t)+/gm, Ze = {
      "after:highlightElement": /* @__PURE__ */ n(({ result: i }) => {
        p.tabReplace && (i.value = i.value.replace(
          V,
          (o) => o.replace(/\t/g, p.tabReplace)
        ));
      }, "after:highlightElement")
    };
    function Y(i) {
      let o = null, x = l(i);
      if (a(x)) return;
      J(
        "before:highlightElement",
        { el: i, language: x }
      ), o = i;
      let y = o.textContent, M = x ? f(y, { language: x, ignoreIllegals: !0 }) : S(y);
      J("after:highlightElement", { el: i, result: M, text: y }), i.innerHTML = M.value, k(i, x, M.language), i.result = {
        language: M.language,
        // TODO: remove with version 11.0
        re: M.relevance,
        relavance: M.relevance
      }, M.second_best && (i.second_best = {
        language: M.second_best.language,
        // TODO: remove with version 11.0
        re: M.second_best.relevance,
        relavance: M.second_best.relevance
      });
    }
    n(Y, "highlightElement");
    function Qe(i) {
      i.useBR && (A("10.3.0", "'useBR' will be removed entirely in v11.0"), A("10.3.0", "Please see https://github.com/highlightjs/highlight.js/issues/2559")), p = Pe(p, i);
    }
    n(Qe, "configure");
    let oe = /* @__PURE__ */ n(() => {
      if (oe.called) return;
      oe.called = !0, A("10.6.0", "initHighlighting() is deprecated.  Use highlightAll() instead."), document.querySelectorAll("pre code").forEach(Y);
    }, "initHighlighting");
    function et() {
      A("10.6.0", "initHighlightingOnLoad() is deprecated.  Use highlightAll() instead."), ce = !0;
    }
    n(et, "initHighlightingOnLoad");
    let ce = !1;
    function me() {
      if (document.readyState === "loading") {
        ce = !0;
        return;
      }
      document.querySelectorAll("pre code").forEach(Y);
    }
    n(me, "highlightAll");
    function tt() {
      ce && me();
    }
    n(tt, "boot"), typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", tt, !1);
    function nt(i, o) {
      let x = null;
      try {
        x = o(e);
      } catch (y) {
        if (he("Language definition for '{}' could not be registered.".replace("{}", i)), u)
          he(y);
        else
          throw y;
        x = d;
      }
      x.name || (x.name = i), t[i] = x, x.rawDefinition = o.bind(null, e), x.aliases && Oe(x.aliases, { languageName: i });
    }
    n(nt, "registerLanguage");
    function rt(i) {
      delete t[i];
      for (let o of Object.keys(r))
        r[o] === i && delete r[o];
    }
    n(rt, "unregisterLanguage");
    function it() {
      return Object.keys(t);
    }
    n(it, "listLanguages");
    function st(i) {
      A("10.4.0", "requireLanguage will be removed entirely in v11."), A("10.4.0", "Please see https://github.com/highlightjs/highlight.js/pull/2844");
      let o = P(i);
      if (o)
        return o;
      throw new Error("The '{}' language is required, but not loaded.".replace("{}", i));
    }
    n(st, "requireLanguage");
    function P(i) {
      return i = (i || "").toLowerCase(), t[i] || t[r[i]];
    }
    n(P, "getLanguage");
    function Oe(i, { languageName: o }) {
      typeof i == "string" && (i = [i]), i.forEach((x) => {
        r[x.toLowerCase()] = o;
      });
    }
    n(Oe, "registerAliases");
    function Ae(i) {
      let o = P(i);
      return o && !o.disableAutodetect;
    }
    n(Ae, "autoDetection");
    function at(i) {
      i["before:highlightBlock"] && !i["before:highlightElement"] && (i["before:highlightElement"] = (o) => {
        i["before:highlightBlock"](
          Object.assign({ block: o.el }, o)
        );
      }), i["after:highlightBlock"] && !i["after:highlightElement"] && (i["after:highlightElement"] = (o) => {
        i["after:highlightBlock"](
          Object.assign({ block: o.el }, o)
        );
      });
    }
    n(at, "upgradePluginAPI");
    function lt(i) {
      at(i), s.push(i);
    }
    n(lt, "addPlugin");
    function J(i, o) {
      let x = i;
      s.forEach(function(y) {
        y[x] && y[x](o);
      });
    }
    n(J, "fire");
    function ot(i) {
      return A("10.2.0", "fixMarkup will be removed entirely in v11.0"), A("10.2.0", "Please see https://github.com/highlightjs/highlight.js/issues/2534"), G(i);
    }
    n(ot, "deprecateFixMarkup");
    function ct(i) {
      return A("10.7.0", "highlightBlock will be removed entirely in v12.0"), A("10.7.0", "Please use highlightElement now."), Y(i);
    }
    n(ct, "deprecateHighlightBlock"), Object.assign(e, {
      highlight: f,
      highlightAuto: S,
      highlightAll: me,
      fixMarkup: ot,
      highlightElement: Y,
      // TODO: Remove with v12 API
      highlightBlock: ct,
      configure: Qe,
      initHighlighting: oe,
      initHighlightingOnLoad: et,
      registerLanguage: nt,
      unregisterLanguage: rt,
      listLanguages: it,
      getLanguage: P,
      registerAliases: Oe,
      requireLanguage: st,
      autoDetection: Ae,
      inherit: Pe,
      addPlugin: lt,
      // plugins for frameworks
      vuePlugin: tn(e).VuePlugin
    }), e.debugMode = function() {
      u = !1;
    }, e.safeMode = function() {
      u = !0;
    }, e.versionString = Qt;
    for (let i in ne)
      typeof ne[i] == "object" && Ce(ne[i]);
    return Object.assign(e, ne), e.addPlugin(le), e.addPlugin(nn), e.addPlugin(Ze), e;
  }, "HLJS"), an = sn({});
  Fe.exports = an;
});

// ../node_modules/format/format.js
var We = te((_n, Me) => {
  (function() {
    var e;
    typeof Me < "u" ? e = Me.exports = s : e = function() {
      return this || (0, eval)("this");
    }(), e.format = s, e.vsprintf = r, typeof console < "u" && typeof console.log == "function" && (e.printf = t);
    function t() {
      console.log(s.apply(null, arguments));
    }
    n(t, "printf");
    function r(u, h) {
      return s.apply(null, [u].concat(h));
    }
    n(r, "vsprintf");
    function s(u) {
      for (var h = 1, v = [].slice.call(arguments), d = 0, p = u.length, a = "", l, f = !1, N, w, S = !1, G, k = /* @__PURE__ */ n(function() {
        return v[h++];
      }, "nextArg"), le = /* @__PURE__ */ n(function() {
        for (var V = ""; /\d/.test(u[d]); )
          V += u[d++], l = u[d];
        return V.length > 0 ? parseInt(V) : null;
      }, "slurpNumber"); d < p; ++d)
        if (l = u[d], f)
          switch (f = !1, l == "." ? (S = !1, l = u[++d]) : l == "0" && u[d + 1] == "." ? (S = !0, d += 2, l = u[d]) : S = !0, G = le(), l) {
            case "b":
              a += parseInt(k(), 10).toString(2);
              break;
            case "c":
              N = k(), typeof N == "string" || N instanceof String ? a += N : a += String.fromCharCode(parseInt(N, 10));
              break;
            case "d":
              a += parseInt(k(), 10);
              break;
            case "f":
              w = String(parseFloat(k()).toFixed(G || 6)), a += S ? w : w.replace(/^0/, "");
              break;
            case "j":
              a += JSON.stringify(k());
              break;
            case "o":
              a += "0" + parseInt(k(), 10).toString(8);
              break;
            case "s":
              a += k();
              break;
            case "x":
              a += "0x" + parseInt(k(), 10).toString(16);
              break;
            case "X":
              a += "0x" + parseInt(k(), 10).toString(16).toUpperCase();
              break;
            default:
              a += l;
              break;
          }
        else l === "%" ? f = !0 : a += l;
      return a;
    }
    n(s, "format");
  })();
});

// ../node_modules/fault/index.js
var qe = te((wn, Ve) => {
  "use strict";
  var ln = We(), U = j(Error);
  Ve.exports = U;
  U.eval = j(EvalError);
  U.range = j(RangeError);
  U.reference = j(ReferenceError);
  U.syntax = j(SyntaxError);
  U.type = j(TypeError);
  U.uri = j(URIError);
  U.create = j;
  function j(e) {
    return t.displayName = e.displayName || e.name, t;
    function t(r) {
      return r && (r = ln.apply(null, arguments)), new e(r);
    }
    n(t, "FormattedError");
  }
  n(j, "create");
});

// ../node_modules/lowlight/lib/core.js
var xn = te((W) => {
  var D = ze(), ae = qe();
  W.highlight = Ye;
  W.highlightAuto = on;
  W.registerLanguage = cn;
  W.listLanguages = un;
  W.registerAlias = gn;
  T.prototype.addText = dn;
  T.prototype.addKeyword = fn;
  T.prototype.addSublanguage = hn;
  T.prototype.openNode = pn;
  T.prototype.closeNode = En;
  T.prototype.closeAllNodes = Je;
  T.prototype.finalize = Je;
  T.prototype.toHTML = bn;
  var Xe = "hljs-";
  function Ye(e, t, r) {
    var s = D.configure({}), u = r || {}, h = u.prefix, v;
    if (typeof e != "string")
      throw ae("Expected `string` for name, got `%s`", e);
    if (!D.getLanguage(e))
      throw ae("Unknown language: `%s` is not registered", e);
    if (typeof t != "string")
      throw ae("Expected `string` for value, got `%s`", t);
    if (h == null && (h = Xe), D.configure({ __emitter: T, classPrefix: h }), v = D.highlight(t, { language: e, ignoreIllegals: !0 }), D.configure(s || {}), v.errorRaised)
      throw v.errorRaised;
    return {
      relevance: v.relevance,
      language: v.language,
      value: v.emitter.rootNode.children
    };
  }
  n(Ye, "highlight");
  function on(e, t) {
    var r = t || {}, s = r.subset || D.listLanguages(), u = r.prefix, h = s.length, v = -1, d, p, a, l;
    if (u == null && (u = Xe), typeof e != "string")
      throw ae("Expected `string` for value, got `%s`", e);
    for (p = { relevance: 0, language: null, value: [] }, d = { relevance: 0, language: null, value: [] }; ++v < h; )
      l = s[v], D.getLanguage(l) && (a = Ye(l, e, t), a.language = l, a.relevance > p.relevance && (p = a), a.relevance > d.relevance && (p = d, d = a));
    return p.language && (d.secondBest = p), d;
  }
  n(on, "highlightAuto");
  function cn(e, t) {
    D.registerLanguage(e, t);
  }
  n(cn, "registerLanguage");
  function un() {
    return D.listLanguages();
  }
  n(un, "listLanguages");
  function gn(e, t) {
    var r = e, s;
    t && (r = {}, r[e] = t);
    for (s in r)
      D.registerAliases(r[s], { languageName: s });
  }
  n(gn, "registerAlias");
  function T(e) {
    this.options = e, this.rootNode = { children: [] }, this.stack = [this.rootNode];
  }
  n(T, "Emitter");
  function fn(e, t) {
    this.openNode(t), this.addText(e), this.closeNode();
  }
  n(fn, "addKeyword");
  function hn(e, t) {
    var r = this.stack, s = r[r.length - 1], u = e.rootNode.children, h = t ? {
      type: "element",
      tagName: "span",
      properties: { className: [t] },
      children: u
    } : u;
    s.children = s.children.concat(h);
  }
  n(hn, "addSublanguage");
  function dn(e) {
    var t = this.stack, r, s;
    e !== "" && (r = t[t.length - 1], s = r.children[r.children.length - 1], s && s.type === "text" ? s.value += e : r.children.push({ type: "text", value: e }));
  }
  n(dn, "text");
  function pn(e) {
    var t = this.stack, r = this.options.classPrefix + e, s = t[t.length - 1], u = {
      type: "element",
      tagName: "span",
      properties: { className: [r] },
      children: []
    };
    s.children.push(u), t.push(u);
  }
  n(pn, "open");
  function En() {
    this.stack.pop();
  }
  n(En, "close");
  function bn() {
    return "";
  }
  n(bn, "toHtmlNoop");
  function Je() {
  }
  n(Je, "noop");
});

export {
  xn as a
};
