@malloy-publisher/sdk 0.0.89 → 0.0.91

package/dist/client/index.es131.js

@@ -0,0 +1,1430 @@
+import { ShikiError as _ } from "./index.es133.js";
+import { createOnigurumaEngine as ye, getDefaultWasmLoader as be } from "./index.es132.js";
+import { FontStyle as L, INITIAL as z, EncodedTokenMetadata as X, Registry as Se, Theme as Te } from "./index.es134.js";
+import { toHtml as we } from "./index.es135.js";
+function _e(n) {
+  return Array.isArray(n) ? n : [n];
+}
+function B(n, e = !1) {
+  const t = n.split(/(\r?\n)/g);
+  let o = 0;
+  const s = [];
+  for (let r = 0; r < t.length; r += 2) {
+    const i = e ? t[r] + (t[r + 1] || "") : t[r];
+    s.push([i, o]), o += t[r].length, o += t[r + 1]?.length || 0;
+  }
+  return s;
+}
+function J(n) {
+  return !n || ["plaintext", "txt", "text", "plain"].includes(n);
+}
+function oe(n) {
+  return n === "ansi" || J(n);
+}
+function V(n) {
+  return n === "none";
+}
+function ae(n) {
+  return V(n);
+}
+function ie(n, e) {
+  if (!e)
+    return n;
+  n.properties ||= {}, n.properties.class ||= [], typeof n.properties.class == "string" && (n.properties.class = n.properties.class.split(/\s+/g)), Array.isArray(n.properties.class) || (n.properties.class = []);
+  const t = Array.isArray(e) ? e : e.split(/\s+/g);
+  for (const o of t)
+    o && !n.properties.class.includes(o) && n.properties.class.push(o);
+  return n;
+}
+function ke(n, e) {
+  let t = 0;
+  const o = [];
+  for (const s of e)
+    s > t && o.push({
+      ...n,
+      content: n.content.slice(t, s),
+      offset: n.offset + t
+    }), t = s;
+  return t < n.content.length && o.push({
+    ...n,
+    content: n.content.slice(t),
+    offset: n.offset + t
+  }), o;
+}
+function Le(n, e) {
+  const t = Array.from(e instanceof Set ? e : new Set(e)).sort((o, s) => o - s);
+  return t.length ? n.map((o) => o.flatMap((s) => {
+    const r = t.filter((i) => s.offset < i && i < s.offset + s.content.length).map((i) => i - s.offset).sort((i, a) => i - a);
+    return r.length ? ke(s, r) : s;
+  })) : n;
+}
+async function ce(n) {
+  return Promise.resolve(typeof n == "function" ? n() : n).then((e) => e.default || e);
+}
+function O(n, e) {
+  const t = typeof n == "string" ? {} : { ...n.colorReplacements }, o = typeof n == "string" ? n : n.name;
+  for (const [s, r] of Object.entries(e?.colorReplacements || {}))
+    typeof r == "string" ? t[s] = r : s === o && Object.assign(t, r);
+  return t;
+}
+function v(n, e) {
+  return n && (e?.[n?.toLowerCase()] || n);
+}
+function le(n) {
+  const e = {};
+  return n.color && (e.color = n.color), n.bgColor && (e["background-color"] = n.bgColor), n.fontStyle && (n.fontStyle & L.Italic && (e["font-style"] = "italic"), n.fontStyle & L.Bold && (e["font-weight"] = "bold"), n.fontStyle & L.Underline && (e["text-decoration"] = "underline")), e;
+}
+function Ce(n) {
+  return typeof n == "string" ? n : Object.entries(n).map(([e, t]) => `${e}:${t}`).join(";");
+}
+function ve(n) {
+  const e = B(n, !0).map(([s]) => s);
+  function t(s) {
+    if (s === n.length)
+      return {
+        line: e.length - 1,
+        character: e[e.length - 1].length
+      };
+    let r = s, i = 0;
+    for (const a of e) {
+      if (r < a.length)
+        break;
+      r -= a.length, i++;
+    }
+    return { line: i, character: r };
+  }
+  function o(s, r) {
+    let i = 0;
+    for (let a = 0; a < s; a++)
+      i += e[a].length;
+    return i += r, i;
+  }
+  return {
+    lines: e,
+    indexToPos: t,
+    posToIndex: o
+  };
+}
+class T extends Error {
+  constructor(e) {
+    super(e), this.name = "ShikiError";
+  }
+}
+const fe = /* @__PURE__ */ new WeakMap();
+function W(n, e) {
+  fe.set(n, e);
+}
+function E(n) {
+  return fe.get(n);
+}
+class $ {
+  /**
+   * Theme to Stack mapping
+   */
+  _stacks = {};
+  lang;
+  get themes() {
+    return Object.keys(this._stacks);
+  }
+  get theme() {
+    return this.themes[0];
+  }
+  get _stack() {
+    return this._stacks[this.theme];
+  }
+  /**
+   * Static method to create a initial grammar state.
+   */
+  static initial(e, t) {
+    return new $(
+      Object.fromEntries(_e(t).map((o) => [o, z])),
+      e
+    );
+  }
+  constructor(...e) {
+    if (e.length === 2) {
+      const [t, o] = e;
+      this.lang = o, this._stacks = t;
+    } else {
+      const [t, o, s] = e;
+      this.lang = o, this._stacks = { [s]: t };
+    }
+  }
+  /**
+   * Get the internal stack object.
+   * @internal
+   */
+  getInternalStack(e = this.theme) {
+    return this._stacks[e];
+  }
+  /**
+   * @deprecated use `getScopes` instead
+   */
+  get scopes() {
+    return Z(this._stacks[this.theme]);
+  }
+  getScopes(e = this.theme) {
+    return Z(this._stacks[e]);
+  }
+  toJSON() {
+    return {
+      lang: this.lang,
+      theme: this.theme,
+      themes: this.themes,
+      scopes: this.scopes
+    };
+  }
+}
+function Z(n) {
+  const e = [], t = /* @__PURE__ */ new Set();
+  function o(s) {
+    if (t.has(s))
+      return;
+    t.add(s);
+    const r = s?.nameScopesList?.scopeName;
+    r && e.push(r), s.parent && o(s.parent);
+  }
+  return o(n), e;
+}
+function xe(n, e) {
+  if (!(n instanceof $))
+    throw new T("Invalid grammar state");
+  return n.getInternalStack(e);
+}
+function Ne() {
+  const n = /* @__PURE__ */ new WeakMap();
+  function e(t) {
+    if (!n.has(t.meta)) {
+      let o = function(i) {
+        if (typeof i == "number") {
+          if (i < 0 || i > t.source.length)
+            throw new T(`Invalid decoration offset: ${i}. Code length: ${t.source.length}`);
+          return {
+            ...s.indexToPos(i),
+            offset: i
+          };
+        } else {
+          const a = s.lines[i.line];
+          if (a === void 0)
+            throw new T(`Invalid decoration position ${JSON.stringify(i)}. Lines length: ${s.lines.length}`);
+          if (i.character < 0 || i.character > a.length)
+            throw new T(`Invalid decoration position ${JSON.stringify(i)}. Line ${i.line} length: ${a.length}`);
+          return {
+            ...i,
+            offset: s.posToIndex(i.line, i.character)
+          };
+        }
+      };
+      const s = ve(t.source), r = (t.options.decorations || []).map((i) => ({
+        ...i,
+        start: o(i.start),
+        end: o(i.end)
+      }));
+      $e(r), n.set(t.meta, {
+        decorations: r,
+        converter: s,
+        source: t.source
+      });
+    }
+    return n.get(t.meta);
+  }
+  return {
+    name: "shiki:decorations",
+    tokens(t) {
+      if (!this.options.decorations?.length)
+        return;
+      const s = e(this).decorations.flatMap((i) => [i.start.offset, i.end.offset]);
+      return Le(t, s);
+    },
+    code(t) {
+      if (!this.options.decorations?.length)
+        return;
+      const o = e(this), s = Array.from(t.children).filter((f) => f.type === "element" && f.tagName === "span");
+      if (s.length !== o.converter.lines.length)
+        throw new T(`Number of lines in code element (${s.length}) does not match the number of lines in the source (${o.converter.lines.length}). Failed to apply decorations.`);
+      function r(f, u, d, h) {
+        const p = s[f];
+        let S = "", g = -1, b = -1;
+        if (u === 0 && (g = 0), d === 0 && (b = 0), d === Number.POSITIVE_INFINITY && (b = p.children.length), g === -1 || b === -1)
+          for (let y = 0; y < p.children.length; y++)
+            S += ue(p.children[y]), g === -1 && S.length === u && (g = y + 1), b === -1 && S.length === d && (b = y + 1);
+        if (g === -1)
+          throw new T(`Failed to find start index for decoration ${JSON.stringify(h.start)}`);
+        if (b === -1)
+          throw new T(`Failed to find end index for decoration ${JSON.stringify(h.end)}`);
+        const m = p.children.slice(g, b);
+        if (!h.alwaysWrap && m.length === p.children.length)
+          a(p, h, "line");
+        else if (!h.alwaysWrap && m.length === 1 && m[0].type === "element")
+          a(m[0], h, "token");
+        else {
+          const y = {
+            type: "element",
+            tagName: "span",
+            properties: {},
+            children: m
+          };
+          a(y, h, "wrapper"), p.children.splice(g, m.length, y);
+        }
+      }
+      function i(f, u) {
+        s[f] = a(s[f], u, "line");
+      }
+      function a(f, u, d) {
+        const h = u.properties || {}, p = u.transform || ((S) => S);
+        return f.tagName = u.tagName || "span", f.properties = {
+          ...f.properties,
+          ...h,
+          class: f.properties.class
+        }, u.properties?.class && ie(f, u.properties.class), f = p(f, d) || f, f;
+      }
+      const c = [], l = o.decorations.sort((f, u) => u.start.offset - f.start.offset);
+      for (const f of l) {
+        const { start: u, end: d } = f;
+        if (u.line === d.line)
+          r(u.line, u.character, d.character, f);
+        else if (u.line < d.line) {
+          r(u.line, u.character, Number.POSITIVE_INFINITY, f);
+          for (let h = u.line + 1; h < d.line; h++)
+            c.unshift(() => i(h, f));
+          r(d.line, 0, d.character, f);
+        }
+      }
+      c.forEach((f) => f());
+    }
+  };
+}
+function $e(n) {
+  for (let e = 0; e < n.length; e++) {
+    const t = n[e];
+    if (t.start.offset > t.end.offset)
+      throw new T(`Invalid decoration range: ${JSON.stringify(t.start)} - ${JSON.stringify(t.end)}`);
+    for (let o = e + 1; o < n.length; o++) {
+      const s = n[o], r = t.start.offset < s.start.offset && s.start.offset < t.end.offset, i = t.start.offset < s.end.offset && s.end.offset < t.end.offset, a = s.start.offset < t.start.offset && t.start.offset < s.end.offset, c = s.start.offset < t.end.offset && t.end.offset < s.end.offset;
+      if (r || i || a || c) {
+        if (i && i || a && c)
+          continue;
+        throw new T(`Decorations ${JSON.stringify(t.start)} and ${JSON.stringify(s.start)} intersect.`);
+      }
+    }
+  }
+}
+function ue(n) {
+  return n.type === "text" ? n.value : n.type === "element" ? n.children.map(ue).join("") : "";
+}
+const Ie = [
+  /* @__PURE__ */ Ne()
+];
+function j(n) {
+  return [
+    ...n.transformers || [],
+    ...Ie
+  ];
+}
+var x = [
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "brightBlack",
+  "brightRed",
+  "brightGreen",
+  "brightYellow",
+  "brightBlue",
+  "brightMagenta",
+  "brightCyan",
+  "brightWhite"
+], D = {
+  1: "bold",
+  2: "dim",
+  3: "italic",
+  4: "underline",
+  7: "reverse",
+  9: "strikethrough"
+};
+function Ee(n, e) {
+  const t = n.indexOf("\x1B[", e);
+  if (t !== -1) {
+    const o = n.indexOf("m", t);
+    return {
+      sequence: n.substring(t + 2, o).split(";"),
+      startPosition: t,
+      position: o + 1
+    };
+  }
+  return {
+    position: n.length
+  };
+}
+function ee(n, e) {
+  let t = 1;
+  const o = n[e + t++];
+  let s;
+  if (o === "2") {
+    const r = [
+      n[e + t++],
+      n[e + t++],
+      n[e + t]
+    ].map((i) => Number.parseInt(i));
+    r.length === 3 && !r.some((i) => Number.isNaN(i)) && (s = {
+      type: "rgb",
+      rgb: r
+    });
+  } else if (o === "5") {
+    const r = Number.parseInt(n[e + t]);
+    Number.isNaN(r) || (s = { type: "table", index: Number(r) });
+  }
+  return [t, s];
+}
+function Me(n) {
+  const e = [];
+  for (let t = 0; t < n.length; t++) {
+    const o = n[t], s = Number.parseInt(o);
+    if (!Number.isNaN(s))
+      if (s === 0)
+        e.push({ type: "resetAll" });
+      else if (s <= 9)
+        D[s] && e.push({
+          type: "setDecoration",
+          value: D[s]
+        });
+      else if (s <= 29) {
+        const r = D[s - 20];
+        r && e.push({
+          type: "resetDecoration",
+          value: r
+        });
+      } else if (s <= 37)
+        e.push({
+          type: "setForegroundColor",
+          value: { type: "named", name: x[s - 30] }
+        });
+      else if (s === 38) {
+        const [r, i] = ee(n, t);
+        i && e.push({
+          type: "setForegroundColor",
+          value: i
+        }), t += r;
+      } else if (s === 39)
+        e.push({
+          type: "resetForegroundColor"
+        });
+      else if (s <= 47)
+        e.push({
+          type: "setBackgroundColor",
+          value: { type: "named", name: x[s - 40] }
+        });
+      else if (s === 48) {
+        const [r, i] = ee(n, t);
+        i && e.push({
+          type: "setBackgroundColor",
+          value: i
+        }), t += r;
+      } else s === 49 ? e.push({
+        type: "resetBackgroundColor"
+      }) : s >= 90 && s <= 97 ? e.push({
+        type: "setForegroundColor",
+        value: { type: "named", name: x[s - 90 + 8] }
+      }) : s >= 100 && s <= 107 && e.push({
+        type: "setBackgroundColor",
+        value: { type: "named", name: x[s - 100 + 8] }
+      });
+  }
+  return e;
+}
+function Oe() {
+  let n = null, e = null, t = /* @__PURE__ */ new Set();
+  return {
+    parse(o) {
+      const s = [];
+      let r = 0;
+      do {
+        const i = Ee(o, r), a = i.sequence ? o.substring(r, i.startPosition) : o.substring(r);
+        if (a.length > 0 && s.push({
+          value: a,
+          foreground: n,
+          background: e,
+          decorations: new Set(t)
+        }), i.sequence) {
+          const c = Me(i.sequence);
+          for (const l of c)
+            l.type === "resetAll" ? (n = null, e = null, t.clear()) : l.type === "resetForegroundColor" ? n = null : l.type === "resetBackgroundColor" ? e = null : l.type === "resetDecoration" && t.delete(l.value);
+          for (const l of c)
+            l.type === "setForegroundColor" ? n = l.value : l.type === "setBackgroundColor" ? e = l.value : l.type === "setDecoration" && t.add(l.value);
+        }
+        r = i.position;
+      } while (r < o.length);
+      return s;
+    }
+  };
+}
+var je = {
+  black: "#000000",
+  red: "#bb0000",
+  green: "#00bb00",
+  yellow: "#bbbb00",
+  blue: "#0000bb",
+  magenta: "#ff00ff",
+  cyan: "#00bbbb",
+  white: "#eeeeee",
+  brightBlack: "#555555",
+  brightRed: "#ff5555",
+  brightGreen: "#00ff00",
+  brightYellow: "#ffff55",
+  brightBlue: "#5555ff",
+  brightMagenta: "#ff55ff",
+  brightCyan: "#55ffff",
+  brightWhite: "#ffffff"
+};
+function Ge(n = je) {
+  function e(a) {
+    return n[a];
+  }
+  function t(a) {
+    return `#${a.map((c) => Math.max(0, Math.min(c, 255)).toString(16).padStart(2, "0")).join("")}`;
+  }
+  let o;
+  function s() {
+    if (o)
+      return o;
+    o = [];
+    for (let l = 0; l < x.length; l++)
+      o.push(e(x[l]));
+    let a = [0, 95, 135, 175, 215, 255];
+    for (let l = 0; l < 6; l++)
+      for (let f = 0; f < 6; f++)
+        for (let u = 0; u < 6; u++)
+          o.push(t([a[l], a[f], a[u]]));
+    let c = 8;
+    for (let l = 0; l < 24; l++, c += 10)
+      o.push(t([c, c, c]));
+    return o;
+  }
+  function r(a) {
+    return s()[a];
+  }
+  function i(a) {
+    switch (a.type) {
+      case "named":
+        return e(a.name);
+      case "rgb":
+        return t(a.rgb);
+      case "table":
+        return r(a.index);
+    }
+  }
+  return {
+    value: i
+  };
+}
+function Re(n, e, t) {
+  const o = O(n, t), s = B(e), r = Ge(
+    Object.fromEntries(
+      x.map((a) => [
+        a,
+        n.colors?.[`terminal.ansi${a[0].toUpperCase()}${a.substring(1)}`]
+      ])
+    )
+  ), i = Oe();
+  return s.map(
+    (a) => i.parse(a[0]).map((c) => {
+      let l, f;
+      c.decorations.has("reverse") ? (l = c.background ? r.value(c.background) : n.bg, f = c.foreground ? r.value(c.foreground) : n.fg) : (l = c.foreground ? r.value(c.foreground) : n.fg, f = c.background ? r.value(c.background) : void 0), l = v(l, o), f = v(f, o), c.decorations.has("dim") && (l = Ae(l));
+      let u = L.None;
+      return c.decorations.has("bold") && (u |= L.Bold), c.decorations.has("italic") && (u |= L.Italic), c.decorations.has("underline") && (u |= L.Underline), {
+        content: c.value,
+        offset: a[1],
+        // TODO: more accurate offset? might need to fork ansi-sequence-parser
+        color: l,
+        bgColor: f,
+        fontStyle: u
+      };
+    })
+  );
+}
+function Ae(n) {
+  const e = n.match(/#([0-9a-f]{3})([0-9a-f]{3})?([0-9a-f]{2})?/);
+  if (e)
+    if (e[3]) {
+      const o = Math.round(Number.parseInt(e[3], 16) / 2).toString(16).padStart(2, "0");
+      return `#${e[1]}${e[2]}${o}`;
+    } else return e[2] ? `#${e[1]}${e[2]}80` : `#${Array.from(e[1]).map((o) => `${o}${o}`).join("")}80`;
+  const t = n.match(/var\((--[\w-]+-ansi-[\w-]+)\)/);
+  return t ? `var(${t[1]}-dim)` : n;
+}
+function Y(n, e, t = {}) {
+  const {
+    lang: o = "text",
+    theme: s = n.getLoadedThemes()[0]
+  } = t;
+  if (J(o) || V(s))
+    return B(e).map((c) => [{ content: c[0], offset: c[1] }]);
+  const { theme: r, colorMap: i } = n.setTheme(s);
+  if (o === "ansi")
+    return Re(r, e, t);
+  const a = n.getLanguage(o);
+  if (t.grammarState) {
+    if (t.grammarState.lang !== a.name)
+      throw new _(`Grammar state language "${t.grammarState.lang}" does not match highlight language "${a.name}"`);
+    if (!t.grammarState.themes.includes(r.name))
+      throw new _(`Grammar state themes "${t.grammarState.themes}" do not contain highlight theme "${r.name}"`);
+  }
+  return We(e, a, r, i, t);
+}
+function Be(...n) {
+  if (n.length === 2)
+    return E(n[1]);
+  const [e, t, o = {}] = n, {
+    lang: s = "text",
+    theme: r = e.getLoadedThemes()[0]
+  } = o;
+  if (J(s) || V(r))
+    throw new _("Plain language does not have grammar state");
+  if (s === "ansi")
+    throw new _("ANSI language does not have grammar state");
+  const { theme: i, colorMap: a } = e.setTheme(r), c = e.getLanguage(s);
+  return new $(
+    G(t, c, i, a, o).stateStack,
+    c.name,
+    i.name
+  );
+}
+function We(n, e, t, o, s) {
+  const r = G(n, e, t, o, s), i = new $(
+    G(n, e, t, o, s).stateStack,
+    e.name,
+    t.name
+  );
+  return W(r.tokens, i), r.tokens;
+}
+function G(n, e, t, o, s) {
+  const r = O(t, s), {
+    tokenizeMaxLineLength: i = 0,
+    tokenizeTimeLimit: a = 500
+  } = s, c = B(n);
+  let l = s.grammarState ? xe(s.grammarState, t.name) ?? z : s.grammarContextCode != null ? G(
+    s.grammarContextCode,
+    e,
+    t,
+    o,
+    {
+      ...s,
+      grammarState: void 0,
+      grammarContextCode: void 0
+    }
+  ).stateStack : z, f = [];
+  const u = [];
+  for (let d = 0, h = c.length; d < h; d++) {
+    const [p, S] = c[d];
+    if (p === "") {
+      f = [], u.push([]);
+      continue;
+    }
+    if (i > 0 && p.length >= i) {
+      f = [], u.push([{
+        content: p,
+        offset: S,
+        color: "",
+        fontStyle: 0
+      }]);
+      continue;
+    }
+    let g, b, m;
+    s.includeExplanation && (g = e.tokenizeLine(p, l), b = g.tokens, m = 0);
+    const y = e.tokenizeLine2(p, l, a), C = y.tokens.length / 2;
+    for (let k = 0; k < C; k++) {
+      const M = y.tokens[2 * k], F = k + 1 < C ? y.tokens[2 * k + 2] : p.length;
+      if (M === F)
+        continue;
+      const K = y.tokens[2 * k + 1], de = v(
+        o[X.getForeground(K)],
+        r
+      ), pe = X.getFontStyle(K), P = {
+        content: p.substring(M, F),
+        offset: S + M,
+        color: de,
+        fontStyle: pe
+      };
+      if (s.includeExplanation) {
+        const q = [];
+        if (s.includeExplanation !== "scopeName")
+          for (const w of t.settings) {
+            let N;
+            switch (typeof w.scope) {
+              case "string":
+                N = w.scope.split(/,/).map((H) => H.trim());
+                break;
+              case "object":
+                N = w.scope;
+                break;
+              default:
+                continue;
+            }
+            q.push({
+              settings: w,
+              selectors: N.map((H) => H.split(/ /))
+            });
+          }
+        P.explanation = [];
+        let Q = 0;
+        for (; M + Q < F; ) {
+          const w = b[m], N = p.substring(
+            w.startIndex,
+            w.endIndex
+          );
+          Q += N.length, P.explanation.push({
+            content: N,
+            scopes: s.includeExplanation === "scopeName" ? Fe(
+              w.scopes
+            ) : Pe(
+              q,
+              w.scopes
+            )
+          }), m += 1;
+        }
+      }
+      f.push(P);
+    }
+    u.push(f), f = [], l = y.ruleStack;
+  }
+  return {
+    tokens: u,
+    stateStack: l
+  };
+}
+function Fe(n) {
+  return n.map((e) => ({ scopeName: e }));
+}
+function Pe(n, e) {
+  const t = [];
+  for (let o = 0, s = e.length; o < s; o++) {
+    const r = e[o];
+    t[o] = {
+      scopeName: r,
+      themeMatches: De(n, r, e.slice(0, o))
+    };
+  }
+  return t;
+}
+function te(n, e) {
+  return n === e || e.substring(0, n.length) === n && e[n.length] === ".";
+}
+function He(n, e, t) {
+  if (!te(n[n.length - 1], e))
+    return !1;
+  let o = n.length - 2, s = t.length - 1;
+  for (; o >= 0 && s >= 0; )
+    te(n[o], t[s]) && (o -= 1), s -= 1;
+  return o === -1;
+}
+function De(n, e, t) {
+  const o = [];
+  for (const { selectors: s, settings: r } of n)
+    for (const i of s)
+      if (He(i, e, t)) {
+        o.push(r);
+        break;
+      }
+  return o;
+}
+function he(n, e, t) {
+  const o = Object.entries(t.themes).filter((c) => c[1]).map((c) => ({ color: c[0], theme: c[1] })), s = o.map((c) => {
+    const l = Y(n, e, {
+      ...t,
+      theme: c.theme
+    }), f = E(l), u = typeof c.theme == "string" ? c.theme : c.theme.name;
+    return {
+      tokens: l,
+      state: f,
+      theme: u
+    };
+  }), r = ze(
+    ...s.map((c) => c.tokens)
+  ), i = r[0].map(
+    (c, l) => c.map((f, u) => {
+      const d = {
+        content: f.content,
+        variants: {},
+        offset: f.offset
+      };
+      return "includeExplanation" in t && t.includeExplanation && (d.explanation = f.explanation), r.forEach((h, p) => {
+        const {
+          content: S,
+          explanation: g,
+          offset: b,
+          ...m
+        } = h[l][u];
+        d.variants[o[p].color] = m;
+      }), d;
+    })
+  ), a = s[0].state ? new $(
+    Object.fromEntries(s.map((c) => [c.theme, c.state?.getInternalStack(c.theme)])),
+    s[0].state.lang
+  ) : void 0;
+  return a && W(i, a), i;
+}
+function ze(...n) {
+  const e = n.map(() => []), t = n.length;
+  for (let o = 0; o < n[0].length; o++) {
+    const s = n.map((c) => c[o]), r = e.map(() => []);
+    e.forEach((c, l) => c.push(r[l]));
+    const i = s.map(() => 0), a = s.map((c) => c[0]);
+    for (; a.every((c) => c); ) {
+      const c = Math.min(...a.map((l) => l.content.length));
+      for (let l = 0; l < t; l++) {
+        const f = a[l];
+        f.content.length === c ? (r[l].push(f), i[l] += 1, a[l] = s[l][i[l]]) : (r[l].push({
+          ...f,
+          content: f.content.slice(0, c)
+        }), a[l] = {
+          ...f,
+          content: f.content.slice(c),
+          offset: f.offset + c
+        });
+      }
+    }
+  }
+  return e;
+}
+function R(n, e, t) {
+  let o, s, r, i, a, c;
+  if ("themes" in t) {
+    const {
+      defaultColor: l = "light",
+      cssVariablePrefix: f = "--shiki-"
+    } = t, u = Object.entries(t.themes).filter((g) => g[1]).map((g) => ({ color: g[0], theme: g[1] })).sort((g, b) => g.color === l ? -1 : b.color === l ? 1 : 0);
+    if (u.length === 0)
+      throw new _("`themes` option must not be empty");
+    const d = he(
+      n,
+      e,
+      t
+    );
+    if (c = E(d), l && !u.find((g) => g.color === l))
+      throw new _(`\`themes\` option must contain the defaultColor key \`${l}\``);
+    const h = u.map((g) => n.getTheme(g.theme)), p = u.map((g) => g.color);
+    r = d.map((g) => g.map((b) => Je(b, p, f, l))), c && W(r, c);
+    const S = u.map((g) => O(g.theme, t));
+    s = u.map((g, b) => (b === 0 && l ? "" : `${f + g.color}:`) + (v(h[b].fg, S[b]) || "inherit")).join(";"), o = u.map((g, b) => (b === 0 && l ? "" : `${f + g.color}-bg:`) + (v(h[b].bg, S[b]) || "inherit")).join(";"), i = `shiki-themes ${h.map((g) => g.name).join(" ")}`, a = l ? void 0 : [s, o].join(";");
+  } else if ("theme" in t) {
+    const l = O(t.theme, t);
+    r = Y(
+      n,
+      e,
+      t
+    );
+    const f = n.getTheme(t.theme);
+    o = v(f.bg, l), s = v(f.fg, l), i = f.name, c = E(r);
+  } else
+    throw new _("Invalid options, either `theme` or `themes` must be provided");
+  return {
+    tokens: r,
+    fg: s,
+    bg: o,
+    themeName: i,
+    rootStyle: a,
+    grammarState: c
+  };
+}
+function Je(n, e, t, o) {
+  const s = {
+    content: n.content,
+    explanation: n.explanation,
+    offset: n.offset
+  }, r = e.map((c) => le(n.variants[c])), i = new Set(r.flatMap((c) => Object.keys(c))), a = {};
+  return r.forEach((c, l) => {
+    for (const f of i) {
+      const u = c[f] || "inherit";
+      if (l === 0 && o)
+        a[f] = u;
+      else {
+        const d = f === "color" ? "" : f === "background-color" ? "-bg" : `-${f}`, h = t + e[l] + (f === "color" ? "" : d);
+        a[h] = u;
+      }
+    }
+  }), s.htmlStyle = a, s;
+}
+function A(n, e, t, o = {
+  meta: {},
+  options: t,
+  codeToHast: (s, r) => A(n, s, r),
+  codeToTokens: (s, r) => R(n, s, r)
+}) {
+  let s = e;
+  for (const h of j(t))
+    s = h.preprocess?.call(o, s, t) || s;
+  let {
+    tokens: r,
+    fg: i,
+    bg: a,
+    themeName: c,
+    rootStyle: l,
+    grammarState: f
+  } = R(n, s, t);
+  const {
+    mergeWhitespaces: u = !0
+  } = t;
+  u === !0 ? r = Ye(r) : u === "never" && (r = Ue(r));
+  const d = {
+    ...o,
+    get source() {
+      return s;
+    }
+  };
+  for (const h of j(t))
+    r = h.tokens?.call(d, r) || r;
+  return Ve(
+    r,
+    {
+      ...t,
+      fg: i,
+      bg: a,
+      themeName: c,
+      rootStyle: l
+    },
+    d,
+    f
+  );
+}
+function Ve(n, e, t, o = E(n)) {
+  const s = j(e), r = [], i = {
+    type: "root",
+    children: []
+  }, {
+    structure: a = "classic",
+    tabindex: c = "0"
+  } = e;
+  let l = {
+    type: "element",
+    tagName: "pre",
+    properties: {
+      class: `shiki ${e.themeName || ""}`,
+      style: e.rootStyle || `background-color:${e.bg};color:${e.fg}`,
+      ...c !== !1 && c != null ? {
+        tabindex: c.toString()
+      } : {},
+      ...Object.fromEntries(
+        Array.from(
+          Object.entries(e.meta || {})
+        ).filter(([p]) => !p.startsWith("_"))
+      )
+    },
+    children: []
+  }, f = {
+    type: "element",
+    tagName: "code",
+    properties: {},
+    children: r
+  };
+  const u = [], d = {
+    ...t,
+    structure: a,
+    addClassToHast: ie,
+    get source() {
+      return t.source;
+    },
+    get tokens() {
+      return n;
+    },
+    get options() {
+      return e;
+    },
+    get root() {
+      return i;
+    },
+    get pre() {
+      return l;
+    },
+    get code() {
+      return f;
+    },
+    get lines() {
+      return u;
+    }
+  };
+  if (n.forEach((p, S) => {
+    S && (a === "inline" ? i.children.push({ type: "element", tagName: "br", properties: {}, children: [] }) : a === "classic" && r.push({ type: "text", value: `
+` }));
+    let g = {
+      type: "element",
+      tagName: "span",
+      properties: { class: "line" },
+      children: []
+    }, b = 0;
+    for (const m of p) {
+      let y = {
+        type: "element",
+        tagName: "span",
+        properties: {
+          ...m.htmlAttrs
+        },
+        children: [{ type: "text", value: m.content }]
+      };
+      m.htmlStyle;
+      const C = Ce(m.htmlStyle || le(m));
+      C && (y.properties.style = C);
+      for (const k of s)
+        y = k?.span?.call(d, y, S + 1, b, g, m) || y;
+      a === "inline" ? i.children.push(y) : a === "classic" && g.children.push(y), b += m.content.length;
+    }
+    if (a === "classic") {
+      for (const m of s)
+        g = m?.line?.call(d, g, S + 1) || g;
+      u.push(g), r.push(g);
+    }
+  }), a === "classic") {
+    for (const p of s)
+      f = p?.code?.call(d, f) || f;
+    l.children.push(f);
+    for (const p of s)
+      l = p?.pre?.call(d, l) || l;
+    i.children.push(l);
+  }
+  let h = i;
+  for (const p of s)
+    h = p?.root?.call(d, h) || h;
+  return o && W(h, o), h;
+}
+function Ye(n) {
+  return n.map((e) => {
+    const t = [];
+    let o = "", s = 0;
+    return e.forEach((r, i) => {
+      const c = !(r.fontStyle && r.fontStyle & L.Underline);
+      c && r.content.match(/^\s+$/) && e[i + 1] ? (s || (s = r.offset), o += r.content) : o ? (c ? t.push({
+        ...r,
+        offset: s,
+        content: o + r.content
+      }) : t.push(
+        {
+          content: o,
+          offset: s
+        },
+        r
+      ), s = 0, o = "") : t.push(r);
+    }), t;
+  });
+}
+function Ue(n) {
+  return n.map((e) => e.flatMap((t) => {
+    if (t.content.match(/^\s+$/))
+      return t;
+    const o = t.content.match(/^(\s*)(.*?)(\s*)$/);
+    if (!o)
+      return t;
+    const [, s, r, i] = o;
+    if (!s && !i)
+      return t;
+    const a = [{
+      ...t,
+      offset: t.offset + s.length,
+      content: r
+    }];
+    return s && a.unshift({
+      content: s,
+      offset: t.offset
+    }), i && a.push({
+      content: i,
+      offset: t.offset + s.length + r.length
+    }), a;
+  }));
+}
+function Ke(n, e, t) {
+  const o = {
+    meta: {},
+    options: t,
+    codeToHast: (r, i) => A(n, r, i),
+    codeToTokens: (r, i) => R(n, r, i)
+  };
+  let s = we(A(n, e, t, o));
+  for (const r of j(t))
+    s = r.postprocess?.call(o, s, t) || s;
+  return s;
+}
+const ne = { light: "#333333", dark: "#bbbbbb" }, se = { light: "#fffffe", dark: "#1e1e1e" }, re = "__shiki_resolved";
+function U(n) {
+  if (n?.[re])
+    return n;
+  const e = {
+    ...n
+  };
+  e.tokenColors && !e.settings && (e.settings = e.tokenColors, delete e.tokenColors), e.type ||= "dark", e.colorReplacements = { ...e.colorReplacements }, e.settings ||= [];
+  let { bg: t, fg: o } = e;
+  if (!t || !o) {
+    const a = e.settings ? e.settings.find((c) => !c.name && !c.scope) : void 0;
+    a?.settings?.foreground && (o = a.settings.foreground), a?.settings?.background && (t = a.settings.background), !o && e?.colors?.["editor.foreground"] && (o = e.colors["editor.foreground"]), !t && e?.colors?.["editor.background"] && (t = e.colors["editor.background"]), o || (o = e.type === "light" ? ne.light : ne.dark), t || (t = e.type === "light" ? se.light : se.dark), e.fg = o, e.bg = t;
+  }
+  e.settings[0] && e.settings[0].settings && !e.settings[0].scope || e.settings.unshift({
+    settings: {
+      foreground: e.fg,
+      background: e.bg
+    }
+  });
+  let s = 0;
+  const r = /* @__PURE__ */ new Map();
+  function i(a) {
+    if (r.has(a))
+      return r.get(a);
+    s += 1;
+    const c = `#${s.toString(16).padStart(8, "0").toLowerCase()}`;
+    return e.colorReplacements?.[`#${c}`] ? i(a) : (r.set(a, c), c);
+  }
+  e.settings = e.settings.map((a) => {
+    const c = a.settings?.foreground && !a.settings.foreground.startsWith("#"), l = a.settings?.background && !a.settings.background.startsWith("#");
+    if (!c && !l)
+      return a;
+    const f = {
+      ...a,
+      settings: {
+        ...a.settings
+      }
+    };
+    if (c) {
+      const u = i(a.settings.foreground);
+      e.colorReplacements[u] = a.settings.foreground, f.settings.foreground = u;
+    }
+    if (l) {
+      const u = i(a.settings.background);
+      e.colorReplacements[u] = a.settings.background, f.settings.background = u;
+    }
+    return f;
+  });
+  for (const a of Object.keys(e.colors || {}))
+    if ((a === "editor.foreground" || a === "editor.background" || a.startsWith("terminal.ansi")) && !e.colors[a]?.startsWith("#")) {
+      const c = i(e.colors[a]);
+      e.colorReplacements[c] = e.colors[a], e.colors[a] = c;
+    }
+  return Object.defineProperty(e, re, {
+    enumerable: !1,
+    writable: !1,
+    value: !0
+  }), e;
+}
+async function ge(n) {
+  return Array.from(new Set((await Promise.all(
+    n.filter((e) => !oe(e)).map(async (e) => await ce(e).then((t) => Array.isArray(t) ? t : [t]))
+  )).flat()));
+}
+async function me(n) {
+  return (await Promise.all(
+    n.map(
+      async (t) => ae(t) ? null : U(await ce(t))
+    )
+  )).filter((t) => !!t);
+}
+class qe extends Se {
+  constructor(e, t, o, s = {}) {
+    super(e), this._resolver = e, this._themes = t, this._langs = o, this._alias = s, this._themes.map((r) => this.loadTheme(r)), this.loadLanguages(this._langs);
+  }
+  _resolvedThemes = /* @__PURE__ */ new Map();
+  _resolvedGrammars = /* @__PURE__ */ new Map();
+  _langMap = /* @__PURE__ */ new Map();
+  _langGraph = /* @__PURE__ */ new Map();
+  _textmateThemeCache = /* @__PURE__ */ new WeakMap();
+  _loadedThemesCache = null;
+  _loadedLanguagesCache = null;
+  getTheme(e) {
+    return typeof e == "string" ? this._resolvedThemes.get(e) : this.loadTheme(e);
+  }
+  loadTheme(e) {
+    const t = U(e);
+    return t.name && (this._resolvedThemes.set(t.name, t), this._loadedThemesCache = null), t;
+  }
+  getLoadedThemes() {
+    return this._loadedThemesCache || (this._loadedThemesCache = [...this._resolvedThemes.keys()]), this._loadedThemesCache;
+  }
+  // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`
+  // is expensive. Themes can switch often especially for dual-theme support.
+  //
+  // The parent class also accepts `colorMap` as the second parameter, but since we don't use that,
+  // we omit here so it's easier to cache the themes.
+  setTheme(e) {
+    let t = this._textmateThemeCache.get(e);
+    t || (t = Te.createFromRawTheme(e), this._textmateThemeCache.set(e, t)), this._syncRegistry.setTheme(t);
+  }
+  getGrammar(e) {
+    if (this._alias[e]) {
+      const t = /* @__PURE__ */ new Set([e]);
+      for (; this._alias[e]; ) {
+        if (e = this._alias[e], t.has(e))
+          throw new T(`Circular alias \`${Array.from(t).join(" -> ")} -> ${e}\``);
+        t.add(e);
+      }
+    }
+    return this._resolvedGrammars.get(e);
+  }
+  loadLanguage(e) {
+    if (this.getGrammar(e.name))
+      return;
+    const t = new Set(
+      [...this._langMap.values()].filter((r) => r.embeddedLangsLazy?.includes(e.name))
+    );
+    this._resolver.addLanguage(e);
+    const o = {
+      balancedBracketSelectors: e.balancedBracketSelectors || ["*"],
+      unbalancedBracketSelectors: e.unbalancedBracketSelectors || []
+    };
+    this._syncRegistry._rawGrammars.set(e.scopeName, e);
+    const s = this.loadGrammarWithConfiguration(e.scopeName, 1, o);
+    if (s.name = e.name, this._resolvedGrammars.set(e.name, s), e.aliases && e.aliases.forEach((r) => {
+      this._alias[r] = e.name;
+    }), this._loadedLanguagesCache = null, t.size)
+      for (const r of t)
+        this._resolvedGrammars.delete(r.name), this._loadedLanguagesCache = null, this._syncRegistry?._injectionGrammars?.delete(r.scopeName), this._syncRegistry?._grammars?.delete(r.scopeName), this.loadLanguage(this._langMap.get(r.name));
+  }
+  dispose() {
+    super.dispose(), this._resolvedThemes.clear(), this._resolvedGrammars.clear(), this._langMap.clear(), this._langGraph.clear(), this._loadedThemesCache = null;
+  }
+  loadLanguages(e) {
+    for (const s of e)
+      this.resolveEmbeddedLanguages(s);
+    const t = Array.from(this._langGraph.entries()), o = t.filter(([s, r]) => !r);
+    if (o.length) {
+      const s = t.filter(([r, i]) => i && i.embeddedLangs?.some((a) => o.map(([c]) => c).includes(a))).filter((r) => !o.includes(r));
+      throw new T(`Missing languages ${o.map(([r]) => `\`${r}\``).join(", ")}, required by ${s.map(([r]) => `\`${r}\``).join(", ")}`);
+    }
+    for (const [s, r] of t)
+      this._resolver.addLanguage(r);
+    for (const [s, r] of t)
+      this.loadLanguage(r);
+  }
+  getLoadedLanguages() {
+    return this._loadedLanguagesCache || (this._loadedLanguagesCache = [
+      .../* @__PURE__ */ new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])
+    ]), this._loadedLanguagesCache;
+  }
+  resolveEmbeddedLanguages(e) {
+    if (this._langMap.set(e.name, e), this._langGraph.set(e.name, e), e.embeddedLangs)
+      for (const t of e.embeddedLangs)
+        this._langGraph.set(t, this._langMap.get(t));
+  }
+}
+class Qe {
+  _langs = /* @__PURE__ */ new Map();
+  _scopeToLang = /* @__PURE__ */ new Map();
+  _injections = /* @__PURE__ */ new Map();
+  _onigLib;
+  constructor(e, t) {
+    this._onigLib = {
+      createOnigScanner: (o) => e.createScanner(o),
+      createOnigString: (o) => e.createString(o)
+    }, t.forEach((o) => this.addLanguage(o));
+  }
+  get onigLib() {
+    return this._onigLib;
+  }
+  getLangRegistration(e) {
+    return this._langs.get(e);
+  }
+  loadGrammar(e) {
+    return this._scopeToLang.get(e);
+  }
+  addLanguage(e) {
+    this._langs.set(e.name, e), e.aliases && e.aliases.forEach((t) => {
+      this._langs.set(t, e);
+    }), this._scopeToLang.set(e.scopeName, e), e.injectTo && e.injectTo.forEach((t) => {
+      this._injections.get(t) || this._injections.set(t, []), this._injections.get(t).push(e.scopeName);
+    });
+  }
+  getInjections(e) {
+    const t = e.split(".");
+    let o = [];
+    for (let s = 1; s <= t.length; s++) {
+      const r = t.slice(0, s).join(".");
+      o = [...o, ...this._injections.get(r) || []];
+    }
+    return o;
+  }
+}
+let I = 0;
+function Xe(n) {
+  I += 1, n.warnings !== !1 && I >= 10 && I % 10 === 0 && console.warn(`[Shiki] ${I} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \`highlighter.dispose()\` to release unused instances.`);
+  let e = !1;
+  if (!n.engine)
+    throw new T("`engine` option is required for synchronous mode");
+  const t = (n.langs || []).flat(1), o = (n.themes || []).flat(1).map(U), s = new Qe(n.engine, t), r = new qe(s, o, t, n.langAlias);
+  let i;
+  function a(m) {
+    g();
+    const y = r.getGrammar(typeof m == "string" ? m : m.name);
+    if (!y)
+      throw new T(`Language \`${m}\` not found, you may need to load it first`);
+    return y;
+  }
+  function c(m) {
+    if (m === "none")
+      return { bg: "", fg: "", name: "none", settings: [], type: "dark" };
+    g();
+    const y = r.getTheme(m);
+    if (!y)
+      throw new T(`Theme \`${m}\` not found, you may need to load it first`);
+    return y;
+  }
+  function l(m) {
+    g();
+    const y = c(m);
+    i !== m && (r.setTheme(y), i = m);
+    const C = r.getColorMap();
+    return {
+      theme: y,
+      colorMap: C
+    };
+  }
+  function f() {
+    return g(), r.getLoadedThemes();
+  }
+  function u() {
+    return g(), r.getLoadedLanguages();
+  }
+  function d(...m) {
+    g(), r.loadLanguages(m.flat(1));
+  }
+  async function h(...m) {
+    return d(await ge(m));
+  }
+  function p(...m) {
+    g();
+    for (const y of m.flat(1))
+      r.loadTheme(y);
+  }
+  async function S(...m) {
+    return g(), p(await me(m));
+  }
+  function g() {
+    if (e)
+      throw new T("Shiki instance has been disposed");
+  }
+  function b() {
+    e || (e = !0, r.dispose(), I -= 1);
+  }
+  return {
+    setTheme: l,
+    getTheme: c,
+    getLanguage: a,
+    getLoadedThemes: f,
+    getLoadedLanguages: u,
+    loadLanguage: h,
+    loadLanguageSync: d,
+    loadTheme: S,
+    loadThemeSync: p,
+    dispose: b,
+    [Symbol.dispose]: b
+  };
+}
+async function Ze(n = {}) {
+  n.loadWasm;
+  const [
+    e,
+    t,
+    o
+  ] = await Promise.all([
+    me(n.themes || []),
+    ge(n.langs || []),
+    n.engine || ye(n.loadWasm || be())
+  ]);
+  return Xe({
+    ...n,
+    themes: e,
+    langs: t,
+    engine: o
+  });
+}
+async function et(n = {}) {
+  const e = await Ze(n);
+  return {
+    getLastGrammarState: (...t) => Be(e, ...t),
+    codeToTokensBase: (t, o) => Y(e, t, o),
+    codeToTokensWithThemes: (t, o) => he(e, t, o),
+    codeToTokens: (t, o) => R(e, t, o),
+    codeToHast: (t, o) => A(e, t, o),
+    codeToHtml: (t, o) => Ke(e, t, o),
+    ...e,
+    getInternalContext: () => e
+  };
+}
+function ot(n, e, t) {
+  let o, s, r;
+  {
+    const a = n;
+    o = a.langs, s = a.themes, r = a.engine;
+  }
+  async function i(a) {
+    function c(h) {
+      if (typeof h == "string") {
+        if (oe(h))
+          return [];
+        const p = o[h];
+        if (!p)
+          throw new _(`Language \`${h}\` is not included in this bundle. You may want to load it from external source.`);
+        return p;
+      }
+      return h;
+    }
+    function l(h) {
+      if (ae(h))
+        return "none";
+      if (typeof h == "string") {
+        const p = s[h];
+        if (!p)
+          throw new _(`Theme \`${h}\` is not included in this bundle. You may want to load it from external source.`);
+        return p;
+      }
+      return h;
+    }
+    const f = (a.themes ?? []).map((h) => l(h)), u = (a.langs ?? []).map((h) => c(h)), d = await et({
+      engine: a.engine ?? r(),
+      ...a,
+      themes: f,
+      langs: u
+    });
+    return {
+      ...d,
+      loadLanguage(...h) {
+        return d.loadLanguage(...h.map(c));
+      },
+      loadTheme(...h) {
+        return d.loadTheme(...h.map(l));
+      }
+    };
+  }
+  return i;
+}
+export {
+  L as FontStyle,
+  _ as ShikiError,
+  X as StackElementMetadata,
+  ie as addClassToHast,
+  v as applyColorReplacements,
+  A as codeToHast,
+  Ke as codeToHtml,
+  R as codeToTokens,
+  Y as codeToTokensBase,
+  he as codeToTokensWithThemes,
+  et as createHighlighterCore,
+  ve as createPositionConverter,
+  Ze as createShikiInternal,
+  Xe as createShikiInternalSync,
+  ot as createdBundledHighlighter,
+  le as getTokenStyleObject,
+  we as hastToHtml,
+  V as isNoneTheme,
+  J as isPlainLang,
+  oe as isSpecialLang,
+  ae as isSpecialTheme,
+  ce as normalizeGetter,
+  U as normalizeTheme,
+  O as resolveColorReplacements,
+  B as splitLines,
+  ke as splitToken,
+  Le as splitTokens,
+  Ce as stringifyTokenStyle,
+  _e as toArray,
+  Re as tokenizeAnsiWithTheme,
+  We as tokenizeWithTheme,
+  Ve as tokensToHast,
+  Ne as transformerDecorations
+};