@omg-dev/app 0.1.308

package/dist-lib/index-npuLMlPS.js

@@ -0,0 +1,746 @@
+import { w as T, s as U, h as X, c as Y, v as G, S as J, o as k, l as Q, f as M, m as y } from "./streamdown-response-DPrve_Vt.js";
+import v from "./katex-jHfnQmlp.js";
+function Z(t, e) {
+  return B(t, {}) || { type: "root", children: [] };
+}
+function B(t, e) {
+  const r = tt(t, e);
+  return r && e.afterTransform && e.afterTransform(t, r), r;
+}
+function tt(t, e) {
+  switch (t.nodeType) {
+    case 1:
+      return it(
+        /** @type {Element} */
+        t,
+        e
+      );
+    // Ignore: Attr (2).
+    case 3:
+      return nt(
+        /** @type {Text} */
+        t
+      );
+    // Ignore: CDATA (4).
+    // Removed: Entity reference (5)
+    // Removed: Entity (6)
+    // Ignore: Processing instruction (7).
+    case 8:
+      return rt(
+        /** @type {Comment} */
+        t
+      );
+    case 9:
+      return z(
+        /** @type {Document} */
+        t,
+        e
+      );
+    case 10:
+      return et();
+    case 11:
+      return z(
+        /** @type {DocumentFragment} */
+        t,
+        e
+      );
+    default:
+      return;
+  }
+}
+function z(t, e) {
+  return { type: "root", children: L(t, e) };
+}
+function et() {
+  return { type: "doctype" };
+}
+function nt(t) {
+  return { type: "text", value: t.nodeValue || "" };
+}
+function rt(t) {
+  return { type: "comment", value: t.nodeValue || "" };
+}
+function it(t, e) {
+  const r = t.namespaceURI, i = r === T.svg ? U : X, n = r === T.html ? t.tagName.toLowerCase() : t.tagName, u = (
+    // @ts-expect-error: DOM types are wrong, content can exist.
+    r === T.html && n === "template" ? t.content : t
+  ), o = t.getAttributeNames(), s = {};
+  let a = -1;
+  for (; ++a < o.length; )
+    s[o[a]] = t.getAttribute(o[a]) || "";
+  return i(n, s, L(u, e));
+}
+function L(t, e) {
+  const r = t.childNodes, i = [];
+  let n = -1;
+  for (; ++n < r.length; ) {
+    const u = B(r[n], e);
+    u !== void 0 && i.push(u);
+  }
+  return i;
+}
+new DOMParser();
+function at(t, e) {
+  const r = ot(t);
+  return (
+    /** @type {Root} */
+    Z(r)
+  );
+}
+function ot(t) {
+  const e = document.createElement("template");
+  return e.innerHTML = t, e.content;
+}
+const A = (
+  // Note: overloads like this are needed to support optional generics.
+  /**
+   * @type {(
+   *   (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &
+   *   (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)
+   * )}
+   */
+  /**
+   * @param {UnistParent} parent
+   * @param {UnistNode | number} index
+   * @param {Test} [test]
+   * @returns {UnistNode | undefined}
+   */
+  (function(t, e, r) {
+    const i = Y(r);
+    if (!t || !t.type || !t.children)
+      throw new Error("Expected parent node");
+    if (typeof e == "number") {
+      if (e < 0 || e === Number.POSITIVE_INFINITY)
+        throw new Error("Expected positive finite number as index");
+    } else if (e = t.children.indexOf(e), e < 0)
+      throw new Error("Expected child node or index");
+    for (; ++e < t.children.length; )
+      if (i(t.children[e], e, t))
+        return t.children[e];
+  })
+), F = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends TestFunction>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & Predicate<Condition, Element>) &
+   *   (<Condition extends string>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & {tagName: Condition}) &
+   *   ((test?: null | undefined) => (element?: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test | null | undefined} [test]
+   * @returns {Check}
+   */
+  (function(t) {
+    if (t == null)
+      return st;
+    if (typeof t == "string")
+      return lt(t);
+    if (typeof t == "object")
+      return ut(t);
+    if (typeof t == "function")
+      return E(t);
+    throw new Error("Expected function, string, or array as `test`");
+  })
+);
+function ut(t) {
+  const e = [];
+  let r = -1;
+  for (; ++r < t.length; )
+    e[r] = F(t[r]);
+  return E(i);
+  function i(...n) {
+    let u = -1;
+    for (; ++u < e.length; )
+      if (e[u].apply(this, n)) return !0;
+    return !1;
+  }
+}
+function lt(t) {
+  return E(e);
+  function e(r) {
+    return r.tagName === t;
+  }
+}
+function E(t) {
+  return e;
+  function e(r, i, n) {
+    return !!(ct(r) && t.call(
+      this,
+      r,
+      typeof i == "number" ? i : void 0,
+      n || void 0
+    ));
+  }
+}
+function st(t) {
+  return !!(t && typeof t == "object" && "type" in t && t.type === "element" && "tagName" in t && typeof t.tagName == "string");
+}
+function ct(t) {
+  return t !== null && typeof t == "object" && "type" in t && "tagName" in t;
+}
+const I = /\n/g, P = /[\t ]+/g, N = F("br"), q = F(wt), ht = F("p"), D = F("tr"), mt = F([
+  // List from: <https://html.spec.whatwg.org/multipage/rendering.html#hidden-elements>
+  "datalist",
+  "head",
+  "noembed",
+  "noframes",
+  "noscript",
+  // Act as if we support scripting.
+  "rp",
+  "script",
+  "style",
+  "template",
+  "title",
+  // Hidden attribute.
+  xt,
+  // From: <https://html.spec.whatwg.org/multipage/rendering.html#flow-content-3>
+  yt
+]), _ = F([
+  "address",
+  // Flow content
+  "article",
+  // Sections and headings
+  "aside",
+  // Sections and headings
+  "blockquote",
+  // Flow content
+  "body",
+  // Page
+  "caption",
+  // `table-caption`
+  "center",
+  // Flow content (legacy)
+  "dd",
+  // Lists
+  "dialog",
+  // Flow content
+  "dir",
+  // Lists (legacy)
+  "dl",
+  // Lists
+  "dt",
+  // Lists
+  "div",
+  // Flow content
+  "figure",
+  // Flow content
+  "figcaption",
+  // Flow content
+  "footer",
+  // Flow content
+  "form,",
+  // Flow content
+  "h1",
+  // Sections and headings
+  "h2",
+  // Sections and headings
+  "h3",
+  // Sections and headings
+  "h4",
+  // Sections and headings
+  "h5",
+  // Sections and headings
+  "h6",
+  // Sections and headings
+  "header",
+  // Flow content
+  "hgroup",
+  // Sections and headings
+  "hr",
+  // Flow content
+  "html",
+  // Page
+  "legend",
+  // Flow content
+  "li",
+  // Lists (as `display: list-item`)
+  "listing",
+  // Flow content (legacy)
+  "main",
+  // Flow content
+  "menu",
+  // Lists
+  "nav",
+  // Sections and headings
+  "ol",
+  // Lists
+  "p",
+  // Flow content
+  "plaintext",
+  // Flow content (legacy)
+  "pre",
+  // Flow content
+  "section",
+  // Sections and headings
+  "ul",
+  // Lists
+  "xmp"
+  // Flow content (legacy)
+]);
+function pt(t, e) {
+  const r = e || {}, i = "children" in t ? t.children : [], n = _(t), u = K(t, {
+    whitespace: r.whitespace || "normal"
+  }), o = [];
+  (t.type === "text" || t.type === "comment") && o.push(
+    ...V(t, {
+      breakBefore: !0,
+      breakAfter: !0
+    })
+  );
+  let s = -1;
+  for (; ++s < i.length; )
+    o.push(
+      ...j(
+        i[s],
+        // @ts-expect-error: `tree` is a parent if we’re here.
+        t,
+        {
+          whitespace: u,
+          breakBefore: s ? void 0 : n,
+          breakAfter: s < i.length - 1 ? N(i[s + 1]) : n
+        }
+      )
+    );
+  const a = [];
+  let c;
+  for (s = -1; ++s < o.length; ) {
+    const m = o[s];
+    typeof m == "number" ? c !== void 0 && m > c && (c = m) : m && (c !== void 0 && c > -1 && a.push(`
+`.repeat(c) || " "), c = -1, a.push(m));
+  }
+  return a.join("");
+}
+function j(t, e, r) {
+  return t.type === "element" ? ft(t, e, r) : t.type === "text" ? r.whitespace === "normal" ? V(t, r) : dt(t) : [];
+}
+function ft(t, e, r) {
+  const i = K(t, r), n = t.children || [];
+  let u = -1, o = [];
+  if (mt(t))
+    return o;
+  let s, a;
+  for (N(t) || D(t) && // @ts-expect-error: something up with types of parents.
+  A(e, t, D) ? a = `
+` : ht(t) ? (s = 2, a = 2) : _(t) && (s = 1, a = 1); ++u < n.length; )
+    o = o.concat(
+      j(n[u], t, {
+        whitespace: i,
+        breakBefore: u ? void 0 : s,
+        breakAfter: u < n.length - 1 ? N(n[u + 1]) : a
+      })
+    );
+  return q(t) && // @ts-expect-error: something up with types of parents.
+  A(e, t, q) && o.push("	"), s && o.unshift(s), a && o.push(a), o;
+}
+function V(t, e) {
+  const r = String(t.value), i = [], n = [];
+  let u = 0;
+  for (; u <= r.length; ) {
+    I.lastIndex = u;
+    const a = I.exec(r), c = a && "index" in a ? a.index : r.length;
+    i.push(
+      // Any sequence of collapsible spaces and tabs immediately preceding or
+      // following a segment break is removed.
+      gt(
+        // […] ignoring bidi formatting characters (characters with the
+        // Bidi_Control property [UAX9]: ALM, LTR, RTL, LRE-RLO, LRI-PDI) as if
+        // they were not there.
+        r.slice(u, c).replace(/[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, ""),
+        u === 0 ? e.breakBefore : !0,
+        c === r.length ? e.breakAfter : !0
+      )
+    ), u = c + 1;
+  }
+  let o = -1, s;
+  for (; ++o < i.length; )
+    i[o].charCodeAt(i[o].length - 1) === 8203 || o < i.length - 1 && i[o + 1].charCodeAt(0) === 8203 ? (n.push(i[o]), s = void 0) : i[o] ? (typeof s == "number" && n.push(s), n.push(i[o]), s = 0) : (o === 0 || o === i.length - 1) && n.push(0);
+  return n;
+}
+function dt(t) {
+  return [String(t.value)];
+}
+function gt(t, e, r) {
+  const i = [];
+  let n = 0, u;
+  for (; n < t.length; ) {
+    P.lastIndex = n;
+    const o = P.exec(t);
+    u = o ? o.index : t.length, !n && !u && o && !e && i.push(""), n !== u && i.push(t.slice(n, u)), n = o ? u + o[0].length : u;
+  }
+  return n !== u && !r && i.push(""), i.join(" ");
+}
+function K(t, e) {
+  if (t.type === "element") {
+    const r = t.properties || {};
+    switch (t.tagName) {
+      case "listing":
+      case "plaintext":
+      case "xmp":
+        return "pre";
+      case "nobr":
+        return "nowrap";
+      case "pre":
+        return r.wrap ? "pre-wrap" : "pre";
+      case "td":
+      case "th":
+        return r.noWrap ? "nowrap" : e.whitespace;
+      case "textarea":
+        return "pre-wrap";
+    }
+  }
+  return e.whitespace;
+}
+function xt(t) {
+  return !!(t.properties || {}).hidden;
+}
+function wt(t) {
+  return t.tagName === "td" || t.tagName === "th";
+}
+function yt(t) {
+  return t.tagName === "dialog" && !(t.properties || {}).open;
+}
+const Ft = {}, kt = [];
+function bt(t) {
+  const e = t || Ft;
+  return function(r, i) {
+    G(r, "element", function(n, u) {
+      const o = Array.isArray(n.properties.className) ? n.properties.className : kt, s = o.includes("language-math"), a = o.includes("math-display"), c = o.includes("math-inline");
+      let m = a;
+      if (!s && !a && !c)
+        return;
+      let p = u[u.length - 1], g = n;
+      if (n.tagName === "code" && s && p && p.type === "element" && p.tagName === "pre" && (g = p, p = u[u.length - 2], m = !0), !p) return;
+      const d = pt(g, { whitespace: "pre" });
+      let f;
+      try {
+        f = v.renderToString(d, {
+          ...e,
+          displayMode: m,
+          throwOnError: !0
+        });
+      } catch (w) {
+        const b = (
+          /** @type {Error} */
+          w
+        ), l = b.name.toLowerCase();
+        i.message("Could not render math with KaTeX", {
+          ancestors: [...u, n],
+          cause: b,
+          place: n.position,
+          ruleId: l,
+          source: "rehype-katex"
+        });
+        try {
+          f = v.renderToString(d, {
+            ...e,
+            displayMode: m,
+            strict: "ignore",
+            throwOnError: !1
+          });
+        } catch {
+          f = [
+            {
+              type: "element",
+              tagName: "span",
+              properties: {
+                className: ["katex-error"],
+                style: "color:" + (e.errorColor || "#cc0000"),
+                title: String(w)
+              },
+              children: [{ type: "text", value: d }]
+            }
+          ];
+        }
+      }
+      typeof f == "string" && (f = /** @type {Array<ElementContent>} */
+      at(f).children);
+      const h = p.children.indexOf(g);
+      return p.children.splice(h, 1, ...f), J;
+    });
+  };
+}
+function Mt() {
+  return {
+    enter: {
+      mathFlow: t,
+      mathFlowFenceMeta: e,
+      mathText: u
+    },
+    exit: {
+      mathFlow: n,
+      mathFlowFence: i,
+      mathFlowFenceMeta: r,
+      mathFlowValue: s,
+      mathText: o,
+      mathTextData: s
+    }
+  };
+  function t(a) {
+    const c = {
+      type: "element",
+      tagName: "code",
+      properties: { className: ["language-math", "math-display"] },
+      children: []
+    };
+    this.enter(
+      {
+        type: "math",
+        meta: null,
+        value: "",
+        data: { hName: "pre", hChildren: [c] }
+      },
+      a
+    );
+  }
+  function e() {
+    this.buffer();
+  }
+  function r() {
+    const a = this.resume(), c = this.stack[this.stack.length - 1];
+    k(c.type === "math"), c.meta = a;
+  }
+  function i() {
+    this.data.mathFlowInside || (this.buffer(), this.data.mathFlowInside = !0);
+  }
+  function n(a) {
+    const c = this.resume().replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, ""), m = this.stack[this.stack.length - 1];
+    k(m.type === "math"), this.exit(a), m.value = c;
+    const p = (
+      /** @type {HastElement} */
+      m.data.hChildren[0]
+    );
+    k(p.type === "element"), k(p.tagName === "code"), p.children.push({ type: "text", value: c }), this.data.mathFlowInside = void 0;
+  }
+  function u(a) {
+    this.enter(
+      {
+        type: "inlineMath",
+        value: "",
+        data: {
+          hName: "code",
+          hProperties: { className: ["language-math", "math-inline"] },
+          hChildren: []
+        }
+      },
+      a
+    ), this.buffer();
+  }
+  function o(a) {
+    const c = this.resume(), m = this.stack[this.stack.length - 1];
+    k(m.type === "inlineMath"), this.exit(a), m.value = c, /** @type {Array<HastElementContent>} */
+    // @ts-expect-error: we defined it in `enterMathFlow`.
+    m.data.hChildren.push({ type: "text", value: c });
+  }
+  function s(a) {
+    this.config.enter.data.call(this, a), this.config.exit.data.call(this, a);
+  }
+}
+function Tt(t) {
+  let e = (t || {}).singleDollarTextMath;
+  return e == null && (e = !0), i.peek = n, {
+    unsafe: [
+      { character: "\r", inConstruct: "mathFlowMeta" },
+      { character: `
+`, inConstruct: "mathFlowMeta" },
+      {
+        character: "$",
+        after: e ? void 0 : "\\$",
+        inConstruct: "phrasing"
+      },
+      { character: "$", inConstruct: "mathFlowMeta" },
+      { atBreak: !0, character: "$", after: "\\$" }
+    ],
+    handlers: { math: r, inlineMath: i }
+  };
+  function r(u, o, s, a) {
+    const c = u.value || "", m = s.createTracker(a), p = "$".repeat(Math.max(Q(c, "$") + 1, 2)), g = s.enter("mathFlow");
+    let d = m.move(p);
+    if (u.meta) {
+      const f = s.enter("mathFlowMeta");
+      d += m.move(
+        s.safe(u.meta, {
+          after: `
+`,
+          before: d,
+          encode: ["$"],
+          ...m.current()
+        })
+      ), f();
+    }
+    return d += m.move(`
+`), c && (d += m.move(c + `
+`)), d += m.move(p), g(), d;
+  }
+  function i(u, o, s) {
+    let a = u.value || "", c = 1;
+    for (e || c++; new RegExp("(^|[^$])" + "\\$".repeat(c) + "([^$]|$)").test(a); )
+      c++;
+    const m = "$".repeat(c);
+    // Contains non-space.
+    /[^ \r\n]/.test(a) && // Starts with space and ends with space.
+    (/^[ \r\n]/.test(a) && /[ \r\n]$/.test(a) || // Starts or ends with dollar.
+    /^\$|\$$/.test(a)) && (a = " " + a + " ");
+    let p = -1;
+    for (; ++p < s.unsafe.length; ) {
+      const g = s.unsafe[p];
+      if (!g.atBreak) continue;
+      const d = s.compilePattern(g);
+      let f;
+      for (; f = d.exec(a); ) {
+        let h = f.index;
+        a.codePointAt(h) === 10 && a.codePointAt(h - 1) === 13 && h--, a = a.slice(0, h) + " " + a.slice(f.index + 1);
+      }
+    }
+    return m + a + m;
+  }
+  function n() {
+    return "$";
+  }
+}
+const Nt = {
+  tokenize: Et,
+  concrete: !0,
+  name: "mathFlow"
+}, O = {
+  tokenize: Ct,
+  partial: !0
+};
+function Et(t, e, r) {
+  const i = this, n = i.events[i.events.length - 1], u = n && n[1].type === "linePrefix" ? n[2].sliceSerialize(n[1], !0).length : 0;
+  let o = 0;
+  return s;
+  function s(l) {
+    return t.enter("mathFlow"), t.enter("mathFlowFence"), t.enter("mathFlowFenceSequence"), a(l);
+  }
+  function a(l) {
+    return l === 36 ? (t.consume(l), o++, a) : o < 2 ? r(l) : (t.exit("mathFlowFenceSequence"), M(t, c, "whitespace")(l));
+  }
+  function c(l) {
+    return l === null || y(l) ? p(l) : (t.enter("mathFlowFenceMeta"), t.enter("chunkString", {
+      contentType: "string"
+    }), m(l));
+  }
+  function m(l) {
+    return l === null || y(l) ? (t.exit("chunkString"), t.exit("mathFlowFenceMeta"), p(l)) : l === 36 ? r(l) : (t.consume(l), m);
+  }
+  function p(l) {
+    return t.exit("mathFlowFence"), i.interrupt ? e(l) : t.attempt(O, g, w)(l);
+  }
+  function g(l) {
+    return t.attempt({
+      tokenize: b,
+      partial: !0
+    }, w, d)(l);
+  }
+  function d(l) {
+    return (u ? M(t, f, "linePrefix", u + 1) : f)(l);
+  }
+  function f(l) {
+    return l === null ? w(l) : y(l) ? t.attempt(O, g, w)(l) : (t.enter("mathFlowValue"), h(l));
+  }
+  function h(l) {
+    return l === null || y(l) ? (t.exit("mathFlowValue"), f(l)) : (t.consume(l), h);
+  }
+  function w(l) {
+    return t.exit("mathFlow"), e(l);
+  }
+  function b(l, R, C) {
+    let S = 0;
+    return M(l, H, "linePrefix", i.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+    function H(x) {
+      return l.enter("mathFlowFence"), l.enter("mathFlowFenceSequence"), $(x);
+    }
+    function $(x) {
+      return x === 36 ? (S++, l.consume(x), $) : S < o ? C(x) : (l.exit("mathFlowFenceSequence"), M(l, W, "whitespace")(x));
+    }
+    function W(x) {
+      return x === null || y(x) ? (l.exit("mathFlowFence"), R(x)) : C(x);
+    }
+  }
+}
+function Ct(t, e, r) {
+  const i = this;
+  return n;
+  function n(o) {
+    return o === null ? e(o) : (t.enter("lineEnding"), t.consume(o), t.exit("lineEnding"), u);
+  }
+  function u(o) {
+    return i.parser.lazy[i.now().line] ? r(o) : e(o);
+  }
+}
+function St(t) {
+  let r = (t || {}).singleDollarTextMath;
+  return r == null && (r = !0), {
+    tokenize: i,
+    resolve: $t,
+    previous: vt,
+    name: "mathText"
+  };
+  function i(n, u, o) {
+    let s = 0, a, c;
+    return m;
+    function m(h) {
+      return n.enter("mathText"), n.enter("mathTextSequence"), p(h);
+    }
+    function p(h) {
+      return h === 36 ? (n.consume(h), s++, p) : s < 2 && !r ? o(h) : (n.exit("mathTextSequence"), g(h));
+    }
+    function g(h) {
+      return h === null ? o(h) : h === 36 ? (c = n.enter("mathTextSequence"), a = 0, f(h)) : h === 32 ? (n.enter("space"), n.consume(h), n.exit("space"), g) : y(h) ? (n.enter("lineEnding"), n.consume(h), n.exit("lineEnding"), g) : (n.enter("mathTextData"), d(h));
+    }
+    function d(h) {
+      return h === null || h === 32 || h === 36 || y(h) ? (n.exit("mathTextData"), g(h)) : (n.consume(h), d);
+    }
+    function f(h) {
+      return h === 36 ? (n.consume(h), a++, f) : a === s ? (n.exit("mathTextSequence"), n.exit("mathText"), u(h)) : (c.type = "mathTextData", d(h));
+    }
+  }
+}
+function $t(t) {
+  let e = t.length - 4, r = 3, i, n;
+  if ((t[r][1].type === "lineEnding" || t[r][1].type === "space") && (t[e][1].type === "lineEnding" || t[e][1].type === "space")) {
+    for (i = r; ++i < e; )
+      if (t[i][1].type === "mathTextData") {
+        t[e][1].type = "mathTextPadding", t[r][1].type = "mathTextPadding", r += 2, e -= 2;
+        break;
+      }
+  }
+  for (i = r - 1, e++; ++i <= e; )
+    n === void 0 ? i !== e && t[i][1].type !== "lineEnding" && (n = i) : (i === e || t[i][1].type === "lineEnding") && (t[n][1].type = "mathTextData", i !== n + 2 && (t[n][1].end = t[i - 1][1].end, t.splice(n + 2, i - n - 2), e -= i - n - 2, i = n + 2), n = void 0);
+  return t;
+}
+function vt(t) {
+  return t !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+function zt(t) {
+  return {
+    flow: {
+      36: Nt
+    },
+    text: {
+      36: St(t)
+    }
+  };
+}
+const At = {};
+function It(t) {
+  const e = (
+    /** @type {Processor} */
+    this
+  ), r = t || At, i = e.data(), n = i.micromarkExtensions || (i.micromarkExtensions = []), u = i.fromMarkdownExtensions || (i.fromMarkdownExtensions = []), o = i.toMarkdownExtensions || (i.toMarkdownExtensions = []);
+  n.push(zt(r)), u.push(Mt()), o.push(Tt(r));
+}
+function Pt(t = {}) {
+  var e, r;
+  let i = [It, { singleDollarTextMath: (e = t.singleDollarTextMath) != null ? e : !1 }], n = [bt, { errorColor: (r = t.errorColor) != null ? r : "var(--color-muted-foreground)" }];
+  return { name: "katex", type: "math", remarkPlugin: i, rehypePlugin: n, getStyles() {
+    return "katex/dist/katex.min.css";
+  } };
+}
+var Ot = Pt();
+export {
+  Pt as createMathPlugin,
+  Ot as math
+};