@qwik.dev/devtools 0.2.5 → 0.2.6

package/dist/ui/node_modules/.pnpm/@shikijs_core@3.8.1/node_modules/@shikijs/core/dist/index.qwik.mjs

@@ -1,1947 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { ShikiError as ShikiError$1 } from "../../../../../@shikijs_types@3.8.1/node_modules/@shikijs/types/dist/index.qwik.mjs";
-import { FontStyle, INITIAL, EncodedTokenMetadata, Registry as Registry$1, Theme } from "../../../../../@shikijs_vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.qwik.mjs";
-import { toHtml } from "../../../../../hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/index.qwik.mjs";
-function resolveColorReplacements(theme, options) {
-  const replacements = typeof theme === "string" ? {} : { ...theme.colorReplacements };
-  const themeName = typeof theme === "string" ? theme : theme.name;
-  for (const [key, value] of Object.entries(options?.colorReplacements || {})) {
-    if (typeof value === "string")
-      replacements[key] = value;
-    else if (key === themeName)
-      Object.assign(replacements, value);
-  }
-  return replacements;
-}
-function applyColorReplacements(color, replacements) {
-  if (!color)
-    return color;
-  return replacements?.[color?.toLowerCase()] || color;
-}
-function toArray(x) {
-  return Array.isArray(x) ? x : [x];
-}
-async function normalizeGetter(p) {
-  return Promise.resolve(typeof p === "function" ? p() : p).then((r) => r.default || r);
-}
-function isPlainLang(lang) {
-  return !lang || ["plaintext", "txt", "text", "plain"].includes(lang);
-}
-function isSpecialLang(lang) {
-  return lang === "ansi" || isPlainLang(lang);
-}
-function isNoneTheme(theme) {
-  return theme === "none";
-}
-function isSpecialTheme(theme) {
-  return isNoneTheme(theme);
-}
-function addClassToHast(node, className) {
-  var _a;
-  if (!className)
-    return node;
-  node.properties || (node.properties = {});
-  (_a = node.properties).class || (_a.class = []);
-  if (typeof node.properties.class === "string")
-    node.properties.class = node.properties.class.split(/\s+/g);
-  if (!Array.isArray(node.properties.class))
-    node.properties.class = [];
-  const targets = Array.isArray(className) ? className : className.split(/\s+/g);
-  for (const c of targets) {
-    if (c && !node.properties.class.includes(c))
-      node.properties.class.push(c);
-  }
-  return node;
-}
-function splitLines(code, preserveEnding = false) {
-  const parts = code.split(/(\r?\n)/g);
-  let index = 0;
-  const lines = [];
-  for (let i = 0; i < parts.length; i += 2) {
-    const line = preserveEnding ? parts[i] + (parts[i + 1] || "") : parts[i];
-    lines.push([line, index]);
-    index += parts[i].length;
-    index += parts[i + 1]?.length || 0;
-  }
-  return lines;
-}
-function createPositionConverter(code) {
-  const lines = splitLines(code, true).map(([line]) => line);
-  function indexToPos(index) {
-    if (index === code.length) {
-      return {
-        line: lines.length - 1,
-        character: lines[lines.length - 1].length
-      };
-    }
-    let character = index;
-    let line = 0;
-    for (const lineText of lines) {
-      if (character < lineText.length)
-        break;
-      character -= lineText.length;
-      line++;
-    }
-    return { line, character };
-  }
-  function posToIndex(line, character) {
-    let index = 0;
-    for (let i = 0; i < line; i++)
-      index += lines[i].length;
-    index += character;
-    return index;
-  }
-  return {
-    lines,
-    indexToPos,
-    posToIndex
-  };
-}
-const DEFAULT_COLOR_LIGHT_DARK = "light-dark()";
-const COLOR_KEYS = ["color", "background-color"];
-function splitToken(token, offsets) {
-  let lastOffset = 0;
-  const tokens = [];
-  for (const offset of offsets) {
-    if (offset > lastOffset) {
-      tokens.push({
-        ...token,
-        content: token.content.slice(lastOffset, offset),
-        offset: token.offset + lastOffset
-      });
-    }
-    lastOffset = offset;
-  }
-  if (lastOffset < token.content.length) {
-    tokens.push({
-      ...token,
-      content: token.content.slice(lastOffset),
-      offset: token.offset + lastOffset
-    });
-  }
-  return tokens;
-}
-function splitTokens(tokens, breakpoints) {
-  const sorted = Array.from(breakpoints instanceof Set ? breakpoints : new Set(breakpoints)).sort((a, b) => a - b);
-  if (!sorted.length)
-    return tokens;
-  return tokens.map((line) => {
-    return line.flatMap((token) => {
-      const breakpointsInToken = sorted.filter((i) => token.offset < i && i < token.offset + token.content.length).map((i) => i - token.offset).sort((a, b) => a - b);
-      if (!breakpointsInToken.length)
-        return token;
-      return splitToken(token, breakpointsInToken);
-    });
-  });
-}
-function flatTokenVariants(merged, variantsOrder, cssVariablePrefix, defaultColor, colorsRendering = "css-vars") {
-  const token = {
-    content: merged.content,
-    explanation: merged.explanation,
-    offset: merged.offset
-  };
-  const styles = variantsOrder.map((t) => getTokenStyleObject(merged.variants[t]));
-  const styleKeys = new Set(styles.flatMap((t) => Object.keys(t)));
-  const mergedStyles = {};
-  const varKey = (idx, key) => {
-    const keyName = key === "color" ? "" : key === "background-color" ? "-bg" : `-${key}`;
-    return cssVariablePrefix + variantsOrder[idx] + (key === "color" ? "" : keyName);
-  };
-  styles.forEach((cur, idx) => {
-    for (const key of styleKeys) {
-      const value = cur[key] || "inherit";
-      if (idx === 0 && defaultColor && COLOR_KEYS.includes(key)) {
-        if (defaultColor === DEFAULT_COLOR_LIGHT_DARK && styles.length > 1) {
-          const lightIndex = variantsOrder.findIndex((t) => t === "light");
-          const darkIndex = variantsOrder.findIndex((t) => t === "dark");
-          if (lightIndex === -1 || darkIndex === -1)
-            throw new ShikiError$1('When using `defaultColor: "light-dark()"`, you must provide both `light` and `dark` themes');
-          const lightValue = styles[lightIndex][key] || "inherit";
-          const darkValue = styles[darkIndex][key] || "inherit";
-          mergedStyles[key] = `light-dark(${lightValue}, ${darkValue})`;
-          if (colorsRendering === "css-vars")
-            mergedStyles[varKey(idx, key)] = value;
-        } else {
-          mergedStyles[key] = value;
-        }
-      } else {
-        if (colorsRendering === "css-vars")
-          mergedStyles[varKey(idx, key)] = value;
-      }
-    }
-  });
-  token.htmlStyle = mergedStyles;
-  return token;
-}
-function getTokenStyleObject(token) {
-  const styles = {};
-  if (token.color)
-    styles.color = token.color;
-  if (token.bgColor)
-    styles["background-color"] = token.bgColor;
-  if (token.fontStyle) {
-    if (token.fontStyle & FontStyle.Italic)
-      styles["font-style"] = "italic";
-    if (token.fontStyle & FontStyle.Bold)
-      styles["font-weight"] = "bold";
-    const decorations2 = [];
-    if (token.fontStyle & FontStyle.Underline)
-      decorations2.push("underline");
-    if (token.fontStyle & FontStyle.Strikethrough)
-      decorations2.push("line-through");
-    if (decorations2.length)
-      styles["text-decoration"] = decorations2.join(" ");
-  }
-  return styles;
-}
-function stringifyTokenStyle(token) {
-  if (typeof token === "string")
-    return token;
-  return Object.entries(token).map(([key, value]) => `${key}:${value}`).join(";");
-}
-const _grammarStateMap = /* @__PURE__ */ new WeakMap();
-function setLastGrammarStateToMap(keys, state) {
-  _grammarStateMap.set(keys, state);
-}
-function getLastGrammarStateFromMap(keys) {
-  return _grammarStateMap.get(keys);
-}
-class GrammarState {
-  constructor(...args) {
-    /**
-     * Theme to Stack mapping
-     */
-    __publicField(this, "_stacks", {});
-    __publicField(this, "lang");
-    if (args.length === 2) {
-      const [stacksMap, lang] = args;
-      this.lang = lang;
-      this._stacks = stacksMap;
-    } else {
-      const [stack, lang, theme] = args;
-      this.lang = lang;
-      this._stacks = { [theme]: stack };
-    }
-  }
-  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(lang, themes) {
-    return new GrammarState(
-      Object.fromEntries(toArray(themes).map((theme) => [theme, INITIAL])),
-      lang
-    );
-  }
-  /**
-   * Get the internal stack object.
-   * @internal
-   */
-  getInternalStack(theme = this.theme) {
-    return this._stacks[theme];
-  }
-  getScopes(theme = this.theme) {
-    return getScopes(this._stacks[theme]);
-  }
-  toJSON() {
-    return {
-      lang: this.lang,
-      theme: this.theme,
-      themes: this.themes,
-      scopes: this.getScopes()
-    };
-  }
-}
-function getScopes(stack) {
-  const scopes = [];
-  const visited = /* @__PURE__ */ new Set();
-  function pushScope(stack2) {
-    if (visited.has(stack2))
-      return;
-    visited.add(stack2);
-    const name = stack2?.nameScopesList?.scopeName;
-    if (name)
-      scopes.push(name);
-    if (stack2.parent)
-      pushScope(stack2.parent);
-  }
-  pushScope(stack);
-  return scopes;
-}
-function getGrammarStack(state, theme) {
-  if (!(state instanceof GrammarState))
-    throw new ShikiError$1("Invalid grammar state");
-  return state.getInternalStack(theme);
-}
-function transformerDecorations() {
-  const map = /* @__PURE__ */ new WeakMap();
-  function getContext(shiki) {
-    if (!map.has(shiki.meta)) {
-      let normalizePosition = function(p) {
-        if (typeof p === "number") {
-          if (p < 0 || p > shiki.source.length)
-            throw new ShikiError$1(`Invalid decoration offset: ${p}. Code length: ${shiki.source.length}`);
-          return {
-            ...converter.indexToPos(p),
-            offset: p
-          };
-        } else {
-          const line = converter.lines[p.line];
-          if (line === void 0)
-            throw new ShikiError$1(`Invalid decoration position ${JSON.stringify(p)}. Lines length: ${converter.lines.length}`);
-          if (p.character < 0 || p.character > line.length)
-            throw new ShikiError$1(`Invalid decoration position ${JSON.stringify(p)}. Line ${p.line} length: ${line.length}`);
-          return {
-            ...p,
-            offset: converter.posToIndex(p.line, p.character)
-          };
-        }
-      };
-      const converter = createPositionConverter(shiki.source);
-      const decorations2 = (shiki.options.decorations || []).map((d) => ({
-        ...d,
-        start: normalizePosition(d.start),
-        end: normalizePosition(d.end)
-      }));
-      verifyIntersections(decorations2);
-      map.set(shiki.meta, {
-        decorations: decorations2,
-        converter,
-        source: shiki.source
-      });
-    }
-    return map.get(shiki.meta);
-  }
-  return {
-    name: "shiki:decorations",
-    tokens(tokens) {
-      if (!this.options.decorations?.length)
-        return;
-      const ctx = getContext(this);
-      const breakpoints = ctx.decorations.flatMap((d) => [d.start.offset, d.end.offset]);
-      const splitted = splitTokens(tokens, breakpoints);
-      return splitted;
-    },
-    code(codeEl) {
-      if (!this.options.decorations?.length)
-        return;
-      const ctx = getContext(this);
-      const lines = Array.from(codeEl.children).filter((i) => i.type === "element" && i.tagName === "span");
-      if (lines.length !== ctx.converter.lines.length)
-        throw new ShikiError$1(`Number of lines in code element (${lines.length}) does not match the number of lines in the source (${ctx.converter.lines.length}). Failed to apply decorations.`);
-      function applyLineSection(line, start, end, decoration) {
-        const lineEl = lines[line];
-        let text = "";
-        let startIndex = -1;
-        let endIndex = -1;
-        if (start === 0)
-          startIndex = 0;
-        if (end === 0)
-          endIndex = 0;
-        if (end === Number.POSITIVE_INFINITY)
-          endIndex = lineEl.children.length;
-        if (startIndex === -1 || endIndex === -1) {
-          for (let i = 0; i < lineEl.children.length; i++) {
-            text += stringify(lineEl.children[i]);
-            if (startIndex === -1 && text.length === start)
-              startIndex = i + 1;
-            if (endIndex === -1 && text.length === end)
-              endIndex = i + 1;
-          }
-        }
-        if (startIndex === -1)
-          throw new ShikiError$1(`Failed to find start index for decoration ${JSON.stringify(decoration.start)}`);
-        if (endIndex === -1)
-          throw new ShikiError$1(`Failed to find end index for decoration ${JSON.stringify(decoration.end)}`);
-        const children = lineEl.children.slice(startIndex, endIndex);
-        if (!decoration.alwaysWrap && children.length === lineEl.children.length) {
-          applyDecoration(lineEl, decoration, "line");
-        } else if (!decoration.alwaysWrap && children.length === 1 && children[0].type === "element") {
-          applyDecoration(children[0], decoration, "token");
-        } else {
-          const wrapper = {
-            type: "element",
-            tagName: "span",
-            properties: {},
-            children
-          };
-          applyDecoration(wrapper, decoration, "wrapper");
-          lineEl.children.splice(startIndex, children.length, wrapper);
-        }
-      }
-      function applyLine(line, decoration) {
-        lines[line] = applyDecoration(lines[line], decoration, "line");
-      }
-      function applyDecoration(el, decoration, type) {
-        const properties = decoration.properties || {};
-        const transform = decoration.transform || ((i) => i);
-        el.tagName = decoration.tagName || "span";
-        el.properties = {
-          ...el.properties,
-          ...properties,
-          class: el.properties.class
-        };
-        if (decoration.properties?.class)
-          addClassToHast(el, decoration.properties.class);
-        el = transform(el, type) || el;
-        return el;
-      }
-      const lineApplies = [];
-      const sorted = ctx.decorations.sort((a, b) => b.start.offset - a.start.offset || a.end.offset - b.end.offset);
-      for (const decoration of sorted) {
-        const { start, end } = decoration;
-        if (start.line === end.line) {
-          applyLineSection(start.line, start.character, end.character, decoration);
-        } else if (start.line < end.line) {
-          applyLineSection(start.line, start.character, Number.POSITIVE_INFINITY, decoration);
-          for (let i = start.line + 1; i < end.line; i++)
-            lineApplies.unshift(() => applyLine(i, decoration));
-          applyLineSection(end.line, 0, end.character, decoration);
-        }
-      }
-      lineApplies.forEach((i) => i());
-    }
-  };
-}
-function verifyIntersections(items) {
-  for (let i = 0; i < items.length; i++) {
-    const foo = items[i];
-    if (foo.start.offset > foo.end.offset)
-      throw new ShikiError$1(`Invalid decoration range: ${JSON.stringify(foo.start)} - ${JSON.stringify(foo.end)}`);
-    for (let j = i + 1; j < items.length; j++) {
-      const bar = items[j];
-      const isFooHasBarStart = foo.start.offset <= bar.start.offset && bar.start.offset < foo.end.offset;
-      const isFooHasBarEnd = foo.start.offset < bar.end.offset && bar.end.offset <= foo.end.offset;
-      const isBarHasFooStart = bar.start.offset <= foo.start.offset && foo.start.offset < bar.end.offset;
-      const isBarHasFooEnd = bar.start.offset < foo.end.offset && foo.end.offset <= bar.end.offset;
-      if (isFooHasBarStart || isFooHasBarEnd || isBarHasFooStart || isBarHasFooEnd) {
-        if (isFooHasBarStart && isFooHasBarEnd)
-          continue;
-        if (isBarHasFooStart && isBarHasFooEnd)
-          continue;
-        if (isBarHasFooStart && foo.start.offset === foo.end.offset)
-          continue;
-        if (isFooHasBarEnd && bar.start.offset === bar.end.offset)
-          continue;
-        throw new ShikiError$1(`Decorations ${JSON.stringify(foo.start)} and ${JSON.stringify(bar.start)} intersect.`);
-      }
-    }
-  }
-}
-function stringify(el) {
-  if (el.type === "text")
-    return el.value;
-  if (el.type === "element")
-    return el.children.map(stringify).join("");
-  return "";
-}
-const builtInTransformers = [
-  /* @__PURE__ */ transformerDecorations()
-];
-function getTransformers(options) {
-  return [
-    ...options.transformers || [],
-    ...builtInTransformers
-  ];
-}
-var namedColors = [
-  "black",
-  "red",
-  "green",
-  "yellow",
-  "blue",
-  "magenta",
-  "cyan",
-  "white",
-  "brightBlack",
-  "brightRed",
-  "brightGreen",
-  "brightYellow",
-  "brightBlue",
-  "brightMagenta",
-  "brightCyan",
-  "brightWhite"
-];
-var decorations = {
-  1: "bold",
-  2: "dim",
-  3: "italic",
-  4: "underline",
-  7: "reverse",
-  8: "hidden",
-  9: "strikethrough"
-};
-function findSequence(value, position) {
-  const nextEscape = value.indexOf("\x1B", position);
-  if (nextEscape !== -1) {
-    if (value[nextEscape + 1] === "[") {
-      const nextClose = value.indexOf("m", nextEscape);
-      if (nextClose !== -1) {
-        return {
-          sequence: value.substring(nextEscape + 2, nextClose).split(";"),
-          startPosition: nextEscape,
-          position: nextClose + 1
-        };
-      }
-    }
-  }
-  return {
-    position: value.length
-  };
-}
-function parseColor(sequence) {
-  const colorMode = sequence.shift();
-  if (colorMode === "2") {
-    const rgb = sequence.splice(0, 3).map((x) => Number.parseInt(x));
-    if (rgb.length !== 3 || rgb.some((x) => Number.isNaN(x)))
-      return;
-    return {
-      type: "rgb",
-      rgb
-    };
-  } else if (colorMode === "5") {
-    const index = sequence.shift();
-    if (index) {
-      return { type: "table", index: Number(index) };
-    }
-  }
-}
-function parseSequence(sequence) {
-  const commands = [];
-  while (sequence.length > 0) {
-    const code = sequence.shift();
-    if (!code)
-      continue;
-    const codeInt = Number.parseInt(code);
-    if (Number.isNaN(codeInt))
-      continue;
-    if (codeInt === 0) {
-      commands.push({ type: "resetAll" });
-    } else if (codeInt <= 9) {
-      const decoration = decorations[codeInt];
-      if (decoration) {
-        commands.push({
-          type: "setDecoration",
-          value: decorations[codeInt]
-        });
-      }
-    } else if (codeInt <= 29) {
-      const decoration = decorations[codeInt - 20];
-      if (decoration) {
-        commands.push({
-          type: "resetDecoration",
-          value: decoration
-        });
-        if (decoration === "dim") {
-          commands.push({
-            type: "resetDecoration",
-            value: "bold"
-          });
-        }
-      }
-    } else if (codeInt <= 37) {
-      commands.push({
-        type: "setForegroundColor",
-        value: { type: "named", name: namedColors[codeInt - 30] }
-      });
-    } else if (codeInt === 38) {
-      const color = parseColor(sequence);
-      if (color) {
-        commands.push({
-          type: "setForegroundColor",
-          value: color
-        });
-      }
-    } else if (codeInt === 39) {
-      commands.push({
-        type: "resetForegroundColor"
-      });
-    } else if (codeInt <= 47) {
-      commands.push({
-        type: "setBackgroundColor",
-        value: { type: "named", name: namedColors[codeInt - 40] }
-      });
-    } else if (codeInt === 48) {
-      const color = parseColor(sequence);
-      if (color) {
-        commands.push({
-          type: "setBackgroundColor",
-          value: color
-        });
-      }
-    } else if (codeInt === 49) {
-      commands.push({
-        type: "resetBackgroundColor"
-      });
-    } else if (codeInt === 53) {
-      commands.push({
-        type: "setDecoration",
-        value: "overline"
-      });
-    } else if (codeInt === 55) {
-      commands.push({
-        type: "resetDecoration",
-        value: "overline"
-      });
-    } else if (codeInt >= 90 && codeInt <= 97) {
-      commands.push({
-        type: "setForegroundColor",
-        value: { type: "named", name: namedColors[codeInt - 90 + 8] }
-      });
-    } else if (codeInt >= 100 && codeInt <= 107) {
-      commands.push({
-        type: "setBackgroundColor",
-        value: { type: "named", name: namedColors[codeInt - 100 + 8] }
-      });
-    }
-  }
-  return commands;
-}
-function createAnsiSequenceParser() {
-  let foreground = null;
-  let background = null;
-  let decorations2 = /* @__PURE__ */ new Set();
-  return {
-    parse(value) {
-      const tokens = [];
-      let position = 0;
-      do {
-        const findResult = findSequence(value, position);
-        const text = findResult.sequence ? value.substring(position, findResult.startPosition) : value.substring(position);
-        if (text.length > 0) {
-          tokens.push({
-            value: text,
-            foreground,
-            background,
-            decorations: new Set(decorations2)
-          });
-        }
-        if (findResult.sequence) {
-          const commands = parseSequence(findResult.sequence);
-          for (const styleToken of commands) {
-            if (styleToken.type === "resetAll") {
-              foreground = null;
-              background = null;
-              decorations2.clear();
-            } else if (styleToken.type === "resetForegroundColor") {
-              foreground = null;
-            } else if (styleToken.type === "resetBackgroundColor") {
-              background = null;
-            } else if (styleToken.type === "resetDecoration") {
-              decorations2.delete(styleToken.value);
-            }
-          }
-          for (const styleToken of commands) {
-            if (styleToken.type === "setForegroundColor") {
-              foreground = styleToken.value;
-            } else if (styleToken.type === "setBackgroundColor") {
-              background = styleToken.value;
-            } else if (styleToken.type === "setDecoration") {
-              decorations2.add(styleToken.value);
-            }
-          }
-        }
-        position = findResult.position;
-      } while (position < value.length);
-      return tokens;
-    }
-  };
-}
-var defaultNamedColorsMap = {
-  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 createColorPalette(namedColorsMap = defaultNamedColorsMap) {
-  function namedColor(name) {
-    return namedColorsMap[name];
-  }
-  function rgbColor(rgb) {
-    return `#${rgb.map((x) => Math.max(0, Math.min(x, 255)).toString(16).padStart(2, "0")).join("")}`;
-  }
-  let colorTable;
-  function getColorTable() {
-    if (colorTable) {
-      return colorTable;
-    }
-    colorTable = [];
-    for (let i = 0; i < namedColors.length; i++) {
-      colorTable.push(namedColor(namedColors[i]));
-    }
-    let levels = [0, 95, 135, 175, 215, 255];
-    for (let r = 0; r < 6; r++) {
-      for (let g = 0; g < 6; g++) {
-        for (let b = 0; b < 6; b++) {
-          colorTable.push(rgbColor([levels[r], levels[g], levels[b]]));
-        }
-      }
-    }
-    let level = 8;
-    for (let i = 0; i < 24; i++, level += 10) {
-      colorTable.push(rgbColor([level, level, level]));
-    }
-    return colorTable;
-  }
-  function tableColor(index) {
-    return getColorTable()[index];
-  }
-  function value(color) {
-    switch (color.type) {
-      case "named":
-        return namedColor(color.name);
-      case "rgb":
-        return rgbColor(color.rgb);
-      case "table":
-        return tableColor(color.index);
-    }
-  }
-  return {
-    value
-  };
-}
-function tokenizeAnsiWithTheme(theme, fileContents, options) {
-  const colorReplacements = resolveColorReplacements(theme, options);
-  const lines = splitLines(fileContents);
-  const colorPalette = createColorPalette(
-    Object.fromEntries(
-      namedColors.map((name) => [
-        name,
-        theme.colors?.[`terminal.ansi${name[0].toUpperCase()}${name.substring(1)}`]
-      ])
-    )
-  );
-  const parser = createAnsiSequenceParser();
-  return lines.map(
-    (line) => parser.parse(line[0]).map((token) => {
-      let color;
-      let bgColor;
-      if (token.decorations.has("reverse")) {
-        color = token.background ? colorPalette.value(token.background) : theme.bg;
-        bgColor = token.foreground ? colorPalette.value(token.foreground) : theme.fg;
-      } else {
-        color = token.foreground ? colorPalette.value(token.foreground) : theme.fg;
-        bgColor = token.background ? colorPalette.value(token.background) : void 0;
-      }
-      color = applyColorReplacements(color, colorReplacements);
-      bgColor = applyColorReplacements(bgColor, colorReplacements);
-      if (token.decorations.has("dim"))
-        color = dimColor(color);
-      let fontStyle = FontStyle.None;
-      if (token.decorations.has("bold"))
-        fontStyle |= FontStyle.Bold;
-      if (token.decorations.has("italic"))
-        fontStyle |= FontStyle.Italic;
-      if (token.decorations.has("underline"))
-        fontStyle |= FontStyle.Underline;
-      if (token.decorations.has("strikethrough"))
-        fontStyle |= FontStyle.Strikethrough;
-      return {
-        content: token.value,
-        offset: line[1],
-        // TODO: more accurate offset? might need to fork ansi-sequence-parser
-        color,
-        bgColor,
-        fontStyle
-      };
-    })
-  );
-}
-function dimColor(color) {
-  const hexMatch = color.match(/#([0-9a-f]{3})([0-9a-f]{3})?([0-9a-f]{2})?/);
-  if (hexMatch) {
-    if (hexMatch[3]) {
-      const alpha = Math.round(Number.parseInt(hexMatch[3], 16) / 2).toString(16).padStart(2, "0");
-      return `#${hexMatch[1]}${hexMatch[2]}${alpha}`;
-    } else if (hexMatch[2]) {
-      return `#${hexMatch[1]}${hexMatch[2]}80`;
-    } else {
-      return `#${Array.from(hexMatch[1]).map((x) => `${x}${x}`).join("")}80`;
-    }
-  }
-  const cssVarMatch = color.match(/var\((--[\w-]+-ansi-[\w-]+)\)/);
-  if (cssVarMatch)
-    return `var(${cssVarMatch[1]}-dim)`;
-  return color;
-}
-function codeToTokensBase(internal, code, options = {}) {
-  const {
-    lang = "text",
-    theme: themeName = internal.getLoadedThemes()[0]
-  } = options;
-  if (isPlainLang(lang) || isNoneTheme(themeName))
-    return splitLines(code).map((line) => [{ content: line[0], offset: line[1] }]);
-  const { theme, colorMap } = internal.setTheme(themeName);
-  if (lang === "ansi")
-    return tokenizeAnsiWithTheme(theme, code, options);
-  const _grammar = internal.getLanguage(lang);
-  if (options.grammarState) {
-    if (options.grammarState.lang !== _grammar.name) {
-      throw new ShikiError$1(`Grammar state language "${options.grammarState.lang}" does not match highlight language "${_grammar.name}"`);
-    }
-    if (!options.grammarState.themes.includes(theme.name)) {
-      throw new ShikiError$1(`Grammar state themes "${options.grammarState.themes}" do not contain highlight theme "${theme.name}"`);
-    }
-  }
-  return tokenizeWithTheme(code, _grammar, theme, colorMap, options);
-}
-function getLastGrammarState(...args) {
-  if (args.length === 2) {
-    return getLastGrammarStateFromMap(args[1]);
-  }
-  const [internal, code, options = {}] = args;
-  const {
-    lang = "text",
-    theme: themeName = internal.getLoadedThemes()[0]
-  } = options;
-  if (isPlainLang(lang) || isNoneTheme(themeName))
-    throw new ShikiError$1("Plain language does not have grammar state");
-  if (lang === "ansi")
-    throw new ShikiError$1("ANSI language does not have grammar state");
-  const { theme, colorMap } = internal.setTheme(themeName);
-  const _grammar = internal.getLanguage(lang);
-  return new GrammarState(
-    _tokenizeWithTheme(code, _grammar, theme, colorMap, options).stateStack,
-    _grammar.name,
-    theme.name
-  );
-}
-function tokenizeWithTheme(code, grammar, theme, colorMap, options) {
-  const result = _tokenizeWithTheme(code, grammar, theme, colorMap, options);
-  const grammarState = new GrammarState(
-    _tokenizeWithTheme(code, grammar, theme, colorMap, options).stateStack,
-    grammar.name,
-    theme.name
-  );
-  setLastGrammarStateToMap(result.tokens, grammarState);
-  return result.tokens;
-}
-function _tokenizeWithTheme(code, grammar, theme, colorMap, options) {
-  const colorReplacements = resolveColorReplacements(theme, options);
-  const {
-    tokenizeMaxLineLength = 0,
-    tokenizeTimeLimit = 500
-  } = options;
-  const lines = splitLines(code);
-  let stateStack = options.grammarState ? getGrammarStack(options.grammarState, theme.name) ?? INITIAL : options.grammarContextCode != null ? _tokenizeWithTheme(
-    options.grammarContextCode,
-    grammar,
-    theme,
-    colorMap,
-    {
-      ...options,
-      grammarState: void 0,
-      grammarContextCode: void 0
-    }
-  ).stateStack : INITIAL;
-  let actual = [];
-  const final = [];
-  for (let i = 0, len = lines.length; i < len; i++) {
-    const [line, lineOffset] = lines[i];
-    if (line === "") {
-      actual = [];
-      final.push([]);
-      continue;
-    }
-    if (tokenizeMaxLineLength > 0 && line.length >= tokenizeMaxLineLength) {
-      actual = [];
-      final.push([{
-        content: line,
-        offset: lineOffset,
-        color: "",
-        fontStyle: 0
-      }]);
-      continue;
-    }
-    let resultWithScopes;
-    let tokensWithScopes;
-    let tokensWithScopesIndex;
-    if (options.includeExplanation) {
-      resultWithScopes = grammar.tokenizeLine(line, stateStack, tokenizeTimeLimit);
-      tokensWithScopes = resultWithScopes.tokens;
-      tokensWithScopesIndex = 0;
-    }
-    const result = grammar.tokenizeLine2(line, stateStack, tokenizeTimeLimit);
-    const tokensLength = result.tokens.length / 2;
-    for (let j = 0; j < tokensLength; j++) {
-      const startIndex = result.tokens[2 * j];
-      const nextStartIndex = j + 1 < tokensLength ? result.tokens[2 * j + 2] : line.length;
-      if (startIndex === nextStartIndex)
-        continue;
-      const metadata = result.tokens[2 * j + 1];
-      const color = applyColorReplacements(
-        colorMap[EncodedTokenMetadata.getForeground(metadata)],
-        colorReplacements
-      );
-      const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);
-      const token = {
-        content: line.substring(startIndex, nextStartIndex),
-        offset: lineOffset + startIndex,
-        color,
-        fontStyle
-      };
-      if (options.includeExplanation) {
-        const themeSettingsSelectors = [];
-        if (options.includeExplanation !== "scopeName") {
-          for (const setting of theme.settings) {
-            let selectors;
-            switch (typeof setting.scope) {
-              case "string":
-                selectors = setting.scope.split(/,/).map((scope) => scope.trim());
-                break;
-              case "object":
-                selectors = setting.scope;
-                break;
-              default:
-                continue;
-            }
-            themeSettingsSelectors.push({
-              settings: setting,
-              selectors: selectors.map((selector) => selector.split(/ /))
-            });
-          }
-        }
-        token.explanation = [];
-        let offset = 0;
-        while (startIndex + offset < nextStartIndex) {
-          const tokenWithScopes = tokensWithScopes[tokensWithScopesIndex];
-          const tokenWithScopesText = line.substring(
-            tokenWithScopes.startIndex,
-            tokenWithScopes.endIndex
-          );
-          offset += tokenWithScopesText.length;
-          token.explanation.push({
-            content: tokenWithScopesText,
-            scopes: options.includeExplanation === "scopeName" ? explainThemeScopesNameOnly(
-              tokenWithScopes.scopes
-            ) : explainThemeScopesFull(
-              themeSettingsSelectors,
-              tokenWithScopes.scopes
-            )
-          });
-          tokensWithScopesIndex += 1;
-        }
-      }
-      actual.push(token);
-    }
-    final.push(actual);
-    actual = [];
-    stateStack = result.ruleStack;
-  }
-  return {
-    tokens: final,
-    stateStack
-  };
-}
-function explainThemeScopesNameOnly(scopes) {
-  return scopes.map((scope) => ({ scopeName: scope }));
-}
-function explainThemeScopesFull(themeSelectors, scopes) {
-  const result = [];
-  for (let i = 0, len = scopes.length; i < len; i++) {
-    const scope = scopes[i];
-    result[i] = {
-      scopeName: scope,
-      themeMatches: explainThemeScope(themeSelectors, scope, scopes.slice(0, i))
-    };
-  }
-  return result;
-}
-function matchesOne(selector, scope) {
-  return selector === scope || scope.substring(0, selector.length) === selector && scope[selector.length] === ".";
-}
-function matches(selectors, scope, parentScopes) {
-  if (!matchesOne(selectors[selectors.length - 1], scope))
-    return false;
-  let selectorParentIndex = selectors.length - 2;
-  let parentIndex = parentScopes.length - 1;
-  while (selectorParentIndex >= 0 && parentIndex >= 0) {
-    if (matchesOne(selectors[selectorParentIndex], parentScopes[parentIndex]))
-      selectorParentIndex -= 1;
-    parentIndex -= 1;
-  }
-  if (selectorParentIndex === -1)
-    return true;
-  return false;
-}
-function explainThemeScope(themeSettingsSelectors, scope, parentScopes) {
-  const result = [];
-  for (const { selectors, settings } of themeSettingsSelectors) {
-    for (const selectorPieces of selectors) {
-      if (matches(selectorPieces, scope, parentScopes)) {
-        result.push(settings);
-        break;
-      }
-    }
-  }
-  return result;
-}
-function codeToTokensWithThemes(internal, code, options) {
-  const themes = Object.entries(options.themes).filter((i) => i[1]).map((i) => ({ color: i[0], theme: i[1] }));
-  const themedTokens = themes.map((t) => {
-    const tokens2 = codeToTokensBase(internal, code, {
-      ...options,
-      theme: t.theme
-    });
-    const state = getLastGrammarStateFromMap(tokens2);
-    const theme = typeof t.theme === "string" ? t.theme : t.theme.name;
-    return {
-      tokens: tokens2,
-      state,
-      theme
-    };
-  });
-  const tokens = syncThemesTokenization(
-    ...themedTokens.map((i) => i.tokens)
-  );
-  const mergedTokens = tokens[0].map(
-    (line, lineIdx) => line.map((_token, tokenIdx) => {
-      const mergedToken = {
-        content: _token.content,
-        variants: {},
-        offset: _token.offset
-      };
-      if ("includeExplanation" in options && options.includeExplanation) {
-        mergedToken.explanation = _token.explanation;
-      }
-      tokens.forEach((t, themeIdx) => {
-        const {
-          content: _,
-          explanation: __,
-          offset: ___,
-          ...styles
-        } = t[lineIdx][tokenIdx];
-        mergedToken.variants[themes[themeIdx].color] = styles;
-      });
-      return mergedToken;
-    })
-  );
-  const mergedGrammarState = themedTokens[0].state ? new GrammarState(
-    Object.fromEntries(themedTokens.map((s) => [s.theme, s.state?.getInternalStack(s.theme)])),
-    themedTokens[0].state.lang
-  ) : void 0;
-  if (mergedGrammarState)
-    setLastGrammarStateToMap(mergedTokens, mergedGrammarState);
-  return mergedTokens;
-}
-function syncThemesTokenization(...themes) {
-  const outThemes = themes.map(() => []);
-  const count = themes.length;
-  for (let i = 0; i < themes[0].length; i++) {
-    const lines = themes.map((t) => t[i]);
-    const outLines = outThemes.map(() => []);
-    outThemes.forEach((t, i2) => t.push(outLines[i2]));
-    const indexes = lines.map(() => 0);
-    const current = lines.map((l) => l[0]);
-    while (current.every((t) => t)) {
-      const minLength = Math.min(...current.map((t) => t.content.length));
-      for (let n = 0; n < count; n++) {
-        const token = current[n];
-        if (token.content.length === minLength) {
-          outLines[n].push(token);
-          indexes[n] += 1;
-          current[n] = lines[n][indexes[n]];
-        } else {
-          outLines[n].push({
-            ...token,
-            content: token.content.slice(0, minLength)
-          });
-          current[n] = {
-            ...token,
-            content: token.content.slice(minLength),
-            offset: token.offset + minLength
-          };
-        }
-      }
-    }
-  }
-  return outThemes;
-}
-function codeToTokens(internal, code, options) {
-  let bg;
-  let fg;
-  let tokens;
-  let themeName;
-  let rootStyle;
-  let grammarState;
-  if ("themes" in options) {
-    const {
-      defaultColor = "light",
-      cssVariablePrefix = "--shiki-",
-      colorsRendering = "css-vars"
-    } = options;
-    const themes = Object.entries(options.themes).filter((i) => i[1]).map((i) => ({ color: i[0], theme: i[1] })).sort((a, b) => a.color === defaultColor ? -1 : b.color === defaultColor ? 1 : 0);
-    if (themes.length === 0)
-      throw new ShikiError$1("`themes` option must not be empty");
-    const themeTokens = codeToTokensWithThemes(
-      internal,
-      code,
-      options
-    );
-    grammarState = getLastGrammarStateFromMap(themeTokens);
-    if (defaultColor && DEFAULT_COLOR_LIGHT_DARK !== defaultColor && !themes.find((t) => t.color === defaultColor))
-      throw new ShikiError$1(`\`themes\` option must contain the defaultColor key \`${defaultColor}\``);
-    const themeRegs = themes.map((t) => internal.getTheme(t.theme));
-    const themesOrder = themes.map((t) => t.color);
-    tokens = themeTokens.map((line) => line.map((token) => flatTokenVariants(token, themesOrder, cssVariablePrefix, defaultColor, colorsRendering)));
-    if (grammarState)
-      setLastGrammarStateToMap(tokens, grammarState);
-    const themeColorReplacements = themes.map((t) => resolveColorReplacements(t.theme, options));
-    fg = mapThemeColors(themes, themeRegs, themeColorReplacements, cssVariablePrefix, defaultColor, "fg", colorsRendering);
-    bg = mapThemeColors(themes, themeRegs, themeColorReplacements, cssVariablePrefix, defaultColor, "bg", colorsRendering);
-    themeName = `shiki-themes ${themeRegs.map((t) => t.name).join(" ")}`;
-    rootStyle = defaultColor ? void 0 : [fg, bg].join(";");
-  } else if ("theme" in options) {
-    const colorReplacements = resolveColorReplacements(options.theme, options);
-    tokens = codeToTokensBase(
-      internal,
-      code,
-      options
-    );
-    const _theme = internal.getTheme(options.theme);
-    bg = applyColorReplacements(_theme.bg, colorReplacements);
-    fg = applyColorReplacements(_theme.fg, colorReplacements);
-    themeName = _theme.name;
-    grammarState = getLastGrammarStateFromMap(tokens);
-  } else {
-    throw new ShikiError$1("Invalid options, either `theme` or `themes` must be provided");
-  }
-  return {
-    tokens,
-    fg,
-    bg,
-    themeName,
-    rootStyle,
-    grammarState
-  };
-}
-function mapThemeColors(themes, themeRegs, themeColorReplacements, cssVariablePrefix, defaultColor, property, colorsRendering) {
-  return themes.map((t, idx) => {
-    const value = applyColorReplacements(themeRegs[idx][property], themeColorReplacements[idx]) || "inherit";
-    const cssVar = `${cssVariablePrefix + t.color}${property === "bg" ? "-bg" : ""}:${value}`;
-    if (idx === 0 && defaultColor) {
-      if (defaultColor === DEFAULT_COLOR_LIGHT_DARK && themes.length > 1) {
-        const lightIndex = themes.findIndex((t2) => t2.color === "light");
-        const darkIndex = themes.findIndex((t2) => t2.color === "dark");
-        if (lightIndex === -1 || darkIndex === -1)
-          throw new ShikiError$1('When using `defaultColor: "light-dark()"`, you must provide both `light` and `dark` themes');
-        const lightValue = applyColorReplacements(themeRegs[lightIndex][property], themeColorReplacements[lightIndex]) || "inherit";
-        const darkValue = applyColorReplacements(themeRegs[darkIndex][property], themeColorReplacements[darkIndex]) || "inherit";
-        return `light-dark(${lightValue}, ${darkValue});${cssVar}`;
-      }
-      return value;
-    }
-    if (colorsRendering === "css-vars") {
-      return cssVar;
-    }
-    return null;
-  }).filter((i) => !!i).join(";");
-}
-function codeToHast(internal, code, options, transformerContext = {
-  meta: {},
-  options,
-  codeToHast: (_code, _options) => codeToHast(internal, _code, _options),
-  codeToTokens: (_code, _options) => codeToTokens(internal, _code, _options)
-}) {
-  let input = code;
-  for (const transformer of getTransformers(options))
-    input = transformer.preprocess?.call(transformerContext, input, options) || input;
-  let {
-    tokens,
-    fg,
-    bg,
-    themeName,
-    rootStyle,
-    grammarState
-  } = codeToTokens(internal, input, options);
-  const {
-    mergeWhitespaces = true,
-    mergeSameStyleTokens = false
-  } = options;
-  if (mergeWhitespaces === true)
-    tokens = mergeWhitespaceTokens(tokens);
-  else if (mergeWhitespaces === "never")
-    tokens = splitWhitespaceTokens(tokens);
-  if (mergeSameStyleTokens) {
-    tokens = mergeAdjacentStyledTokens(tokens);
-  }
-  const contextSource = {
-    ...transformerContext,
-    get source() {
-      return input;
-    }
-  };
-  for (const transformer of getTransformers(options))
-    tokens = transformer.tokens?.call(contextSource, tokens) || tokens;
-  return tokensToHast(
-    tokens,
-    {
-      ...options,
-      fg,
-      bg,
-      themeName,
-      rootStyle
-    },
-    contextSource,
-    grammarState
-  );
-}
-function tokensToHast(tokens, options, transformerContext, grammarState = getLastGrammarStateFromMap(tokens)) {
-  const transformers = getTransformers(options);
-  const lines = [];
-  const root = {
-    type: "root",
-    children: []
-  };
-  const {
-    structure = "classic",
-    tabindex = "0"
-  } = options;
-  let preNode = {
-    type: "element",
-    tagName: "pre",
-    properties: {
-      class: `shiki ${options.themeName || ""}`,
-      style: options.rootStyle || `background-color:${options.bg};color:${options.fg}`,
-      ...tabindex !== false && tabindex != null ? {
-        tabindex: tabindex.toString()
-      } : {},
-      ...Object.fromEntries(
-        Array.from(
-          Object.entries(options.meta || {})
-        ).filter(([key]) => !key.startsWith("_"))
-      )
-    },
-    children: []
-  };
-  let codeNode = {
-    type: "element",
-    tagName: "code",
-    properties: {},
-    children: lines
-  };
-  const lineNodes = [];
-  const context = {
-    ...transformerContext,
-    structure,
-    addClassToHast,
-    get source() {
-      return transformerContext.source;
-    },
-    get tokens() {
-      return tokens;
-    },
-    get options() {
-      return options;
-    },
-    get root() {
-      return root;
-    },
-    get pre() {
-      return preNode;
-    },
-    get code() {
-      return codeNode;
-    },
-    get lines() {
-      return lineNodes;
-    }
-  };
-  tokens.forEach((line, idx) => {
-    if (idx) {
-      if (structure === "inline")
-        root.children.push({ type: "element", tagName: "br", properties: {}, children: [] });
-      else if (structure === "classic")
-        lines.push({ type: "text", value: "\n" });
-    }
-    let lineNode = {
-      type: "element",
-      tagName: "span",
-      properties: { class: "line" },
-      children: []
-    };
-    let col = 0;
-    for (const token of line) {
-      let tokenNode = {
-        type: "element",
-        tagName: "span",
-        properties: {
-          ...token.htmlAttrs
-        },
-        children: [{ type: "text", value: token.content }]
-      };
-      const style = stringifyTokenStyle(token.htmlStyle || getTokenStyleObject(token));
-      if (style)
-        tokenNode.properties.style = style;
-      for (const transformer of transformers)
-        tokenNode = transformer?.span?.call(context, tokenNode, idx + 1, col, lineNode, token) || tokenNode;
-      if (structure === "inline")
-        root.children.push(tokenNode);
-      else if (structure === "classic")
-        lineNode.children.push(tokenNode);
-      col += token.content.length;
-    }
-    if (structure === "classic") {
-      for (const transformer of transformers)
-        lineNode = transformer?.line?.call(context, lineNode, idx + 1) || lineNode;
-      lineNodes.push(lineNode);
-      lines.push(lineNode);
-    }
-  });
-  if (structure === "classic") {
-    for (const transformer of transformers)
-      codeNode = transformer?.code?.call(context, codeNode) || codeNode;
-    preNode.children.push(codeNode);
-    for (const transformer of transformers)
-      preNode = transformer?.pre?.call(context, preNode) || preNode;
-    root.children.push(preNode);
-  }
-  let result = root;
-  for (const transformer of transformers)
-    result = transformer?.root?.call(context, result) || result;
-  if (grammarState)
-    setLastGrammarStateToMap(result, grammarState);
-  return result;
-}
-function mergeWhitespaceTokens(tokens) {
-  return tokens.map((line) => {
-    const newLine = [];
-    let carryOnContent = "";
-    let firstOffset = 0;
-    line.forEach((token, idx) => {
-      const isDecorated = token.fontStyle && (token.fontStyle & FontStyle.Underline || token.fontStyle & FontStyle.Strikethrough);
-      const couldMerge = !isDecorated;
-      if (couldMerge && token.content.match(/^\s+$/) && line[idx + 1]) {
-        if (!firstOffset)
-          firstOffset = token.offset;
-        carryOnContent += token.content;
-      } else {
-        if (carryOnContent) {
-          if (couldMerge) {
-            newLine.push({
-              ...token,
-              offset: firstOffset,
-              content: carryOnContent + token.content
-            });
-          } else {
-            newLine.push(
-              {
-                content: carryOnContent,
-                offset: firstOffset
-              },
-              token
-            );
-          }
-          firstOffset = 0;
-          carryOnContent = "";
-        } else {
-          newLine.push(token);
-        }
-      }
-    });
-    return newLine;
-  });
-}
-function splitWhitespaceTokens(tokens) {
-  return tokens.map((line) => {
-    return line.flatMap((token) => {
-      if (token.content.match(/^\s+$/))
-        return token;
-      const match = token.content.match(/^(\s*)(.*?)(\s*)$/);
-      if (!match)
-        return token;
-      const [, leading, content, trailing] = match;
-      if (!leading && !trailing)
-        return token;
-      const expanded = [{
-        ...token,
-        offset: token.offset + leading.length,
-        content
-      }];
-      if (leading) {
-        expanded.unshift({
-          content: leading,
-          offset: token.offset
-        });
-      }
-      if (trailing) {
-        expanded.push({
-          content: trailing,
-          offset: token.offset + leading.length + content.length
-        });
-      }
-      return expanded;
-    });
-  });
-}
-function mergeAdjacentStyledTokens(tokens) {
-  return tokens.map((line) => {
-    const newLine = [];
-    for (const token of line) {
-      if (newLine.length === 0) {
-        newLine.push({ ...token });
-        continue;
-      }
-      const prevToken = newLine[newLine.length - 1];
-      const prevStyle = stringifyTokenStyle(prevToken.htmlStyle || getTokenStyleObject(prevToken));
-      const currentStyle = stringifyTokenStyle(token.htmlStyle || getTokenStyleObject(token));
-      const isPrevDecorated = prevToken.fontStyle && (prevToken.fontStyle & FontStyle.Underline || prevToken.fontStyle & FontStyle.Strikethrough);
-      const isDecorated = token.fontStyle && (token.fontStyle & FontStyle.Underline || token.fontStyle & FontStyle.Strikethrough);
-      if (!isPrevDecorated && !isDecorated && prevStyle === currentStyle) {
-        prevToken.content += token.content;
-      } else {
-        newLine.push({ ...token });
-      }
-    }
-    return newLine;
-  });
-}
-const hastToHtml = toHtml;
-function codeToHtml(internal, code, options) {
-  const context = {
-    meta: {},
-    options,
-    codeToHast: (_code, _options) => codeToHast(internal, _code, _options),
-    codeToTokens: (_code, _options) => codeToTokens(internal, _code, _options)
-  };
-  let result = hastToHtml(codeToHast(internal, code, options, context));
-  for (const transformer of getTransformers(options))
-    result = transformer.postprocess?.call(context, result, options) || result;
-  return result;
-}
-const VSCODE_FALLBACK_EDITOR_FG = { light: "#333333", dark: "#bbbbbb" };
-const VSCODE_FALLBACK_EDITOR_BG = { light: "#fffffe", dark: "#1e1e1e" };
-const RESOLVED_KEY = "__shiki_resolved";
-function normalizeTheme(rawTheme) {
-  if (rawTheme?.[RESOLVED_KEY])
-    return rawTheme;
-  const theme = {
-    ...rawTheme
-  };
-  if (theme.tokenColors && !theme.settings) {
-    theme.settings = theme.tokenColors;
-    delete theme.tokenColors;
-  }
-  theme.type || (theme.type = "dark");
-  theme.colorReplacements = { ...theme.colorReplacements };
-  theme.settings || (theme.settings = []);
-  let { bg, fg } = theme;
-  if (!bg || !fg) {
-    const globalSetting = theme.settings ? theme.settings.find((s) => !s.name && !s.scope) : void 0;
-    if (globalSetting?.settings?.foreground)
-      fg = globalSetting.settings.foreground;
-    if (globalSetting?.settings?.background)
-      bg = globalSetting.settings.background;
-    if (!fg && theme?.colors?.["editor.foreground"])
-      fg = theme.colors["editor.foreground"];
-    if (!bg && theme?.colors?.["editor.background"])
-      bg = theme.colors["editor.background"];
-    if (!fg)
-      fg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
-    if (!bg)
-      bg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
-    theme.fg = fg;
-    theme.bg = bg;
-  }
-  if (!(theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope)) {
-    theme.settings.unshift({
-      settings: {
-        foreground: theme.fg,
-        background: theme.bg
-      }
-    });
-  }
-  let replacementCount = 0;
-  const replacementMap = /* @__PURE__ */ new Map();
-  function getReplacementColor(value) {
-    if (replacementMap.has(value))
-      return replacementMap.get(value);
-    replacementCount += 1;
-    const hex = `#${replacementCount.toString(16).padStart(8, "0").toLowerCase()}`;
-    if (theme.colorReplacements?.[`#${hex}`])
-      return getReplacementColor(value);
-    replacementMap.set(value, hex);
-    return hex;
-  }
-  theme.settings = theme.settings.map((setting) => {
-    const replaceFg = setting.settings?.foreground && !setting.settings.foreground.startsWith("#");
-    const replaceBg = setting.settings?.background && !setting.settings.background.startsWith("#");
-    if (!replaceFg && !replaceBg)
-      return setting;
-    const clone = {
-      ...setting,
-      settings: {
-        ...setting.settings
-      }
-    };
-    if (replaceFg) {
-      const replacement = getReplacementColor(setting.settings.foreground);
-      theme.colorReplacements[replacement] = setting.settings.foreground;
-      clone.settings.foreground = replacement;
-    }
-    if (replaceBg) {
-      const replacement = getReplacementColor(setting.settings.background);
-      theme.colorReplacements[replacement] = setting.settings.background;
-      clone.settings.background = replacement;
-    }
-    return clone;
-  });
-  for (const key of Object.keys(theme.colors || {})) {
-    if (key === "editor.foreground" || key === "editor.background" || key.startsWith("terminal.ansi")) {
-      if (!theme.colors[key]?.startsWith("#")) {
-        const replacement = getReplacementColor(theme.colors[key]);
-        theme.colorReplacements[replacement] = theme.colors[key];
-        theme.colors[key] = replacement;
-      }
-    }
-  }
-  Object.defineProperty(theme, RESOLVED_KEY, {
-    enumerable: false,
-    writable: false,
-    value: true
-  });
-  return theme;
-}
-async function resolveLangs(langs) {
-  return Array.from(new Set((await Promise.all(
-    langs.filter((l) => !isSpecialLang(l)).map(async (lang) => await normalizeGetter(lang).then((r) => Array.isArray(r) ? r : [r]))
-  )).flat()));
-}
-async function resolveThemes(themes) {
-  const resolved = await Promise.all(
-    themes.map(
-      async (theme) => isSpecialTheme(theme) ? null : normalizeTheme(await normalizeGetter(theme))
-    )
-  );
-  return resolved.filter((i) => !!i);
-}
-let _emitDeprecation = 3;
-function warnDeprecated(message, version = 3) {
-  if (version > _emitDeprecation)
-    return;
-  {
-    console.trace(`[SHIKI DEPRECATE]: ${message}`);
-  }
-}
-class ShikiError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ShikiError";
-  }
-}
-class Registry extends Registry$1 {
-  constructor(_resolver, _themes, _langs, _alias = {}) {
-    super(_resolver);
-    __publicField(this, "_resolvedThemes", /* @__PURE__ */ new Map());
-    __publicField(this, "_resolvedGrammars", /* @__PURE__ */ new Map());
-    __publicField(this, "_langMap", /* @__PURE__ */ new Map());
-    __publicField(this, "_langGraph", /* @__PURE__ */ new Map());
-    __publicField(this, "_textmateThemeCache", /* @__PURE__ */ new WeakMap());
-    __publicField(this, "_loadedThemesCache", null);
-    __publicField(this, "_loadedLanguagesCache", null);
-    this._resolver = _resolver;
-    this._themes = _themes;
-    this._langs = _langs;
-    this._alias = _alias;
-    this._themes.map((t) => this.loadTheme(t));
-    this.loadLanguages(this._langs);
-  }
-  getTheme(theme) {
-    if (typeof theme === "string")
-      return this._resolvedThemes.get(theme);
-    else
-      return this.loadTheme(theme);
-  }
-  loadTheme(theme) {
-    const _theme = normalizeTheme(theme);
-    if (_theme.name) {
-      this._resolvedThemes.set(_theme.name, _theme);
-      this._loadedThemesCache = null;
-    }
-    return _theme;
-  }
-  getLoadedThemes() {
-    if (!this._loadedThemesCache)
-      this._loadedThemesCache = [...this._resolvedThemes.keys()];
-    return 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(theme) {
-    let textmateTheme = this._textmateThemeCache.get(theme);
-    if (!textmateTheme) {
-      textmateTheme = Theme.createFromRawTheme(theme);
-      this._textmateThemeCache.set(theme, textmateTheme);
-    }
-    this._syncRegistry.setTheme(textmateTheme);
-  }
-  getGrammar(name) {
-    if (this._alias[name]) {
-      const resolved = /* @__PURE__ */ new Set([name]);
-      while (this._alias[name]) {
-        name = this._alias[name];
-        if (resolved.has(name))
-          throw new ShikiError(`Circular alias \`${Array.from(resolved).join(" -> ")} -> ${name}\``);
-        resolved.add(name);
-      }
-    }
-    return this._resolvedGrammars.get(name);
-  }
-  loadLanguage(lang) {
-    if (this.getGrammar(lang.name))
-      return;
-    const embeddedLazilyBy = new Set(
-      [...this._langMap.values()].filter((i) => i.embeddedLangsLazy?.includes(lang.name))
-    );
-    this._resolver.addLanguage(lang);
-    const grammarConfig = {
-      balancedBracketSelectors: lang.balancedBracketSelectors || ["*"],
-      unbalancedBracketSelectors: lang.unbalancedBracketSelectors || []
-    };
-    this._syncRegistry._rawGrammars.set(lang.scopeName, lang);
-    const g = this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
-    g.name = lang.name;
-    this._resolvedGrammars.set(lang.name, g);
-    if (lang.aliases) {
-      lang.aliases.forEach((alias) => {
-        this._alias[alias] = lang.name;
-      });
-    }
-    this._loadedLanguagesCache = null;
-    if (embeddedLazilyBy.size) {
-      for (const e of embeddedLazilyBy) {
-        this._resolvedGrammars.delete(e.name);
-        this._loadedLanguagesCache = null;
-        this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
-        this._syncRegistry?._grammars?.delete(e.scopeName);
-        this.loadLanguage(this._langMap.get(e.name));
-      }
-    }
-  }
-  dispose() {
-    super.dispose();
-    this._resolvedThemes.clear();
-    this._resolvedGrammars.clear();
-    this._langMap.clear();
-    this._langGraph.clear();
-    this._loadedThemesCache = null;
-  }
-  loadLanguages(langs) {
-    for (const lang of langs)
-      this.resolveEmbeddedLanguages(lang);
-    const langsGraphArray = Array.from(this._langGraph.entries());
-    const missingLangs = langsGraphArray.filter(([_, lang]) => !lang);
-    if (missingLangs.length) {
-      const dependents = langsGraphArray.filter(([_, lang]) => lang && lang.embeddedLangs?.some((l) => missingLangs.map(([name]) => name).includes(l))).filter((lang) => !missingLangs.includes(lang));
-      throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(", ")}, required by ${dependents.map(([name]) => `\`${name}\``).join(", ")}`);
-    }
-    for (const [_, lang] of langsGraphArray)
-      this._resolver.addLanguage(lang);
-    for (const [_, lang] of langsGraphArray)
-      this.loadLanguage(lang);
-  }
-  getLoadedLanguages() {
-    if (!this._loadedLanguagesCache) {
-      this._loadedLanguagesCache = [
-        .../* @__PURE__ */ new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])
-      ];
-    }
-    return this._loadedLanguagesCache;
-  }
-  resolveEmbeddedLanguages(lang) {
-    this._langMap.set(lang.name, lang);
-    this._langGraph.set(lang.name, lang);
-    if (lang.embeddedLangs) {
-      for (const embeddedLang of lang.embeddedLangs)
-        this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));
-    }
-  }
-}
-class Resolver {
-  constructor(engine, langs) {
-    __publicField(this, "_langs", /* @__PURE__ */ new Map());
-    __publicField(this, "_scopeToLang", /* @__PURE__ */ new Map());
-    __publicField(this, "_injections", /* @__PURE__ */ new Map());
-    __publicField(this, "_onigLib");
-    this._onigLib = {
-      createOnigScanner: (patterns) => engine.createScanner(patterns),
-      createOnigString: (s) => engine.createString(s)
-    };
-    langs.forEach((i) => this.addLanguage(i));
-  }
-  get onigLib() {
-    return this._onigLib;
-  }
-  getLangRegistration(langIdOrAlias) {
-    return this._langs.get(langIdOrAlias);
-  }
-  loadGrammar(scopeName) {
-    return this._scopeToLang.get(scopeName);
-  }
-  addLanguage(l) {
-    this._langs.set(l.name, l);
-    if (l.aliases) {
-      l.aliases.forEach((a) => {
-        this._langs.set(a, l);
-      });
-    }
-    this._scopeToLang.set(l.scopeName, l);
-    if (l.injectTo) {
-      l.injectTo.forEach((i) => {
-        if (!this._injections.get(i))
-          this._injections.set(i, []);
-        this._injections.get(i).push(l.scopeName);
-      });
-    }
-  }
-  getInjections(scopeName) {
-    const scopeParts = scopeName.split(".");
-    let injections = [];
-    for (let i = 1; i <= scopeParts.length; i++) {
-      const subScopeName = scopeParts.slice(0, i).join(".");
-      injections = [...injections, ...this._injections.get(subScopeName) || []];
-    }
-    return injections;
-  }
-}
-let instancesCount = 0;
-function createShikiInternalSync(options) {
-  instancesCount += 1;
-  if (options.warnings !== false && instancesCount >= 10 && instancesCount % 10 === 0)
-    console.warn(`[Shiki] ${instancesCount} 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 isDisposed = false;
-  if (!options.engine)
-    throw new ShikiError("`engine` option is required for synchronous mode");
-  const langs = (options.langs || []).flat(1);
-  const themes = (options.themes || []).flat(1).map(normalizeTheme);
-  const resolver = new Resolver(options.engine, langs);
-  const _registry = new Registry(resolver, themes, langs, options.langAlias);
-  let _lastTheme;
-  function getLanguage(name) {
-    ensureNotDisposed();
-    const _lang = _registry.getGrammar(typeof name === "string" ? name : name.name);
-    if (!_lang)
-      throw new ShikiError(`Language \`${name}\` not found, you may need to load it first`);
-    return _lang;
-  }
-  function getTheme(name) {
-    if (name === "none")
-      return { bg: "", fg: "", name: "none", settings: [], type: "dark" };
-    ensureNotDisposed();
-    const _theme = _registry.getTheme(name);
-    if (!_theme)
-      throw new ShikiError(`Theme \`${name}\` not found, you may need to load it first`);
-    return _theme;
-  }
-  function setTheme(name) {
-    ensureNotDisposed();
-    const theme = getTheme(name);
-    if (_lastTheme !== name) {
-      _registry.setTheme(theme);
-      _lastTheme = name;
-    }
-    const colorMap = _registry.getColorMap();
-    return {
-      theme,
-      colorMap
-    };
-  }
-  function getLoadedThemes() {
-    ensureNotDisposed();
-    return _registry.getLoadedThemes();
-  }
-  function getLoadedLanguages() {
-    ensureNotDisposed();
-    return _registry.getLoadedLanguages();
-  }
-  function loadLanguageSync(...langs2) {
-    ensureNotDisposed();
-    _registry.loadLanguages(langs2.flat(1));
-  }
-  async function loadLanguage(...langs2) {
-    return loadLanguageSync(await resolveLangs(langs2));
-  }
-  function loadThemeSync(...themes2) {
-    ensureNotDisposed();
-    for (const theme of themes2.flat(1)) {
-      _registry.loadTheme(theme);
-    }
-  }
-  async function loadTheme(...themes2) {
-    ensureNotDisposed();
-    return loadThemeSync(await resolveThemes(themes2));
-  }
-  function ensureNotDisposed() {
-    if (isDisposed)
-      throw new ShikiError("Shiki instance has been disposed");
-  }
-  function dispose() {
-    if (isDisposed)
-      return;
-    isDisposed = true;
-    _registry.dispose();
-    instancesCount -= 1;
-  }
-  return {
-    setTheme,
-    getTheme,
-    getLanguage,
-    getLoadedThemes,
-    getLoadedLanguages,
-    loadLanguage,
-    loadLanguageSync,
-    loadTheme,
-    loadThemeSync,
-    dispose,
-    [Symbol.dispose]: dispose
-  };
-}
-async function createShikiInternal(options) {
-  if (!options.engine) {
-    warnDeprecated("`engine` option is required. Use `createOnigurumaEngine` or `createJavaScriptRegexEngine` to create an engine.");
-  }
-  const [
-    themes,
-    langs,
-    engine
-  ] = await Promise.all([
-    resolveThemes(options.themes || []),
-    resolveLangs(options.langs || []),
-    options.engine
-  ]);
-  return createShikiInternalSync({
-    ...options,
-    themes,
-    langs,
-    engine
-  });
-}
-async function createHighlighterCore(options) {
-  const internal = await createShikiInternal(options);
-  return {
-    getLastGrammarState: (...args) => getLastGrammarState(internal, ...args),
-    codeToTokensBase: (code, options2) => codeToTokensBase(internal, code, options2),
-    codeToTokensWithThemes: (code, options2) => codeToTokensWithThemes(internal, code, options2),
-    codeToTokens: (code, options2) => codeToTokens(internal, code, options2),
-    codeToHast: (code, options2) => codeToHast(internal, code, options2),
-    codeToHtml: (code, options2) => codeToHtml(internal, code, options2),
-    getBundledLanguages: () => ({}),
-    getBundledThemes: () => ({}),
-    ...internal,
-    getInternalContext: () => internal
-  };
-}
-function createdBundledHighlighter(options) {
-  const bundledLanguages = options.langs;
-  const bundledThemes = options.themes;
-  const engine = options.engine;
-  async function createHighlighter(options2) {
-    function resolveLang(lang) {
-      if (typeof lang === "string") {
-        if (isSpecialLang(lang))
-          return [];
-        lang = options2.langAlias?.[lang] || lang;
-        const bundle = bundledLanguages[lang];
-        if (!bundle)
-          throw new ShikiError$1(`Language \`${lang}\` is not included in this bundle. You may want to load it from external source.`);
-        return bundle;
-      }
-      return lang;
-    }
-    function resolveTheme(theme) {
-      if (isSpecialTheme(theme))
-        return "none";
-      if (typeof theme === "string") {
-        const bundle = bundledThemes[theme];
-        if (!bundle)
-          throw new ShikiError$1(`Theme \`${theme}\` is not included in this bundle. You may want to load it from external source.`);
-        return bundle;
-      }
-      return theme;
-    }
-    const _themes = (options2.themes ?? []).map((i) => resolveTheme(i));
-    const langs = (options2.langs ?? []).map((i) => resolveLang(i));
-    const core = await createHighlighterCore({
-      engine: options2.engine ?? engine(),
-      ...options2,
-      themes: _themes,
-      langs
-    });
-    return {
-      ...core,
-      loadLanguage(...langs2) {
-        return core.loadLanguage(...langs2.map(resolveLang));
-      },
-      loadTheme(...themes) {
-        return core.loadTheme(...themes.map(resolveTheme));
-      },
-      getBundledLanguages() {
-        return bundledLanguages;
-      },
-      getBundledThemes() {
-        return bundledThemes;
-      }
-    };
-  }
-  return createHighlighter;
-}
-export {
-  ShikiError$1 as ShikiError,
-  addClassToHast,
-  applyColorReplacements,
-  codeToHast,
-  codeToHtml,
-  codeToTokens,
-  codeToTokensBase,
-  codeToTokensWithThemes,
-  createHighlighterCore,
-  createPositionConverter,
-  createShikiInternal,
-  createShikiInternalSync,
-  createdBundledHighlighter,
-  flatTokenVariants,
-  getTokenStyleObject,
-  hastToHtml,
-  isNoneTheme,
-  isPlainLang,
-  isSpecialLang,
-  isSpecialTheme,
-  normalizeGetter,
-  normalizeTheme,
-  resolveColorReplacements,
-  splitLines,
-  splitToken,
-  splitTokens,
-  stringifyTokenStyle,
-  toArray,
-  tokenizeAnsiWithTheme,
-  tokenizeWithTheme,
-  tokensToHast,
-  transformerDecorations,
-  warnDeprecated
-};