@veracity/ai 1.0.1 → 2.0.1

package/dist/core-CdG-ENX3.js

@@ -0,0 +1,1069 @@
+function Ft(T) {
+  return T && T.__esModule && Object.prototype.hasOwnProperty.call(T, "default") ? T.default : T;
+}
+var ce, De;
+function zt() {
+  if (De) return ce;
+  De = 1;
+  function T(e) {
+    return e instanceof Map ? e.clear = e.delete = e.set = function() {
+      throw new Error("map is read-only");
+    } : e instanceof Set && (e.add = e.clear = e.delete = function() {
+      throw new Error("set is read-only");
+    }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((t) => {
+      const i = e[t], u = typeof i;
+      (u === "object" || u === "function") && !Object.isFrozen(i) && T(i);
+    }), e;
+  }
+  class oe {
+    /**
+     * @param {CompiledMode} mode
+     */
+    constructor(t) {
+      t.data === void 0 && (t.data = {}), this.data = t.data, this.isMatchIgnored = !1;
+    }
+    ignoreMatch() {
+      this.isMatchIgnored = !0;
+    }
+  }
+  function ae(e) {
+    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+  }
+  function I(e, ...t) {
+    const i = /* @__PURE__ */ Object.create(null);
+    for (const u in e)
+      i[u] = e[u];
+    return t.forEach(function(u) {
+      for (const b in u)
+        i[b] = u[b];
+    }), /** @type {T} */
+    i;
+  }
+  const Ce = "</span>", le = (e) => !!e.scope, Le = (e, { prefix: t }) => {
+    if (e.startsWith("language:"))
+      return e.replace("language:", "language-");
+    if (e.includes(".")) {
+      const i = e.split(".");
+      return [
+        `${t}${i.shift()}`,
+        ...i.map((u, b) => `${u}${"_".repeat(b + 1)}`)
+      ].join(" ");
+    }
+    return `${t}${e}`;
+  };
+  class je {
+    /**
+     * Creates a new HTMLRenderer
+     *
+     * @param {Tree} parseTree - the parse tree (must support `walk` API)
+     * @param {{classPrefix: string}} options
+     */
+    constructor(t, i) {
+      this.buffer = "", this.classPrefix = i.classPrefix, t.walk(this);
+    }
+    /**
+     * Adds texts to the output stream
+     *
+     * @param {string} text */
+    addText(t) {
+      this.buffer += ae(t);
+    }
+    /**
+     * Adds a node open to the output stream (if needed)
+     *
+     * @param {Node} node */
+    openNode(t) {
+      if (!le(t)) return;
+      const i = Le(
+        t.scope,
+        { prefix: this.classPrefix }
+      );
+      this.span(i);
+    }
+    /**
+     * Adds a node close to the output stream (if needed)
+     *
+     * @param {Node} node */
+    closeNode(t) {
+      le(t) && (this.buffer += Ce);
+    }
+    /**
+     * returns the accumulated buffer
+    */
+    value() {
+      return this.buffer;
+    }
+    // helpers
+    /**
+     * Builds a span element
+     *
+     * @param {string} className */
+    span(t) {
+      this.buffer += `<span class="${t}">`;
+    }
+  }
+  const ue = (e = {}) => {
+    const t = { children: [] };
+    return Object.assign(t, e), t;
+  };
+  class J {
+    constructor() {
+      this.rootNode = ue(), 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 i = ue({ scope: t });
+      this.add(i), this.stack.push(i);
+    }
+    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, i) {
+      return typeof i == "string" ? t.addText(i) : i.children && (t.openNode(i), i.children.forEach((u) => this._walk(t, u)), t.closeNode(i)), t;
+    }
+    /**
+     * @param {Node} node
+     */
+    static _collapse(t) {
+      typeof t != "string" && t.children && (t.children.every((i) => typeof i == "string") ? t.children = [t.children.join("")] : t.children.forEach((i) => {
+        J._collapse(i);
+      }));
+    }
+  }
+  class He extends J {
+    /**
+     * @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, i) {
+      const u = t.root;
+      i && (u.scope = `language:${i}`), this.add(u);
+    }
+    toHTML() {
+      return new je(this, this.options).value();
+    }
+    finalize() {
+      return this.closeAllNodes(), !0;
+    }
+  }
+  function P(e) {
+    return e ? typeof e == "string" ? e : e.source : null;
+  }
+  function fe(e) {
+    return D("(?=", e, ")");
+  }
+  function Pe(e) {
+    return D("(?:", e, ")*");
+  }
+  function Ue(e) {
+    return D("(?:", e, ")?");
+  }
+  function D(...e) {
+    return e.map((i) => P(i)).join("");
+  }
+  function $e(e) {
+    const t = e[e.length - 1];
+    return typeof t == "object" && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {};
+  }
+  function q(...e) {
+    return "(" + ($e(e).capture ? "" : "?:") + e.map((u) => P(u)).join("|") + ")";
+  }
+  function ge(e) {
+    return new RegExp(e.toString() + "|").exec("").length - 1;
+  }
+  function Ge(e, t) {
+    const i = e && e.exec(t);
+    return i && i.index === 0;
+  }
+  const We = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+  function V(e, { joinWith: t }) {
+    let i = 0;
+    return e.map((u) => {
+      i += 1;
+      const b = i;
+      let _ = P(u), c = "";
+      for (; _.length > 0; ) {
+        const r = We.exec(_);
+        if (!r) {
+          c += _;
+          break;
+        }
+        c += _.substring(0, r.index), _ = _.substring(r.index + r[0].length), r[0][0] === "\\" && r[1] ? c += "\\" + String(Number(r[1]) + b) : (c += r[0], r[0] === "(" && i++);
+      }
+      return c;
+    }).map((u) => `(${u})`).join(t);
+  }
+  const Ke = /\b\B/, he = "[a-zA-Z]\\w*", Q = "[a-zA-Z_]\\w*", de = "\\b\\d+(\\.\\d+)?", pe = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", Ee = "\\b(0b[01]+)", Fe = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", ze = (e = {}) => {
+    const t = /^#![ ]*\//;
+    return e.binary && (e.begin = D(
+      t,
+      /.*\b/,
+      e.binary,
+      /\b.*/
+    )), I({
+      scope: "meta",
+      begin: t,
+      end: /$/,
+      relevance: 0,
+      /** @type {ModeCallback} */
+      "on:begin": (i, u) => {
+        i.index !== 0 && u.ignoreMatch();
+      }
+    }, e);
+  }, U = {
+    begin: "\\\\[\\s\\S]",
+    relevance: 0
+  }, Xe = {
+    scope: "string",
+    begin: "'",
+    end: "'",
+    illegal: "\\n",
+    contains: [U]
+  }, Ye = {
+    scope: "string",
+    begin: '"',
+    end: '"',
+    illegal: "\\n",
+    contains: [U]
+  }, Ze = {
+    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/
+  }, G = function(e, t, i = {}) {
+    const u = I(
+      {
+        scope: "comment",
+        begin: e,
+        end: t,
+        contains: []
+      },
+      i
+    );
+    u.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 b = q(
+      // 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 u.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: D(
+          /[ ]+/,
+          // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+          "(",
+          b,
+          /[.]?[:]?([.][ ]|[ ])/,
+          "){3}"
+        )
+        // look for 3 words in a row
+      }
+    ), u;
+  }, Je = G("//", "$"), qe = G("/\\*", "\\*/"), Ve = G("#", "$"), Qe = {
+    scope: "number",
+    begin: de,
+    relevance: 0
+  }, me = {
+    scope: "number",
+    begin: pe,
+    relevance: 0
+  }, et = {
+    scope: "number",
+    begin: Ee,
+    relevance: 0
+  }, tt = {
+    scope: "regexp",
+    begin: /\/(?=[^/\n]*\/)/,
+    end: /\/[gimuy]*/,
+    contains: [
+      U,
+      {
+        begin: /\[/,
+        end: /\]/,
+        relevance: 0,
+        contains: [U]
+      }
+    ]
+  }, nt = {
+    scope: "title",
+    begin: he,
+    relevance: 0
+  }, it = {
+    scope: "title",
+    begin: Q,
+    relevance: 0
+  }, st = {
+    // excludes method names from keyword processing
+    begin: "\\.\\s*" + Q,
+    relevance: 0
+  };
+  var W = /* @__PURE__ */ Object.freeze({
+    __proto__: null,
+    APOS_STRING_MODE: Xe,
+    BACKSLASH_ESCAPE: U,
+    BINARY_NUMBER_MODE: et,
+    BINARY_NUMBER_RE: Ee,
+    COMMENT: G,
+    C_BLOCK_COMMENT_MODE: qe,
+    C_LINE_COMMENT_MODE: Je,
+    C_NUMBER_MODE: me,
+    C_NUMBER_RE: pe,
+    END_SAME_AS_BEGIN: function(e) {
+      return Object.assign(
+        e,
+        {
+          /** @type {ModeCallback} */
+          "on:begin": (t, i) => {
+            i.data._beginMatch = t[1];
+          },
+          /** @type {ModeCallback} */
+          "on:end": (t, i) => {
+            i.data._beginMatch !== t[1] && i.ignoreMatch();
+          }
+        }
+      );
+    },
+    HASH_COMMENT_MODE: Ve,
+    IDENT_RE: he,
+    MATCH_NOTHING_RE: Ke,
+    METHOD_GUARD: st,
+    NUMBER_MODE: Qe,
+    NUMBER_RE: de,
+    PHRASAL_WORDS_MODE: Ze,
+    QUOTE_STRING_MODE: Ye,
+    REGEXP_MODE: tt,
+    RE_STARTERS_RE: Fe,
+    SHEBANG: ze,
+    TITLE_MODE: nt,
+    UNDERSCORE_IDENT_RE: Q,
+    UNDERSCORE_TITLE_MODE: it
+  });
+  function rt(e, t) {
+    e.input[e.index - 1] === "." && t.ignoreMatch();
+  }
+  function ct(e, t) {
+    e.className !== void 0 && (e.scope = e.className, delete e.className);
+  }
+  function ot(e, t) {
+    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = rt, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+  }
+  function at(e, t) {
+    Array.isArray(e.illegal) && (e.illegal = q(...e.illegal));
+  }
+  function lt(e, t) {
+    if (e.match) {
+      if (e.begin || e.end) throw new Error("begin & end are not supported with match");
+      e.begin = e.match, delete e.match;
+    }
+  }
+  function ut(e, t) {
+    e.relevance === void 0 && (e.relevance = 1);
+  }
+  const ft = (e, t) => {
+    if (!e.beforeMatch) return;
+    if (e.starts) throw new Error("beforeMatch cannot be used with starts");
+    const i = Object.assign({}, e);
+    Object.keys(e).forEach((u) => {
+      delete e[u];
+    }), e.keywords = i.keywords, e.begin = D(i.beforeMatch, fe(i.begin)), e.starts = {
+      relevance: 0,
+      contains: [
+        Object.assign(i, { endsParent: !0 })
+      ]
+    }, e.relevance = 0, delete i.beforeMatch;
+  }, gt = [
+    "of",
+    "and",
+    "for",
+    "in",
+    "not",
+    "or",
+    "if",
+    "then",
+    "parent",
+    // common variable name
+    "list",
+    // common variable name
+    "value"
+    // common variable name
+  ], ht = "keyword";
+  function be(e, t, i = ht) {
+    const u = /* @__PURE__ */ Object.create(null);
+    return typeof e == "string" ? b(i, e.split(" ")) : Array.isArray(e) ? b(i, e) : Object.keys(e).forEach(function(_) {
+      Object.assign(
+        u,
+        be(e[_], t, _)
+      );
+    }), u;
+    function b(_, c) {
+      t && (c = c.map((r) => r.toLowerCase())), c.forEach(function(r) {
+        const l = r.split("|");
+        u[l[0]] = [_, dt(l[0], l[1])];
+      });
+    }
+  }
+  function dt(e, t) {
+    return t ? Number(t) : pt(e) ? 0 : 1;
+  }
+  function pt(e) {
+    return gt.includes(e.toLowerCase());
+  }
+  const _e = {}, C = (e) => {
+    console.error(e);
+  }, Me = (e, ...t) => {
+    console.log(`WARN: ${e}`, ...t);
+  }, j = (e, t) => {
+    _e[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), _e[`${e}/${t}`] = !0);
+  }, K = new Error();
+  function we(e, t, { key: i }) {
+    let u = 0;
+    const b = e[i], _ = {}, c = {};
+    for (let r = 1; r <= t.length; r++)
+      c[r + u] = b[r], _[r + u] = !0, u += ge(t[r - 1]);
+    e[i] = c, e[i]._emit = _, e[i]._multi = !0;
+  }
+  function Et(e) {
+    if (Array.isArray(e.begin)) {
+      if (e.skip || e.excludeBegin || e.returnBegin)
+        throw C("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), K;
+      if (typeof e.beginScope != "object" || e.beginScope === null)
+        throw C("beginScope must be object"), K;
+      we(e, e.begin, { key: "beginScope" }), e.begin = V(e.begin, { joinWith: "" });
+    }
+  }
+  function bt(e) {
+    if (Array.isArray(e.end)) {
+      if (e.skip || e.excludeEnd || e.returnEnd)
+        throw C("skip, excludeEnd, returnEnd not compatible with endScope: {}"), K;
+      if (typeof e.endScope != "object" || e.endScope === null)
+        throw C("endScope must be object"), K;
+      we(e, e.end, { key: "endScope" }), e.end = V(e.end, { joinWith: "" });
+    }
+  }
+  function _t(e) {
+    e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+  }
+  function Mt(e) {
+    _t(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), Et(e), bt(e);
+  }
+  function wt(e) {
+    function t(c, r) {
+      return new RegExp(
+        P(c),
+        "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (r ? "g" : "")
+      );
+    }
+    class i {
+      constructor() {
+        this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+      }
+      // @ts-ignore
+      addRule(r, l) {
+        l.position = this.position++, this.matchIndexes[this.matchAt] = l, this.regexes.push([l, r]), this.matchAt += ge(r) + 1;
+      }
+      compile() {
+        this.regexes.length === 0 && (this.exec = () => null);
+        const r = this.regexes.map((l) => l[1]);
+        this.matcherRe = t(V(r, { joinWith: "|" }), !0), this.lastIndex = 0;
+      }
+      /** @param {string} s */
+      exec(r) {
+        this.matcherRe.lastIndex = this.lastIndex;
+        const l = this.matcherRe.exec(r);
+        if (!l)
+          return null;
+        const x = l.findIndex(($, ee) => ee > 0 && $ !== void 0), M = this.matchIndexes[x];
+        return l.splice(0, x), Object.assign(l, M);
+      }
+    }
+    class u {
+      constructor() {
+        this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+      }
+      // @ts-ignore
+      getMatcher(r) {
+        if (this.multiRegexes[r]) return this.multiRegexes[r];
+        const l = new i();
+        return this.rules.slice(r).forEach(([x, M]) => l.addRule(x, M)), l.compile(), this.multiRegexes[r] = l, l;
+      }
+      resumingScanAtSamePosition() {
+        return this.regexIndex !== 0;
+      }
+      considerAll() {
+        this.regexIndex = 0;
+      }
+      // @ts-ignore
+      addRule(r, l) {
+        this.rules.push([r, l]), l.type === "begin" && this.count++;
+      }
+      /** @param {string} s */
+      exec(r) {
+        const l = this.getMatcher(this.regexIndex);
+        l.lastIndex = this.lastIndex;
+        let x = l.exec(r);
+        if (this.resumingScanAtSamePosition() && !(x && x.index === this.lastIndex)) {
+          const M = this.getMatcher(0);
+          M.lastIndex = this.lastIndex + 1, x = M.exec(r);
+        }
+        return x && (this.regexIndex += x.position + 1, this.regexIndex === this.count && this.considerAll()), x;
+      }
+    }
+    function b(c) {
+      const r = new u();
+      return c.contains.forEach((l) => r.addRule(l.begin, { rule: l, type: "begin" })), c.terminatorEnd && r.addRule(c.terminatorEnd, { type: "end" }), c.illegal && r.addRule(c.illegal, { type: "illegal" }), r;
+    }
+    function _(c, r) {
+      const l = (
+        /** @type CompiledMode */
+        c
+      );
+      if (c.isCompiled) return l;
+      [
+        ct,
+        // do this early so compiler extensions generally don't have to worry about
+        // the distinction between match/begin
+        lt,
+        Mt,
+        ft
+      ].forEach((M) => M(c, r)), e.compilerExtensions.forEach((M) => M(c, r)), c.__beforeBegin = null, [
+        ot,
+        // do this later so compiler extensions that come earlier have access to the
+        // raw array if they wanted to perhaps manipulate it, etc.
+        at,
+        // default to 1 relevance if not specified
+        ut
+      ].forEach((M) => M(c, r)), c.isCompiled = !0;
+      let x = null;
+      return typeof c.keywords == "object" && c.keywords.$pattern && (c.keywords = Object.assign({}, c.keywords), x = c.keywords.$pattern, delete c.keywords.$pattern), x = x || /\w+/, c.keywords && (c.keywords = be(c.keywords, e.case_insensitive)), l.keywordPatternRe = t(x, !0), r && (c.begin || (c.begin = /\B|\b/), l.beginRe = t(l.begin), !c.end && !c.endsWithParent && (c.end = /\B|\b/), c.end && (l.endRe = t(l.end)), l.terminatorEnd = P(l.end) || "", c.endsWithParent && r.terminatorEnd && (l.terminatorEnd += (c.end ? "|" : "") + r.terminatorEnd)), c.illegal && (l.illegalRe = t(
+        /** @type {RegExp | string} */
+        c.illegal
+      )), c.contains || (c.contains = []), c.contains = [].concat(...c.contains.map(function(M) {
+        return xt(M === "self" ? c : M);
+      })), c.contains.forEach(function(M) {
+        _(
+          /** @type Mode */
+          M,
+          l
+        );
+      }), c.starts && _(c.starts, r), l.matcher = b(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 = I(e.classNameAliases || {}), _(
+      /** @type Mode */
+      e
+    );
+  }
+  function xe(e) {
+    return e ? e.endsWithParent || xe(e.starts) : !1;
+  }
+  function xt(e) {
+    return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
+      return I(e, { variants: null }, t);
+    })), e.cachedVariants ? e.cachedVariants : xe(e) ? I(e, { starts: e.starts ? I(e.starts) : null }) : Object.isFrozen(e) ? I(e) : e;
+  }
+  var Ot = "11.10.0";
+  class yt extends Error {
+    constructor(t, i) {
+      super(t), this.name = "HTMLInjectionError", this.html = i;
+    }
+  }
+  const m = ae, Oe = I, ye = Symbol("nomatch"), Rt = 7, Re = function(e) {
+    const t = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null), u = [];
+    let b = !0;
+    const _ = "Could not find the language '{}', did you forget to load/include a language module?", c = { disableAutodetect: !0, name: "Plain text", contains: [] };
+    let r = {
+      ignoreUnescapedHTML: !1,
+      throwUnescapedHTML: !1,
+      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: He
+    };
+    function l(n) {
+      return r.noHighlightRe.test(n);
+    }
+    function x(n) {
+      let a = n.className + " ";
+      a += n.parentNode ? n.parentNode.className : "";
+      const h = r.languageDetectRe.exec(a);
+      if (h) {
+        const p = v(h[1]);
+        return p || (Me(_.replace("{}", h[1])), Me("Falling back to no-highlight mode for this block.", n)), p ? h[1] : "no-highlight";
+      }
+      return a.split(/\s+/).find((p) => l(p) || v(p));
+    }
+    function M(n, a, h) {
+      let p = "", w = "";
+      typeof a == "object" ? (p = n, h = a.ignoreIllegals, w = a.language) : (j("10.7.0", "highlight(lang, code, ...args) has been deprecated."), j("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`), w = n, p = a), h === void 0 && (h = !0);
+      const S = {
+        code: p,
+        language: w
+      };
+      z("before:highlight", S);
+      const B = S.result ? S.result : $(S.language, S.code, h);
+      return B.code = S.code, z("after:highlight", B), B;
+    }
+    function $(n, a, h, p) {
+      const w = /* @__PURE__ */ Object.create(null);
+      function S(s, o) {
+        return s.keywords[o];
+      }
+      function B() {
+        if (!f.keywords) {
+          O.addText(E);
+          return;
+        }
+        let s = 0;
+        f.keywordPatternRe.lastIndex = 0;
+        let o = f.keywordPatternRe.exec(E), g = "";
+        for (; o; ) {
+          g += E.substring(s, o.index);
+          const d = A.case_insensitive ? o[0].toLowerCase() : o[0], y = S(f, d);
+          if (y) {
+            const [k, Wt] = y;
+            if (O.addText(g), g = "", w[d] = (w[d] || 0) + 1, w[d] <= Rt && (Z += Wt), k.startsWith("_"))
+              g += o[0];
+            else {
+              const Kt = A.classNameAliases[k] || k;
+              N(o[0], Kt);
+            }
+          } else
+            g += o[0];
+          s = f.keywordPatternRe.lastIndex, o = f.keywordPatternRe.exec(E);
+        }
+        g += E.substring(s), O.addText(g);
+      }
+      function X() {
+        if (E === "") return;
+        let s = null;
+        if (typeof f.subLanguage == "string") {
+          if (!t[f.subLanguage]) {
+            O.addText(E);
+            return;
+          }
+          s = $(f.subLanguage, E, !0, Be[f.subLanguage]), Be[f.subLanguage] = /** @type {CompiledMode} */
+          s._top;
+        } else
+          s = te(E, f.subLanguage.length ? f.subLanguage : null);
+        f.relevance > 0 && (Z += s.relevance), O.__addSublanguage(s._emitter, s.language);
+      }
+      function R() {
+        f.subLanguage != null ? X() : B(), E = "";
+      }
+      function N(s, o) {
+        s !== "" && (O.startScope(o), O.addText(s), O.endScope());
+      }
+      function ke(s, o) {
+        let g = 1;
+        const d = o.length - 1;
+        for (; g <= d; ) {
+          if (!s._emit[g]) {
+            g++;
+            continue;
+          }
+          const y = A.classNameAliases[s[g]] || s[g], k = o[g];
+          y ? N(k, y) : (E = k, B(), E = ""), g++;
+        }
+      }
+      function Te(s, o) {
+        return s.scope && typeof s.scope == "string" && O.openNode(A.classNameAliases[s.scope] || s.scope), s.beginScope && (s.beginScope._wrap ? (N(E, A.classNameAliases[s.beginScope._wrap] || s.beginScope._wrap), E = "") : s.beginScope._multi && (ke(s.beginScope, o), E = "")), f = Object.create(s, { parent: { value: f } }), f;
+      }
+      function Ie(s, o, g) {
+        let d = Ge(s.endRe, g);
+        if (d) {
+          if (s["on:end"]) {
+            const y = new oe(s);
+            s["on:end"](o, y), y.isMatchIgnored && (d = !1);
+          }
+          if (d) {
+            for (; s.endsParent && s.parent; )
+              s = s.parent;
+            return s;
+          }
+        }
+        if (s.endsWithParent)
+          return Ie(s.parent, o, g);
+      }
+      function Ht(s) {
+        return f.matcher.regexIndex === 0 ? (E += s[0], 1) : (re = !0, 0);
+      }
+      function Pt(s) {
+        const o = s[0], g = s.rule, d = new oe(g), y = [g.__beforeBegin, g["on:begin"]];
+        for (const k of y)
+          if (k && (k(s, d), d.isMatchIgnored))
+            return Ht(o);
+        return g.skip ? E += o : (g.excludeBegin && (E += o), R(), !g.returnBegin && !g.excludeBegin && (E = o)), Te(g, s), g.returnBegin ? 0 : o.length;
+      }
+      function Ut(s) {
+        const o = s[0], g = a.substring(s.index), d = Ie(f, s, g);
+        if (!d)
+          return ye;
+        const y = f;
+        f.endScope && f.endScope._wrap ? (R(), N(o, f.endScope._wrap)) : f.endScope && f.endScope._multi ? (R(), ke(f.endScope, s)) : y.skip ? E += o : (y.returnEnd || y.excludeEnd || (E += o), R(), y.excludeEnd && (E = o));
+        do
+          f.scope && O.closeNode(), !f.skip && !f.subLanguage && (Z += f.relevance), f = f.parent;
+        while (f !== d.parent);
+        return d.starts && Te(d.starts, s), y.returnEnd ? 0 : o.length;
+      }
+      function $t() {
+        const s = [];
+        for (let o = f; o !== A; o = o.parent)
+          o.scope && s.unshift(o.scope);
+        s.forEach((o) => O.openNode(o));
+      }
+      let Y = {};
+      function ve(s, o) {
+        const g = o && o[0];
+        if (E += s, g == null)
+          return R(), 0;
+        if (Y.type === "begin" && o.type === "end" && Y.index === o.index && g === "") {
+          if (E += a.slice(o.index, o.index + 1), !b) {
+            const d = new Error(`0 width match regex (${n})`);
+            throw d.languageName = n, d.badRule = Y.rule, d;
+          }
+          return 1;
+        }
+        if (Y = o, o.type === "begin")
+          return Pt(o);
+        if (o.type === "illegal" && !h) {
+          const d = new Error('Illegal lexeme "' + g + '" for mode "' + (f.scope || "<unnamed>") + '"');
+          throw d.mode = f, d;
+        } else if (o.type === "end") {
+          const d = Ut(o);
+          if (d !== ye)
+            return d;
+        }
+        if (o.type === "illegal" && g === "")
+          return 1;
+        if (se > 1e5 && se > o.index * 3)
+          throw new Error("potential infinite loop, way more iterations than matches");
+        return E += g, g.length;
+      }
+      const A = v(n);
+      if (!A)
+        throw C(_.replace("{}", n)), new Error('Unknown language: "' + n + '"');
+      const Gt = wt(A);
+      let ie = "", f = p || Gt;
+      const Be = {}, O = new r.__emitter(r);
+      $t();
+      let E = "", Z = 0, L = 0, se = 0, re = !1;
+      try {
+        if (A.__emitTokens)
+          A.__emitTokens(a, O);
+        else {
+          for (f.matcher.considerAll(); ; ) {
+            se++, re ? re = !1 : f.matcher.considerAll(), f.matcher.lastIndex = L;
+            const s = f.matcher.exec(a);
+            if (!s) break;
+            const o = a.substring(L, s.index), g = ve(o, s);
+            L = s.index + g;
+          }
+          ve(a.substring(L));
+        }
+        return O.finalize(), ie = O.toHTML(), {
+          language: n,
+          value: ie,
+          relevance: Z,
+          illegal: !1,
+          _emitter: O,
+          _top: f
+        };
+      } catch (s) {
+        if (s.message && s.message.includes("Illegal"))
+          return {
+            language: n,
+            value: m(a),
+            illegal: !0,
+            relevance: 0,
+            _illegalBy: {
+              message: s.message,
+              index: L,
+              context: a.slice(L - 100, L + 100),
+              mode: s.mode,
+              resultSoFar: ie
+            },
+            _emitter: O
+          };
+        if (b)
+          return {
+            language: n,
+            value: m(a),
+            illegal: !1,
+            relevance: 0,
+            errorRaised: s,
+            _emitter: O,
+            _top: f
+          };
+        throw s;
+      }
+    }
+    function ee(n) {
+      const a = {
+        value: m(n),
+        illegal: !1,
+        relevance: 0,
+        _top: c,
+        _emitter: new r.__emitter(r)
+      };
+      return a._emitter.addText(n), a;
+    }
+    function te(n, a) {
+      a = a || r.languages || Object.keys(t);
+      const h = ee(n), p = a.filter(v).filter(Ae).map(
+        (R) => $(R, n, !1)
+      );
+      p.unshift(h);
+      const w = p.sort((R, N) => {
+        if (R.relevance !== N.relevance) return N.relevance - R.relevance;
+        if (R.language && N.language) {
+          if (v(R.language).supersetOf === N.language)
+            return 1;
+          if (v(N.language).supersetOf === R.language)
+            return -1;
+        }
+        return 0;
+      }), [S, B] = w, X = S;
+      return X.secondBest = B, X;
+    }
+    function St(n, a, h) {
+      const p = a && i[a] || h;
+      n.classList.add("hljs"), n.classList.add(`language-${p}`);
+    }
+    function ne(n) {
+      let a = null;
+      const h = x(n);
+      if (l(h)) return;
+      if (z(
+        "before:highlightElement",
+        { el: n, language: h }
+      ), n.dataset.highlighted) {
+        console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", n);
+        return;
+      }
+      if (n.children.length > 0 && (r.ignoreUnescapedHTML || (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."), console.warn("https://github.com/highlightjs/highlight.js/wiki/security"), console.warn("The element with unescaped HTML:"), console.warn(n)), r.throwUnescapedHTML))
+        throw new yt(
+          "One of your code blocks includes unescaped HTML.",
+          n.innerHTML
+        );
+      a = n;
+      const p = a.textContent, w = h ? M(p, { language: h, ignoreIllegals: !0 }) : te(p);
+      n.innerHTML = w.value, n.dataset.highlighted = "yes", St(n, h, w.language), n.result = {
+        language: w.language,
+        // TODO: remove with version 11.0
+        re: w.relevance,
+        relevance: w.relevance
+      }, w.secondBest && (n.secondBest = {
+        language: w.secondBest.language,
+        relevance: w.secondBest.relevance
+      }), z("after:highlightElement", { el: n, result: w, text: p });
+    }
+    function Nt(n) {
+      r = Oe(r, n);
+    }
+    const At = () => {
+      F(), j("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+    };
+    function kt() {
+      F(), j("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+    }
+    let Se = !1;
+    function F() {
+      if (document.readyState === "loading") {
+        Se = !0;
+        return;
+      }
+      document.querySelectorAll(r.cssSelector).forEach(ne);
+    }
+    function Tt() {
+      Se && F();
+    }
+    typeof window < "u" && window.addEventListener && window.addEventListener("DOMContentLoaded", Tt, !1);
+    function It(n, a) {
+      let h = null;
+      try {
+        h = a(e);
+      } catch (p) {
+        if (C("Language definition for '{}' could not be registered.".replace("{}", n)), b)
+          C(p);
+        else
+          throw p;
+        h = c;
+      }
+      h.name || (h.name = n), t[n] = h, h.rawDefinition = a.bind(null, e), h.aliases && Ne(h.aliases, { languageName: n });
+    }
+    function vt(n) {
+      delete t[n];
+      for (const a of Object.keys(i))
+        i[a] === n && delete i[a];
+    }
+    function Bt() {
+      return Object.keys(t);
+    }
+    function v(n) {
+      return n = (n || "").toLowerCase(), t[n] || t[i[n]];
+    }
+    function Ne(n, { languageName: a }) {
+      typeof n == "string" && (n = [n]), n.forEach((h) => {
+        i[h.toLowerCase()] = a;
+      });
+    }
+    function Ae(n) {
+      const a = v(n);
+      return a && !a.disableAutodetect;
+    }
+    function Dt(n) {
+      n["before:highlightBlock"] && !n["before:highlightElement"] && (n["before:highlightElement"] = (a) => {
+        n["before:highlightBlock"](
+          Object.assign({ block: a.el }, a)
+        );
+      }), n["after:highlightBlock"] && !n["after:highlightElement"] && (n["after:highlightElement"] = (a) => {
+        n["after:highlightBlock"](
+          Object.assign({ block: a.el }, a)
+        );
+      });
+    }
+    function Ct(n) {
+      Dt(n), u.push(n);
+    }
+    function Lt(n) {
+      const a = u.indexOf(n);
+      a !== -1 && u.splice(a, 1);
+    }
+    function z(n, a) {
+      const h = n;
+      u.forEach(function(p) {
+        p[h] && p[h](a);
+      });
+    }
+    function jt(n) {
+      return j("10.7.0", "highlightBlock will be removed entirely in v12.0"), j("10.7.0", "Please use highlightElement now."), ne(n);
+    }
+    Object.assign(e, {
+      highlight: M,
+      highlightAuto: te,
+      highlightAll: F,
+      highlightElement: ne,
+      // TODO: Remove with v12 API
+      highlightBlock: jt,
+      configure: Nt,
+      initHighlighting: At,
+      initHighlightingOnLoad: kt,
+      registerLanguage: It,
+      unregisterLanguage: vt,
+      listLanguages: Bt,
+      getLanguage: v,
+      registerAliases: Ne,
+      autoDetection: Ae,
+      inherit: Oe,
+      addPlugin: Ct,
+      removePlugin: Lt
+    }), e.debugMode = function() {
+      b = !1;
+    }, e.safeMode = function() {
+      b = !0;
+    }, e.versionString = Ot, e.regex = {
+      concat: D,
+      lookahead: fe,
+      either: q,
+      optional: Ue,
+      anyNumberOfTimes: Pe
+    };
+    for (const n in W)
+      typeof W[n] == "object" && T(W[n]);
+    return Object.assign(e, W), e;
+  }, H = Re({});
+  return H.newInstance = () => Re({}), ce = H, H.HighlightJS = H, H.default = H, ce;
+}
+var Xt = /* @__PURE__ */ zt();
+const Zt = /* @__PURE__ */ Ft(Xt);
+export {
+  Zt as HighlightJS,
+  Zt as default
+};