@qwik.dev/devtools 0.2.4 → 0.2.6

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

@@ -0,0 +1,1137 @@
+import { ShikiError } from "../../../../../@shikijs_types@4.0.2/node_modules/@shikijs/types/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;
+}
+/**
+* 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
+	};
+}
+/**
+* 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]);
+}
+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.
+*/
+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;
+}
+/**
+* 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);
+		});
+	});
+}
+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;
+}
+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;
+}
+function stringifyTokenStyle(token) {
+	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());
+		}
+	};
+}
+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.`);
+			}
+		}
+	}
+}
+function stringify(el) {
+	if (el.type === "text") return el.value;
+	if (el.type === "element") return el.children.map(stringify).join("");
+	return "";
+}
+var builtInTransformers = [/* @__PURE__ */ transformerDecorations()];
+function getTransformers(options) {
+	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
+	};
+}
+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) {
+			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;
+	} };
+}
+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 };
+}
+/**
+* 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"
+};
+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
+		};
+	}));
+}
+/**
+* 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;
+}
+/**
+* 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);
+}
+/**
+* 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
+	};
+}
+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(";");
+}
+function codeToHast(primitive, code, options, transformerContext = {
+	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);
+}
+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;
+}
+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;
+	});
+}
+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;
+	});
+}
+var hastToHtml = toHtml;
+/**
+* Get highlighted code in HTML.
+*/
+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;
+}
+/**
+* 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
+	};
+}
+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;
+}
+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;
+}
+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);
+		}
+	};
+}
+//#endregion
+export { addClassToHast, createBundledHighlighter, createHighlighterCore, createPositionConverter, createSingletonShorthands, flatTokenVariants, getTokenStyleObject, guessEmbeddedLanguages, hastToHtml, makeSingletonHighlighter, splitToken, splitTokens, stringifyTokenStyle, tokenizeAnsiWithTheme, tokensToHast, transformerDecorations };