@qwik.dev/devtools 0.2.8 → 0.3.0-beta.3

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

@@ -1,1137 +1,1112 @@
 import { ShikiError } from "../../../../../@shikijs_types@4.0.2/node_modules/@shikijs/types/dist/index.qwik.mjs";
+import { isSpecialTheme, isSpecialLang, createShikiPrimitiveAsync, codeToTokensWithThemes, getLastGrammarState, getLastGrammarStateFromMap, setLastGrammarStateToMap, resolveColorReplacements, applyColorReplacements, isPlainLang, isNoneTheme, codeToTokensBase as codeToTokensBase$1, splitLines } from "../../../../../@shikijs_primitive@4.0.2/node_modules/@shikijs/primitive/dist/index.qwik.mjs";
+import { createShikiPrimitive, normalizeGetter, normalizeTheme, toArray, tokenizeWithTheme } from "../../../../../@shikijs_primitive@4.0.2/node_modules/@shikijs/primitive/dist/index.qwik.mjs";
 import { FontStyle } from "../../../../../@shikijs_vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.qwik.mjs";
-import { applyColorReplacements, codeToTokensBase as codeToTokensBase$1, codeToTokensWithThemes, createShikiPrimitiveAsync, getLastGrammarState, getLastGrammarStateFromMap, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, resolveColorReplacements, setLastGrammarStateToMap, splitLines } from "../../../../../@shikijs_primitive@4.0.2/node_modules/@shikijs/primitive/dist/index.qwik.mjs";
 import { toHtml } from "../../../../../hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/index.qwik.mjs";
-//#region ../../node_modules/.pnpm/@shikijs+core@4.0.2/node_modules/@shikijs/core/dist/index.mjs
-/**
-* Utility to append class to a hast node
-*
-* If the `property.class` is a string, it will be splitted by space and converted to an array.
-*/
 function addClassToHast(node, className) {
-	var _node$properties;
-	if (!className) return node;
-	node.properties || (node.properties = {});
-	(_node$properties = node.properties).class || (_node$properties.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;
+  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;
 }
-/**
-* Creates a converter between index and position in a code block.
-*
-* Overflow/underflow are unchecked.
-*/
 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 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
+  };
 }
-/**
-* Guess embedded languages from given code and highlighter.
-*
-* When highlighter is provided, only bundled languages will be included.
-*
-* @param code - The code string to analyze
-* @param _lang - The primary language of the code (currently unused)
-* @param highlighter - Optional highlighter instance to validate languages
-* @returns Array of detected language identifiers
-*
-* @example
-* ```ts
-* // Detects 'javascript' from Vue SFC
-* guessEmbeddedLanguages('<script lang="javascript">')
-*
-* // Detects 'python' from markdown code block
-* guessEmbeddedLanguages('```python\nprint("hi")\n```')
-* ```
-*/
 function guessEmbeddedLanguages(code, _lang, highlighter) {
-	const langs = /* @__PURE__ */ new Set();
-	for (const match of code.matchAll(/:?lang=["']([^"']+)["']/g)) {
-		const lang = match[1].toLowerCase().trim();
-		if (lang) langs.add(lang);
-	}
-	for (const match of code.matchAll(/(?:```|~~~)([\w-]+)/g)) {
-		const lang = match[1].toLowerCase().trim();
-		if (lang) langs.add(lang);
-	}
-	for (const match of code.matchAll(/\\begin\{([\w-]+)\}/g)) {
-		const lang = match[1].toLowerCase().trim();
-		if (lang) langs.add(lang);
-	}
-	for (const match of code.matchAll(/<script\s+(?:type|lang)=["']([^"']+)["']/gi)) {
-		const fullType = match[1].toLowerCase().trim();
-		const lang = fullType.includes("/") ? fullType.split("/").pop() : fullType;
-		if (lang) langs.add(lang);
-	}
-	if (!highlighter) return Array.from(langs);
-	const bundle = highlighter.getBundledLanguages();
-	return Array.from(langs).filter((l) => l && bundle[l]);
+  const langs = /* @__PURE__ */ new Set();
+  for (const match of code.matchAll(/:?lang=["']([^"']+)["']/g)) {
+    const lang = match[1].toLowerCase().trim();
+    if (lang) langs.add(lang);
+  }
+  for (const match of code.matchAll(/(?:```|~~~)([\w-]+)/g)) {
+    const lang = match[1].toLowerCase().trim();
+    if (lang) langs.add(lang);
+  }
+  for (const match of code.matchAll(/\\begin\{([\w-]+)\}/g)) {
+    const lang = match[1].toLowerCase().trim();
+    if (lang) langs.add(lang);
+  }
+  for (const match of code.matchAll(/<script\s+(?:type|lang)=["']([^"']+)["']/gi)) {
+    const fullType = match[1].toLowerCase().trim();
+    const lang = fullType.includes("/") ? fullType.split("/").pop() : fullType;
+    if (lang) langs.add(lang);
+  }
+  if (!highlighter) return Array.from(langs);
+  const bundle = highlighter.getBundledLanguages();
+  return Array.from(langs).filter((l) => l && bundle[l]);
 }
-var DEFAULT_COLOR_LIGHT_DARK = "light-dark()";
-var COLOR_KEYS = ["color", "background-color"];
-/**
-* Split a token into multiple tokens by given offsets.
-*
-* The offsets are relative to the token, and should be sorted.
-*/
+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;
+  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;
 }
-/**
-* Split 2D tokens array by given breakpoints.
-*/
 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);
-		});
-	});
+  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("When using `defaultColor: \"light-dark()\"`, you must provide both `light` and `dark` themes");
-				mergedStyles[key] = `light-dark(${styles[lightIndex][key] || "inherit"}, ${styles[darkIndex][key] || "inherit"})`;
-				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;
+  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('When using `defaultColor: "light-dark()"`, you must provide both `light` and `dark` themes');
+        mergedStyles[key] = `light-dark(${styles[lightIndex][key] || "inherit"}, ${styles[darkIndex][key] || "inherit"})`;
+        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 decorations = [];
-		if (token.fontStyle & FontStyle.Underline) decorations.push("underline");
-		if (token.fontStyle & FontStyle.Strikethrough) decorations.push("line-through");
-		if (decorations.length) styles["text-decoration"] = decorations.join(" ");
-	}
-	return styles;
+  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(";");
+  if (typeof token === "string") return token;
+  return Object.entries(token).map(([key, value]) => `${key}:${value}`).join(";");
 }
-/**
-* A built-in transformer to add decorations to the highlighted code.
-*/
 function transformerDecorations() {
-	const map = /* @__PURE__ */ new WeakMap();
-	function getContext(shiki) {
-		if (!map.has(shiki.meta)) {
-			const converter = createPositionConverter(shiki.source);
-			function normalizePosition(p) {
-				if (typeof p === "number") {
-					if (p < 0 || p > shiki.source.length) throw new ShikiError(`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(`Invalid decoration position ${JSON.stringify(p)}. Lines length: ${converter.lines.length}`);
-					let character = p.character;
-					if (character < 0) character = line.length + character;
-					if (character < 0 || character > line.length) throw new ShikiError(`Invalid decoration position ${JSON.stringify(p)}. Line ${p.line} length: ${line.length}`);
-					return {
-						...p,
-						character,
-						offset: converter.posToIndex(p.line, character)
-					};
-				}
-			}
-			const decorations = (shiki.options.decorations || []).map((d) => ({
-				...d,
-				start: normalizePosition(d.start),
-				end: normalizePosition(d.end)
-			}));
-			verifyIntersections(decorations);
-			map.set(shiki.meta, {
-				decorations,
-				converter,
-				source: shiki.source
-			});
-		}
-		return map.get(shiki.meta);
-	}
-	return {
-		name: "shiki:decorations",
-		tokens(tokens) {
-			if (!this.options.decorations?.length) return;
-			return splitTokens(tokens, getContext(this).decorations.flatMap((d) => [d.start.offset, d.end.offset]));
-		},
-		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(`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(`Failed to find start index for decoration ${JSON.stringify(decoration.start)}`);
-				if (endIndex === -1) throw new ShikiError(`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());
-		}
-	};
+  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(`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(`Invalid decoration position ${JSON.stringify(p)}. Lines length: ${converter.lines.length}`);
+          let character = p.character;
+          if (character < 0) character = line.length + character;
+          if (character < 0 || character > line.length) throw new ShikiError(`Invalid decoration position ${JSON.stringify(p)}. Line ${p.line} length: ${line.length}`);
+          return {
+            ...p,
+            character,
+            offset: converter.posToIndex(p.line, 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;
+      return splitTokens(tokens, getContext(this).decorations.flatMap((d) => [d.start.offset, d.end.offset]));
+    },
+    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(`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(`Failed to find start index for decoration ${JSON.stringify(decoration.start)}`);
+        if (endIndex === -1) throw new ShikiError(`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(`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(`Decorations ${JSON.stringify(foo.start)} and ${JSON.stringify(bar.start)} intersect.`);
-			}
-		}
-	}
+  for (let i = 0; i < items.length; i++) {
+    const foo = items[i];
+    if (foo.start.offset > foo.end.offset) throw new ShikiError(`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(`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 "";
+  if (el.type === "text") return el.value;
+  if (el.type === "element") return el.children.map(stringify).join("");
+  return "";
 }
-var builtInTransformers = [/* @__PURE__ */ transformerDecorations()];
+const builtInTransformers = [/* @__PURE__ */ transformerDecorations()];
 function getTransformers(options) {
-	const transformers = sortTransformersByEnforcement(options.transformers || []);
-	return [
-		...transformers.pre,
-		...transformers.normal,
-		...transformers.post,
-		...builtInTransformers
-	];
+  const transformers = sortTransformersByEnforcement(options.transformers || []);
+  return [
+    ...transformers.pre,
+    ...transformers.normal,
+    ...transformers.post,
+    ...builtInTransformers
+  ];
 }
 function sortTransformersByEnforcement(transformers) {
-	const pre = [];
-	const post = [];
-	const normal = [];
-	for (const transformer of transformers) switch (transformer.enforce) {
-		case "pre":
-			pre.push(transformer);
-			break;
-		case "post":
-			post.push(transformer);
-			break;
-		default: normal.push(transformer);
-	}
-	return {
-		pre,
-		post,
-		normal
-	};
+  const pre = [];
+  const post = [];
+  const normal = [];
+  for (const transformer of transformers) switch (transformer.enforce) {
+    case "pre":
+      pre.push(transformer);
+      break;
+    case "post":
+      post.push(transformer);
+      break;
+    default:
+      normal.push(transformer);
+  }
+  return {
+    pre,
+    post,
+    normal
+  };
 }
 var namedColors = [
-	"black",
-	"red",
-	"green",
-	"yellow",
-	"blue",
-	"magenta",
-	"cyan",
-	"white",
-	"brightBlack",
-	"brightRed",
-	"brightGreen",
-	"brightYellow",
-	"brightBlue",
-	"brightMagenta",
-	"brightCyan",
-	"brightWhite"
+  "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"
+  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 };
+  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)
-		};
-	}
+  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) {
-			if (decorations[codeInt]) 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;
+  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) {
+      if (decorations[codeInt]) 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;
-	} };
+  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"
+  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 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 };
 }
-/**
-* Default ANSI palette (VSCode compatible fallbacks)
-* Used when the theme does not define terminal.ansi* colors.
-*/
-var defaultAnsiColors = {
-	black: "#000000",
-	red: "#cd3131",
-	green: "#0DBC79",
-	yellow: "#E5E510",
-	blue: "#2472C8",
-	magenta: "#BC3FBC",
-	cyan: "#11A8CD",
-	white: "#E5E5E5",
-	brightBlack: "#666666",
-	brightRed: "#F14C4C",
-	brightGreen: "#23D18B",
-	brightYellow: "#F5F543",
-	brightBlue: "#3B8EEA",
-	brightMagenta: "#D670D6",
-	brightCyan: "#29B8DB",
-	brightWhite: "#FFFFFF"
+const defaultAnsiColors = {
+  black: "#000000",
+  red: "#cd3131",
+  green: "#0DBC79",
+  yellow: "#E5E510",
+  blue: "#2472C8",
+  magenta: "#BC3FBC",
+  cyan: "#11A8CD",
+  white: "#E5E5E5",
+  brightBlack: "#666666",
+  brightRed: "#F14C4C",
+  brightGreen: "#23D18B",
+  brightYellow: "#F5F543",
+  brightBlue: "#3B8EEA",
+  brightMagenta: "#D670D6",
+  brightCyan: "#29B8DB",
+  brightWhite: "#FFFFFF"
 };
 function tokenizeAnsiWithTheme(theme, fileContents, options) {
-	const colorReplacements = resolveColorReplacements(theme, options);
-	const lines = splitLines(fileContents);
-	const colorPalette = createColorPalette(Object.fromEntries(namedColors.map((name) => {
-		const key = `terminal.ansi${name[0].toUpperCase()}${name.substring(1)}`;
-		return [name, theme.colors?.[key] || defaultAnsiColors[name]];
-	})));
-	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],
-			color,
-			bgColor,
-			fontStyle
-		};
-	}));
+  const colorReplacements = resolveColorReplacements(theme, options);
+  const lines = splitLines(fileContents);
+  const colorPalette = createColorPalette(Object.fromEntries(namedColors.map((name) => {
+    const key = `terminal.ansi${name[0].toUpperCase()}${name.substring(1)}`;
+    return [name, theme.colors?.[key] || defaultAnsiColors[name]];
+  })));
+  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],
+      color,
+      bgColor,
+      fontStyle
+    };
+  }));
 }
-/**
-* Adds 50% alpha to a hex color string or the "-dim" postfix to a CSS variable
-*/
 function dimColor(color) {
-	const hexMatch = color.match(/#([0-9a-f]{3,8})/i);
-	if (hexMatch) {
-		const hex = hexMatch[1];
-		if (hex.length === 8) {
-			const alpha = Math.round(Number.parseInt(hex.slice(6, 8), 16) / 2).toString(16).padStart(2, "0");
-			return `#${hex.slice(0, 6)}${alpha}`;
-		} else if (hex.length === 6) return `#${hex}80`;
-		else if (hex.length === 4) {
-			const r = hex[0];
-			const g = hex[1];
-			const b = hex[2];
-			const a = hex[3];
-			return `#${r}${r}${g}${g}${b}${b}${Math.round(Number.parseInt(`${a}${a}`, 16) / 2).toString(16).padStart(2, "0")}`;
-		} else if (hex.length === 3) {
-			const r = hex[0];
-			const g = hex[1];
-			const b = hex[2];
-			return `#${r}${r}${g}${g}${b}${b}80`;
-		}
-	}
-	const cssVarMatch = color.match(/var\((--[\w-]+-ansi-[\w-]+)\)/);
-	if (cssVarMatch) return `var(${cssVarMatch[1]}-dim)`;
-	return color;
+  const hexMatch = color.match(/#([0-9a-f]{3,8})/i);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    if (hex.length === 8) {
+      const alpha = Math.round(Number.parseInt(hex.slice(6, 8), 16) / 2).toString(16).padStart(2, "0");
+      return `#${hex.slice(0, 6)}${alpha}`;
+    } else if (hex.length === 6) return `#${hex}80`;
+    else if (hex.length === 4) {
+      const r = hex[0];
+      const g = hex[1];
+      const b = hex[2];
+      const a = hex[3];
+      return `#${r}${r}${g}${g}${b}${b}${Math.round(Number.parseInt(`${a}${a}`, 16) / 2).toString(16).padStart(2, "0")}`;
+    } else if (hex.length === 3) {
+      const r = hex[0];
+      const g = hex[1];
+      const b = hex[2];
+      return `#${r}${r}${g}${g}${b}${b}80`;
+    }
+  }
+  const cssVarMatch = color.match(/var\((--[\w-]+-ansi-[\w-]+)\)/);
+  if (cssVarMatch) return `var(${cssVarMatch[1]}-dim)`;
+  return color;
 }
-/**
-* Code to tokens, with a simple theme.
-* This wraps the tokenizer's implementation to add ANSI support.
-*/
 function codeToTokensBase(primitive, code, options = {}) {
-	const lang = primitive.resolveLangAlias(options.lang || "text");
-	const { theme: themeName = primitive.getLoadedThemes()[0] } = options;
-	if (!isPlainLang(lang) && !isNoneTheme(themeName) && lang === "ansi") {
-		const { theme } = primitive.setTheme(themeName);
-		return tokenizeAnsiWithTheme(theme, code, options);
-	}
-	return codeToTokensBase$1(primitive, code, options);
+  const lang = primitive.resolveLangAlias(options.lang || "text");
+  const { theme: themeName = primitive.getLoadedThemes()[0] } = options;
+  if (!isPlainLang(lang) && !isNoneTheme(themeName) && lang === "ansi") {
+    const { theme } = primitive.setTheme(themeName);
+    return tokenizeAnsiWithTheme(theme, code, options);
+  }
+  return codeToTokensBase$1(primitive, code, options);
 }
-/**
-* High-level code-to-tokens API.
-*
-* It will use `codeToTokensWithThemes` or `codeToTokensBase` based on the options.
-*/
 function codeToTokens(primitive, 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("`themes` option must not be empty");
-		const themeTokens = codeToTokensWithThemes(primitive, code, options, codeToTokensBase);
-		grammarState = getLastGrammarStateFromMap(themeTokens);
-		if (defaultColor && DEFAULT_COLOR_LIGHT_DARK !== defaultColor && !themes.find((t) => t.color === defaultColor)) throw new ShikiError(`\`themes\` option must contain the defaultColor key \`${defaultColor}\``);
-		const themeRegs = themes.map((t) => primitive.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(primitive, code, options);
-		const _theme = primitive.getTheme(options.theme);
-		bg = applyColorReplacements(_theme.bg, colorReplacements);
-		fg = applyColorReplacements(_theme.fg, colorReplacements);
-		themeName = _theme.name;
-		grammarState = getLastGrammarStateFromMap(tokens);
-	} else throw new ShikiError("Invalid options, either `theme` or `themes` must be provided");
-	return {
-		tokens,
-		fg,
-		bg,
-		themeName,
-		rootStyle,
-		grammarState
-	};
+  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("`themes` option must not be empty");
+    const themeTokens = codeToTokensWithThemes(primitive, code, options, codeToTokensBase);
+    grammarState = getLastGrammarStateFromMap(themeTokens);
+    if (defaultColor && DEFAULT_COLOR_LIGHT_DARK !== defaultColor && !themes.find((t) => t.color === defaultColor)) throw new ShikiError(`\`themes\` option must contain the defaultColor key \`${defaultColor}\``);
+    const themeRegs = themes.map((t) => primitive.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(primitive, code, options);
+    const _theme = primitive.getTheme(options.theme);
+    bg = applyColorReplacements(_theme.bg, colorReplacements);
+    fg = applyColorReplacements(_theme.fg, colorReplacements);
+    themeName = _theme.name;
+    grammarState = getLastGrammarStateFromMap(tokens);
+  } else throw new ShikiError("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((t) => t.color === "light");
-				const darkIndex = themes.findIndex((t) => t.color === "dark");
-				if (lightIndex === -1 || darkIndex === -1) throw new ShikiError("When using `defaultColor: \"light-dark()\"`, you must provide both `light` and `dark` themes");
-				return `light-dark(${applyColorReplacements(themeRegs[lightIndex][property], themeColorReplacements[lightIndex]) || "inherit"}, ${applyColorReplacements(themeRegs[darkIndex][property], themeColorReplacements[darkIndex]) || "inherit"});${cssVar}`;
-			}
-			return value;
-		}
-		if (colorsRendering === "css-vars") return cssVar;
-		return null;
-	}).filter((i) => !!i).join(";");
+  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('When using `defaultColor: "light-dark()"`, you must provide both `light` and `dark` themes');
+        return `light-dark(${applyColorReplacements(themeRegs[lightIndex][property], themeColorReplacements[lightIndex]) || "inherit"}, ${applyColorReplacements(themeRegs[darkIndex][property], themeColorReplacements[darkIndex]) || "inherit"});${cssVar}`;
+      }
+      return value;
+    }
+    if (colorsRendering === "css-vars") return cssVar;
+    return null;
+  }).filter((i) => !!i).join(";");
 }
 function codeToHast(primitive, code, options, transformerContext = {
-	meta: {},
-	options,
-	codeToHast: (_code, _options) => codeToHast(primitive, _code, _options),
-	codeToTokens: (_code, _options) => codeToTokens(primitive, _code, _options)
+  meta: {},
+  options,
+  codeToHast: (_code, _options) => codeToHast(primitive, _code, _options),
+  codeToTokens: (_code, _options) => codeToTokens(primitive, _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(primitive, 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: options.rootStyle === false ? false : options.rootStyle ?? rootStyle
-	}, contextSource, grammarState);
+  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(primitive, 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: options.rootStyle === false ? false : options.rootStyle ?? 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;
-	const properties = { class: `shiki ${options.themeName || ""}` };
-	if (options.rootStyle !== false) if (options.rootStyle != null) properties.style = options.rootStyle;
-	else properties.style = `background-color:${options.bg};color:${options.fg}`;
-	if (tabindex !== false && tabindex != null) properties.tabindex = tabindex.toString();
-	for (const [key, value] of Object.entries(options.meta || {})) if (!key.startsWith("_")) properties[key] = value;
-	let preNode = {
-		type: "element",
-		tagName: "pre",
-		properties,
-		children: [],
-		data: options.data
-	};
-	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);
-		} else if (structure === "inline") lineNodes.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);
-	} else if (structure === "inline") {
-		const syntheticLines = [];
-		let currentLine = {
-			type: "element",
-			tagName: "span",
-			properties: { class: "line" },
-			children: []
-		};
-		for (const child of root.children) if (child.type === "element" && child.tagName === "br") {
-			syntheticLines.push(currentLine);
-			currentLine = {
-				type: "element",
-				tagName: "span",
-				properties: { class: "line" },
-				children: []
-			};
-		} else if (child.type === "element" || child.type === "text") currentLine.children.push(child);
-		syntheticLines.push(currentLine);
-		let transformedCode = {
-			type: "element",
-			tagName: "code",
-			properties: {},
-			children: syntheticLines
-		};
-		for (const transformer of transformers) transformedCode = transformer?.code?.call(context, transformedCode) || transformedCode;
-		root.children = [];
-		for (let i = 0; i < transformedCode.children.length; i++) {
-			if (i > 0) root.children.push({
-				type: "element",
-				tagName: "br",
-				properties: {},
-				children: []
-			});
-			const line = transformedCode.children[i];
-			if (line.type === "element") root.children.push(...line.children);
-		}
-	}
-	let result = root;
-	for (const transformer of transformers) result = transformer?.root?.call(context, result) || result;
-	if (grammarState) setLastGrammarStateToMap(result, grammarState);
-	return result;
+  const transformers = getTransformers(options);
+  const lines = [];
+  const root = {
+    type: "root",
+    children: []
+  };
+  const { structure = "classic", tabindex = "0" } = options;
+  const properties = { class: `shiki ${options.themeName || ""}` };
+  if (options.rootStyle !== false) if (options.rootStyle != null) properties.style = options.rootStyle;
+  else properties.style = `background-color:${options.bg};color:${options.fg}`;
+  if (tabindex !== false && tabindex != null) properties.tabindex = tabindex.toString();
+  for (const [key, value] of Object.entries(options.meta || {})) if (!key.startsWith("_")) properties[key] = value;
+  let preNode = {
+    type: "element",
+    tagName: "pre",
+    properties,
+    children: [],
+    data: options.data
+  };
+  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);
+    } else if (structure === "inline") lineNodes.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);
+  } else if (structure === "inline") {
+    const syntheticLines = [];
+    let currentLine = {
+      type: "element",
+      tagName: "span",
+      properties: { class: "line" },
+      children: []
+    };
+    for (const child of root.children) if (child.type === "element" && child.tagName === "br") {
+      syntheticLines.push(currentLine);
+      currentLine = {
+        type: "element",
+        tagName: "span",
+        properties: { class: "line" },
+        children: []
+      };
+    } else if (child.type === "element" || child.type === "text") currentLine.children.push(child);
+    syntheticLines.push(currentLine);
+    let transformedCode = {
+      type: "element",
+      tagName: "code",
+      properties: {},
+      children: syntheticLines
+    };
+    for (const transformer of transformers) transformedCode = transformer?.code?.call(context, transformedCode) || transformedCode;
+    root.children = [];
+    for (let i = 0; i < transformedCode.children.length; i++) {
+      if (i > 0) root.children.push({
+        type: "element",
+        tagName: "br",
+        properties: {},
+        children: []
+      });
+      const line = transformedCode.children[i];
+      if (line.type === "element") root.children.push(...line.children);
+    }
+  }
+  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;
-		line.forEach((token, idx) => {
-			const couldMerge = !(token.fontStyle && (token.fontStyle & FontStyle.Underline || token.fontStyle & FontStyle.Strikethrough));
-			if (couldMerge && token.content.match(/^\s+$/) && line[idx + 1]) {
-				if (firstOffset === void 0) 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 = void 0;
-				carryOnContent = "";
-			} else newLine.push(token);
-		});
-		return newLine;
-	});
+  return tokens.map((line) => {
+    const newLine = [];
+    let carryOnContent = "";
+    let firstOffset;
+    line.forEach((token, idx) => {
+      const couldMerge = !(token.fontStyle && (token.fontStyle & FontStyle.Underline || token.fontStyle & FontStyle.Strikethrough));
+      if (couldMerge && token.content.match(/^\s+$/) && line[idx + 1]) {
+        if (firstOffset === void 0) 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 = void 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;
-		});
-	});
+  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;
-	});
+  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;
+  });
 }
-var hastToHtml = toHtml;
-/**
-* Get highlighted code in HTML.
-*/
+const hastToHtml = toHtml;
 function codeToHtml(primitive, code, options) {
-	const context = {
-		meta: {},
-		options,
-		codeToHast: (_code, _options) => codeToHast(primitive, _code, _options),
-		codeToTokens: (_code, _options) => codeToTokens(primitive, _code, _options)
-	};
-	let result = hastToHtml(codeToHast(primitive, code, options, context));
-	for (const transformer of getTransformers(options)) result = transformer.postprocess?.call(context, result, options) || result;
-	return result;
+  const context = {
+    meta: {},
+    options,
+    codeToHast: (_code, _options) => codeToHast(primitive, _code, _options),
+    codeToTokens: (_code, _options) => codeToTokens(primitive, _code, _options)
+  };
+  let result = hastToHtml(codeToHast(primitive, code, options, context));
+  for (const transformer of getTransformers(options)) result = transformer.postprocess?.call(context, result, options) || result;
+  return result;
 }
-/**
-* Create a Shiki core highlighter instance, with no languages or themes bundled.
-* Wasm and each language and theme must be loaded manually.
-*
-* @see http://shiki.style/guide/bundles#fine-grained-bundle
-*/
 async function createHighlighterCore(options) {
-	const primitive = await createShikiPrimitiveAsync(options);
-	return {
-		getLastGrammarState: (...args) => getLastGrammarState(primitive, ...args),
-		codeToTokensBase: (code, options) => codeToTokensBase(primitive, code, options),
-		codeToTokensWithThemes: (code, options) => codeToTokensWithThemes(primitive, code, options),
-		codeToTokens: (code, options) => codeToTokens(primitive, code, options),
-		codeToHast: (code, options) => codeToHast(primitive, code, options),
-		codeToHtml: (code, options) => codeToHtml(primitive, code, options),
-		getBundledLanguages: () => ({}),
-		getBundledThemes: () => ({}),
-		...primitive,
-		getInternalContext: () => primitive
-	};
+  const primitive = await createShikiPrimitiveAsync(options);
+  return {
+    getLastGrammarState: (...args) => getLastGrammarState(primitive, ...args),
+    codeToTokensBase: (code, options2) => codeToTokensBase(primitive, code, options2),
+    codeToTokensWithThemes: (code, options2) => codeToTokensWithThemes(primitive, code, options2),
+    codeToTokens: (code, options2) => codeToTokens(primitive, code, options2),
+    codeToHast: (code, options2) => codeToHast(primitive, code, options2),
+    codeToHtml: (code, options2) => codeToHtml(primitive, code, options2),
+    getBundledLanguages: () => ({}),
+    getBundledThemes: () => ({}),
+    ...primitive,
+    getInternalContext: () => primitive
+  };
 }
 function createBundledHighlighter(options) {
-	const bundledLanguages = options.langs;
-	const bundledThemes = options.themes;
-	const engine = options.engine;
-	async function createHighlighter(options) {
-		function resolveLang(lang) {
-			if (typeof lang === "string") {
-				lang = options.langAlias?.[lang] || lang;
-				if (isSpecialLang(lang)) return [];
-				const bundle = bundledLanguages[lang];
-				if (!bundle) throw new ShikiError(`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(`Theme \`${theme}\` is not included in this bundle. You may want to load it from external source.`);
-				return bundle;
-			}
-			return theme;
-		}
-		const _themes = (options.themes ?? []).map((i) => resolveTheme(i));
-		const langs = (options.langs ?? []).map((i) => resolveLang(i));
-		const core = await createHighlighterCore({
-			engine: options.engine ?? engine(),
-			...options,
-			themes: _themes,
-			langs
-		});
-		return {
-			...core,
-			loadLanguage(...langs) {
-				return core.loadLanguage(...langs.map(resolveLang));
-			},
-			loadTheme(...themes) {
-				return core.loadTheme(...themes.map(resolveTheme));
-			},
-			getBundledLanguages() {
-				return bundledLanguages;
-			},
-			getBundledThemes() {
-				return bundledThemes;
-			}
-		};
-	}
-	return createHighlighter;
+  const bundledLanguages = options.langs;
+  const bundledThemes = options.themes;
+  const engine = options.engine;
+  async function createHighlighter(options2) {
+    function resolveLang(lang) {
+      if (typeof lang === "string") {
+        lang = options2.langAlias?.[lang] || lang;
+        if (isSpecialLang(lang)) return [];
+        const bundle = bundledLanguages[lang];
+        if (!bundle) throw new ShikiError(`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(`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;
 }
 function makeSingletonHighlighter(createHighlighter) {
-	let _shiki;
-	async function getSingletonHighlighter(options = {}) {
-		if (!_shiki) {
-			_shiki = createHighlighter({
-				...options,
-				themes: [],
-				langs: []
-			});
-			const s = await _shiki;
-			await Promise.all([s.loadTheme(...options.themes || []), s.loadLanguage(...options.langs || [])]);
-			return s;
-		} else {
-			const s = await _shiki;
-			await Promise.all([s.loadTheme(...options.themes || []), s.loadLanguage(...options.langs || [])]);
-			return s;
-		}
-	}
-	return getSingletonHighlighter;
+  let _shiki;
+  async function getSingletonHighlighter(options = {}) {
+    if (!_shiki) {
+      _shiki = createHighlighter({
+        ...options,
+        themes: [],
+        langs: []
+      });
+      const s = await _shiki;
+      await Promise.all([s.loadTheme(...options.themes || []), s.loadLanguage(...options.langs || [])]);
+      return s;
+    } else {
+      const s = await _shiki;
+      await Promise.all([s.loadTheme(...options.themes || []), s.loadLanguage(...options.langs || [])]);
+      return s;
+    }
+  }
+  return getSingletonHighlighter;
 }
 function createSingletonShorthands(createHighlighter, config) {
-	const getSingletonHighlighter = makeSingletonHighlighter(createHighlighter);
-	async function get(code, options) {
-		const shiki = await getSingletonHighlighter({
-			langs: [options.lang],
-			themes: "theme" in options ? [options.theme] : Object.values(options.themes)
-		});
-		const langs = await config?.guessEmbeddedLanguages?.(code, options.lang, shiki);
-		if (langs) await shiki.loadLanguage(...langs);
-		return shiki;
-	}
-	return {
-		getSingletonHighlighter(options) {
-			return getSingletonHighlighter(options);
-		},
-		async codeToHtml(code, options) {
-			return (await get(code, options)).codeToHtml(code, options);
-		},
-		async codeToHast(code, options) {
-			return (await get(code, options)).codeToHast(code, options);
-		},
-		async codeToTokens(code, options) {
-			return (await get(code, options)).codeToTokens(code, options);
-		},
-		async codeToTokensBase(code, options) {
-			return (await get(code, options)).codeToTokensBase(code, options);
-		},
-		async codeToTokensWithThemes(code, options) {
-			return (await get(code, options)).codeToTokensWithThemes(code, options);
-		},
-		async getLastGrammarState(code, options) {
-			return (await getSingletonHighlighter({
-				langs: [options.lang],
-				themes: [options.theme]
-			})).getLastGrammarState(code, options);
-		}
-	};
+  const getSingletonHighlighter = makeSingletonHighlighter(createHighlighter);
+  async function get(code, options) {
+    const shiki = await getSingletonHighlighter({
+      langs: [options.lang],
+      themes: "theme" in options ? [options.theme] : Object.values(options.themes)
+    });
+    const langs = await config?.guessEmbeddedLanguages?.(code, options.lang, shiki);
+    if (langs) await shiki.loadLanguage(...langs);
+    return shiki;
+  }
+  return {
+    getSingletonHighlighter(options) {
+      return getSingletonHighlighter(options);
+    },
+    async codeToHtml(code, options) {
+      return (await get(code, options)).codeToHtml(code, options);
+    },
+    async codeToHast(code, options) {
+      return (await get(code, options)).codeToHast(code, options);
+    },
+    async codeToTokens(code, options) {
+      return (await get(code, options)).codeToTokens(code, options);
+    },
+    async codeToTokensBase(code, options) {
+      return (await get(code, options)).codeToTokensBase(code, options);
+    },
+    async codeToTokensWithThemes(code, options) {
+      return (await get(code, options)).codeToTokensWithThemes(code, options);
+    },
+    async getLastGrammarState(code, options) {
+      return (await getSingletonHighlighter({
+        langs: [options.lang],
+        themes: [options.theme]
+      })).getLastGrammarState(code, options);
+    }
+  };
 }
-//#endregion
-export { addClassToHast, createBundledHighlighter, createHighlighterCore, createPositionConverter, createSingletonShorthands, flatTokenVariants, getTokenStyleObject, guessEmbeddedLanguages, hastToHtml, makeSingletonHighlighter, splitToken, splitTokens, stringifyTokenStyle, tokenizeAnsiWithTheme, tokensToHast, transformerDecorations };
+export {
+  ShikiError,
+  addClassToHast,
+  applyColorReplacements,
+  codeToHast,
+  codeToHtml,
+  codeToTokens,
+  codeToTokensBase,
+  codeToTokensWithThemes,
+  createBundledHighlighter,
+  createHighlighterCore,
+  createPositionConverter,
+  createShikiPrimitive,
+  createShikiPrimitiveAsync,
+  createSingletonShorthands,
+  flatTokenVariants,
+  getLastGrammarState,
+  getTokenStyleObject,
+  guessEmbeddedLanguages,
+  hastToHtml,
+  isNoneTheme,
+  isPlainLang,
+  isSpecialLang,
+  isSpecialTheme,
+  makeSingletonHighlighter,
+  normalizeGetter,
+  normalizeTheme,
+  resolveColorReplacements,
+  splitLines,
+  splitToken,
+  splitTokens,
+  stringifyTokenStyle,
+  toArray,
+  tokenizeAnsiWithTheme,
+  tokenizeWithTheme,
+  tokensToHast,
+  transformerDecorations
+};