mini-shiki 3.23.0 → 4.0.1

package/dist/shiki.js

@@ -3,9 +3,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createOnigurumaEngine, loadWasm } from "@shikijs/engine-oniguruma";
 import { ShikiError } from "@shikijs/types";
-import { EncodedTokenMetadata, FontStyle, INITIAL, Registry, Theme } from "@shikijs/vscode-textmate";
+import { EncodedTokenMetadata, INITIAL, Registry, Theme } from "@shikijs/vscode-textmate";
 
-//#region node_modules/@shikijs/core/dist/index.mjs
+//#region node_modules/@shikijs/primitive/dist/index.mjs
 function resolveColorReplacements(theme, options) {
 	const replacements = typeof theme === "string" ? {} : { ...theme.colorReplacements };
 	const themeName = typeof theme === "string" ? theme : theme.name;
@@ -20,9 +20,17 @@ function applyColorReplacements(color, replacements) {
 function toArray(x) {
 	return Array.isArray(x) ? x : [x];
 }
+/**
+* Normalize a getter to a promise.
+*/
 async function normalizeGetter(p) {
 	return Promise.resolve(typeof p === "function" ? p() : p).then((r) => r.default || r);
 }
+/**
+* Check if the language is plaintext that is ignored by Shiki.
+*
+* Hard-coded plain text languages: `plaintext`, `txt`, `text`, `plain`.
+*/
 function isPlainLang(lang) {
 	return !lang || [
 		"plaintext",
@@ -31,15 +39,46 @@ function isPlainLang(lang) {
 		"plain"
 	].includes(lang);
 }
+/**
+* Check if the language is specially handled or bypassed by Shiki.
+*
+* Hard-coded languages: `ansi` and plaintexts like `plaintext`, `txt`, `text`, `plain`.
+*/
 function isSpecialLang(lang) {
 	return lang === "ansi" || isPlainLang(lang);
 }
+/**
+* Check if the theme is specially handled or bypassed by Shiki.
+*
+* Hard-coded themes: `none`.
+*/
 function isNoneTheme(theme) {
 	return theme === "none";
 }
+/**
+* Check if the theme is specially handled or bypassed by Shiki.
+*
+* Hard-coded themes: `none`.
+*/
 function isSpecialTheme(theme) {
 	return isNoneTheme(theme);
 }
+/**
+* Split a string into lines, each line preserves the line ending.
+*
+* @param code - The code string to split into lines
+* @param preserveEnding - Whether to preserve line endings in the result
+* @returns Array of tuples containing [line content, offset index]
+*
+* @example
+* ```ts
+* splitLines('hello\nworld', false)
+* // => [['hello', 0], ['world', 6]]
+*
+* splitLines('hello\nworld', true)
+* // => [['hello\n', 0], ['world', 6]]
+* ```
+*/
 function splitLines(code, preserveEnding = false) {
 	if (code.length === 0) return [["", 0]];
 	const parts = code.split(/(\r?\n)/g);
@@ -53,616 +92,9 @@ function splitLines(code, preserveEnding = false) {
 	}
 	return lines;
 }
-const _grammarStateMap = /* @__PURE__ */ new WeakMap();
-function setLastGrammarStateToMap(keys, state) {
-	_grammarStateMap.set(keys, state);
-}
-function getLastGrammarStateFromMap(keys) {
-	return _grammarStateMap.get(keys);
-}
-var GrammarState = class GrammarState {
-	/**
-	* Theme to Stack mapping
-	*/
-	_stacks = {};
-	lang;
-	get themes() {
-		return Object.keys(this._stacks);
-	}
-	get theme() {
-		return this.themes[0];
-	}
-	get _stack() {
-		return this._stacks[this.theme];
-	}
-	/**
-	* Static method to create a initial grammar state.
-	*/
-	static initial(lang, themes) {
-		return new GrammarState(Object.fromEntries(toArray(themes).map((theme) => [theme, INITIAL])), lang);
-	}
-	constructor(...args) {
-		if (args.length === 2) {
-			const [stacksMap, lang] = args;
-			this.lang = lang;
-			this._stacks = stacksMap;
-		} else {
-			const [stack, lang, theme] = args;
-			this.lang = lang;
-			this._stacks = { [theme]: stack };
-		}
-	}
-	/**
-	* Get the internal stack object.
-	* @internal
-	*/
-	getInternalStack(theme = this.theme) {
-		return this._stacks[theme];
-	}
-	getScopes(theme = this.theme) {
-		return getScopes(this._stacks[theme]);
-	}
-	toJSON() {
-		return {
-			lang: this.lang,
-			theme: this.theme,
-			themes: this.themes,
-			scopes: this.getScopes()
-		};
-	}
-};
-function getScopes(stack) {
-	const scopes = [];
-	const visited = /* @__PURE__ */ new Set();
-	function pushScope(stack2) {
-		if (visited.has(stack2)) return;
-		visited.add(stack2);
-		const name = stack2?.nameScopesList?.scopeName;
-		if (name) scopes.push(name);
-		if (stack2.parent) pushScope(stack2.parent);
-	}
-	pushScope(stack);
-	return scopes;
-}
-function getGrammarStack(state, theme) {
-	if (!(state instanceof GrammarState)) throw new ShikiError("Invalid grammar state");
-	return state.getInternalStack(theme);
-}
-var namedColors = [
-	"black",
-	"red",
-	"green",
-	"yellow",
-	"blue",
-	"magenta",
-	"cyan",
-	"white",
-	"brightBlack",
-	"brightRed",
-	"brightGreen",
-	"brightYellow",
-	"brightBlue",
-	"brightMagenta",
-	"brightCyan",
-	"brightWhite"
-];
-var decorations = {
-	1: "bold",
-	2: "dim",
-	3: "italic",
-	4: "underline",
-	7: "reverse",
-	8: "hidden",
-	9: "strikethrough"
-};
-function findSequence(value, position) {
-	const nextEscape = value.indexOf("\x1B", position);
-	if (nextEscape !== -1) {
-		if (value[nextEscape + 1] === "[") {
-			const nextClose = value.indexOf("m", nextEscape);
-			if (nextClose !== -1) return {
-				sequence: value.substring(nextEscape + 2, nextClose).split(";"),
-				startPosition: nextEscape,
-				position: nextClose + 1
-			};
-		}
-	}
-	return { position: value.length };
-}
-function parseColor(sequence) {
-	const colorMode = sequence.shift();
-	if (colorMode === "2") {
-		const rgb = sequence.splice(0, 3).map((x) => Number.parseInt(x));
-		if (rgb.length !== 3 || rgb.some((x) => Number.isNaN(x))) return;
-		return {
-			type: "rgb",
-			rgb
-		};
-	} else if (colorMode === "5") {
-		const index = sequence.shift();
-		if (index) return {
-			type: "table",
-			index: Number(index)
-		};
-	}
-}
-function parseSequence(sequence) {
-	const commands = [];
-	while (sequence.length > 0) {
-		const code = sequence.shift();
-		if (!code) continue;
-		const codeInt = Number.parseInt(code);
-		if (Number.isNaN(codeInt)) continue;
-		if (codeInt === 0) commands.push({ type: "resetAll" });
-		else if (codeInt <= 9) {
-			const decoration = decorations[codeInt];
-			if (decoration) commands.push({
-				type: "setDecoration",
-				value: decorations[codeInt]
-			});
-		} else if (codeInt <= 29) {
-			const decoration = decorations[codeInt - 20];
-			if (decoration) {
-				commands.push({
-					type: "resetDecoration",
-					value: decoration
-				});
-				if (decoration === "dim") commands.push({
-					type: "resetDecoration",
-					value: "bold"
-				});
-			}
-		} else if (codeInt <= 37) commands.push({
-			type: "setForegroundColor",
-			value: {
-				type: "named",
-				name: namedColors[codeInt - 30]
-			}
-		});
-		else if (codeInt === 38) {
-			const color = parseColor(sequence);
-			if (color) commands.push({
-				type: "setForegroundColor",
-				value: color
-			});
-		} else if (codeInt === 39) commands.push({ type: "resetForegroundColor" });
-		else if (codeInt <= 47) commands.push({
-			type: "setBackgroundColor",
-			value: {
-				type: "named",
-				name: namedColors[codeInt - 40]
-			}
-		});
-		else if (codeInt === 48) {
-			const color = parseColor(sequence);
-			if (color) commands.push({
-				type: "setBackgroundColor",
-				value: color
-			});
-		} else if (codeInt === 49) commands.push({ type: "resetBackgroundColor" });
-		else if (codeInt === 53) commands.push({
-			type: "setDecoration",
-			value: "overline"
-		});
-		else if (codeInt === 55) commands.push({
-			type: "resetDecoration",
-			value: "overline"
-		});
-		else if (codeInt >= 90 && codeInt <= 97) commands.push({
-			type: "setForegroundColor",
-			value: {
-				type: "named",
-				name: namedColors[codeInt - 90 + 8]
-			}
-		});
-		else if (codeInt >= 100 && codeInt <= 107) commands.push({
-			type: "setBackgroundColor",
-			value: {
-				type: "named",
-				name: namedColors[codeInt - 100 + 8]
-			}
-		});
-	}
-	return commands;
-}
-function createAnsiSequenceParser() {
-	let foreground = null;
-	let background = null;
-	let decorations2 = /* @__PURE__ */ new Set();
-	return { parse(value) {
-		const tokens = [];
-		let position = 0;
-		do {
-			const findResult = findSequence(value, position);
-			const text = findResult.sequence ? value.substring(position, findResult.startPosition) : value.substring(position);
-			if (text.length > 0) tokens.push({
-				value: text,
-				foreground,
-				background,
-				decorations: new Set(decorations2)
-			});
-			if (findResult.sequence) {
-				const commands = parseSequence(findResult.sequence);
-				for (const styleToken of commands) if (styleToken.type === "resetAll") {
-					foreground = null;
-					background = null;
-					decorations2.clear();
-				} else if (styleToken.type === "resetForegroundColor") foreground = null;
-				else if (styleToken.type === "resetBackgroundColor") background = null;
-				else if (styleToken.type === "resetDecoration") decorations2.delete(styleToken.value);
-				for (const styleToken of commands) if (styleToken.type === "setForegroundColor") foreground = styleToken.value;
-				else if (styleToken.type === "setBackgroundColor") background = styleToken.value;
-				else if (styleToken.type === "setDecoration") decorations2.add(styleToken.value);
-			}
-			position = findResult.position;
-		} while (position < value.length);
-		return tokens;
-	} };
-}
-var defaultNamedColorsMap = {
-	black: "#000000",
-	red: "#bb0000",
-	green: "#00bb00",
-	yellow: "#bbbb00",
-	blue: "#0000bb",
-	magenta: "#ff00ff",
-	cyan: "#00bbbb",
-	white: "#eeeeee",
-	brightBlack: "#555555",
-	brightRed: "#ff5555",
-	brightGreen: "#00ff00",
-	brightYellow: "#ffff55",
-	brightBlue: "#5555ff",
-	brightMagenta: "#ff55ff",
-	brightCyan: "#55ffff",
-	brightWhite: "#ffffff"
-};
-function createColorPalette(namedColorsMap = defaultNamedColorsMap) {
-	function namedColor(name) {
-		return namedColorsMap[name];
-	}
-	function rgbColor(rgb) {
-		return `#${rgb.map((x) => Math.max(0, Math.min(x, 255)).toString(16).padStart(2, "0")).join("")}`;
-	}
-	let colorTable;
-	function getColorTable() {
-		if (colorTable) return colorTable;
-		colorTable = [];
-		for (let i = 0; i < namedColors.length; i++) colorTable.push(namedColor(namedColors[i]));
-		let levels = [
-			0,
-			95,
-			135,
-			175,
-			215,
-			255
-		];
-		for (let r = 0; r < 6; r++) for (let g = 0; g < 6; g++) for (let b = 0; b < 6; b++) colorTable.push(rgbColor([
-			levels[r],
-			levels[g],
-			levels[b]
-		]));
-		let level = 8;
-		for (let i = 0; i < 24; i++, level += 10) colorTable.push(rgbColor([
-			level,
-			level,
-			level
-		]));
-		return colorTable;
-	}
-	function tableColor(index) {
-		return getColorTable()[index];
-	}
-	function value(color) {
-		switch (color.type) {
-			case "named": return namedColor(color.name);
-			case "rgb": return rgbColor(color.rgb);
-			case "table": return tableColor(color.index);
-		}
-	}
-	return { value };
-}
-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 ansiPalette = Object.fromEntries(namedColors.map((name) => {
-		const key = `terminal.ansi${name[0].toUpperCase()}${name.substring(1)}`;
-		const themeColor = theme.colors?.[key];
-		return [name, themeColor || defaultAnsiColors[name]];
-	}));
-	const colorPalette = createColorPalette(ansiPalette);
-	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
-		};
-	}));
-}
-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];
-			const alpha = Math.round(Number.parseInt(`${a}${a}`, 16) / 2).toString(16).padStart(2, "0");
-			return `#${r}${r}${g}${g}${b}${b}${alpha}`;
-		} 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;
-}
-function codeToTokensBase(internal, code, options = {}) {
-	const { theme: themeName = internal.getLoadedThemes()[0] } = options;
-	const lang = internal.resolveLangAlias(options.lang || "text");
-	if (isPlainLang(lang) || isNoneTheme(themeName)) return splitLines(code).map((line) => [{
-		content: line[0],
-		offset: line[1]
-	}]);
-	const { theme, colorMap } = internal.setTheme(themeName);
-	if (lang === "ansi") return tokenizeAnsiWithTheme(theme, code, options);
-	const _grammar = internal.getLanguage(options.lang || "text");
-	if (options.grammarState) {
-		if (options.grammarState.lang !== _grammar.name) throw new ShikiError(`Grammar state language "${options.grammarState.lang}" does not match highlight language "${_grammar.name}"`);
-		if (!options.grammarState.themes.includes(theme.name)) throw new ShikiError(`Grammar state themes "${options.grammarState.themes}" do not contain highlight theme "${theme.name}"`);
-	}
-	return tokenizeWithTheme(code, _grammar, theme, colorMap, options);
-}
-function tokenizeWithTheme(code, grammar, theme, colorMap, options) {
-	const result = _tokenizeWithTheme(code, grammar, theme, colorMap, options);
-	const grammarState = new GrammarState(result.stateStack, grammar.name, theme.name);
-	setLastGrammarStateToMap(result.tokens, grammarState);
-	return result.tokens;
-}
-function _tokenizeWithTheme(code, grammar, theme, colorMap, options) {
-	const colorReplacements = resolveColorReplacements(theme, options);
-	const { tokenizeMaxLineLength = 0, tokenizeTimeLimit = 500 } = options;
-	const lines = splitLines(code);
-	let stateStack = options.grammarState ? getGrammarStack(options.grammarState, theme.name) ?? INITIAL : options.grammarContextCode != null ? _tokenizeWithTheme(options.grammarContextCode, grammar, theme, colorMap, {
-		...options,
-		grammarState: void 0,
-		grammarContextCode: void 0
-	}).stateStack : INITIAL;
-	let actual = [];
-	const final = [];
-	for (let i = 0, len = lines.length; i < len; i++) {
-		const [line, lineOffset] = lines[i];
-		if (line === "") {
-			actual = [];
-			final.push([]);
-			continue;
-		}
-		if (tokenizeMaxLineLength > 0 && line.length >= tokenizeMaxLineLength) {
-			actual = [];
-			final.push([{
-				content: line,
-				offset: lineOffset,
-				color: "",
-				fontStyle: 0
-			}]);
-			continue;
-		}
-		let resultWithScopes;
-		let tokensWithScopes;
-		let tokensWithScopesIndex;
-		if (options.includeExplanation) {
-			resultWithScopes = grammar.tokenizeLine(line, stateStack, tokenizeTimeLimit);
-			tokensWithScopes = resultWithScopes.tokens;
-			tokensWithScopesIndex = 0;
-		}
-		const result = grammar.tokenizeLine2(line, stateStack, tokenizeTimeLimit);
-		const tokensLength = result.tokens.length / 2;
-		for (let j = 0; j < tokensLength; j++) {
-			const startIndex = result.tokens[2 * j];
-			const nextStartIndex = j + 1 < tokensLength ? result.tokens[2 * j + 2] : line.length;
-			if (startIndex === nextStartIndex) continue;
-			const metadata = result.tokens[2 * j + 1];
-			const color = applyColorReplacements(colorMap[EncodedTokenMetadata.getForeground(metadata)], colorReplacements);
-			const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);
-			const token = {
-				content: line.substring(startIndex, nextStartIndex),
-				offset: lineOffset + startIndex,
-				color,
-				fontStyle
-			};
-			if (options.includeExplanation) {
-				const themeSettingsSelectors = [];
-				if (options.includeExplanation !== "scopeName") for (const setting of theme.settings) {
-					let selectors;
-					switch (typeof setting.scope) {
-						case "string":
-							selectors = setting.scope.split(/,/).map((scope) => scope.trim());
-							break;
-						case "object":
-							selectors = setting.scope;
-							break;
-						default: continue;
-					}
-					themeSettingsSelectors.push({
-						settings: setting,
-						selectors: selectors.map((selector) => selector.split(/ /))
-					});
-				}
-				token.explanation = [];
-				let offset = 0;
-				while (startIndex + offset < nextStartIndex) {
-					const tokenWithScopes = tokensWithScopes[tokensWithScopesIndex];
-					const tokenWithScopesText = line.substring(tokenWithScopes.startIndex, tokenWithScopes.endIndex);
-					offset += tokenWithScopesText.length;
-					token.explanation.push({
-						content: tokenWithScopesText,
-						scopes: options.includeExplanation === "scopeName" ? explainThemeScopesNameOnly(tokenWithScopes.scopes) : explainThemeScopesFull(themeSettingsSelectors, tokenWithScopes.scopes)
-					});
-					tokensWithScopesIndex += 1;
-				}
-			}
-			actual.push(token);
-		}
-		final.push(actual);
-		actual = [];
-		stateStack = result.ruleStack;
-	}
-	return {
-		tokens: final,
-		stateStack
-	};
-}
-function explainThemeScopesNameOnly(scopes) {
-	return scopes.map((scope) => ({ scopeName: scope }));
-}
-function explainThemeScopesFull(themeSelectors, scopes) {
-	const result = [];
-	for (let i = 0, len = scopes.length; i < len; i++) {
-		const scope = scopes[i];
-		result[i] = {
-			scopeName: scope,
-			themeMatches: explainThemeScope(themeSelectors, scope, scopes.slice(0, i))
-		};
-	}
-	return result;
-}
-function matchesOne(selector, scope) {
-	return selector === scope || scope.substring(0, selector.length) === selector && scope[selector.length] === ".";
-}
-function matches(selectors, scope, parentScopes) {
-	if (!matchesOne(selectors[selectors.length - 1], scope)) return false;
-	let selectorParentIndex = selectors.length - 2;
-	let parentIndex = parentScopes.length - 1;
-	while (selectorParentIndex >= 0 && parentIndex >= 0) {
-		if (matchesOne(selectors[selectorParentIndex], parentScopes[parentIndex])) selectorParentIndex -= 1;
-		parentIndex -= 1;
-	}
-	if (selectorParentIndex === -1) return true;
-	return false;
-}
-function explainThemeScope(themeSettingsSelectors, scope, parentScopes) {
-	const result = [];
-	for (const { selectors, settings } of themeSettingsSelectors) for (const selectorPieces of selectors) if (matches(selectorPieces, scope, parentScopes)) {
-		result.push(settings);
-		break;
-	}
-	return result;
-}
-function codeToTokensWithThemes(internal, code, options) {
-	const themes = Object.entries(options.themes).filter((i) => i[1]).map((i) => ({
-		color: i[0],
-		theme: i[1]
-	}));
-	const themedTokens = themes.map((t) => {
-		const tokens2 = codeToTokensBase(internal, code, {
-			...options,
-			theme: t.theme
-		});
-		const state = getLastGrammarStateFromMap(tokens2);
-		const theme = typeof t.theme === "string" ? t.theme : t.theme.name;
-		return {
-			tokens: tokens2,
-			state,
-			theme
-		};
-	});
-	const tokens = syncThemesTokenization(...themedTokens.map((i) => i.tokens));
-	const mergedTokens = tokens[0].map((line, lineIdx) => line.map((_token, tokenIdx) => {
-		const mergedToken = {
-			content: _token.content,
-			variants: {},
-			offset: _token.offset
-		};
-		if ("includeExplanation" in options && options.includeExplanation) mergedToken.explanation = _token.explanation;
-		tokens.forEach((t, themeIdx) => {
-			const { content: _, explanation: __, offset: ___,...styles } = t[lineIdx][tokenIdx];
-			mergedToken.variants[themes[themeIdx].color] = styles;
-		});
-		return mergedToken;
-	}));
-	const mergedGrammarState = themedTokens[0].state ? new GrammarState(Object.fromEntries(themedTokens.map((s) => [s.theme, s.state?.getInternalStack(s.theme)])), themedTokens[0].state.lang) : void 0;
-	if (mergedGrammarState) setLastGrammarStateToMap(mergedTokens, mergedGrammarState);
-	return mergedTokens;
-}
-function syncThemesTokenization(...themes) {
-	const outThemes = themes.map(() => []);
-	const count = themes.length;
-	for (let i = 0; i < themes[0].length; i++) {
-		const lines = themes.map((t) => t[i]);
-		const outLines = outThemes.map(() => []);
-		outThemes.forEach((t, i2) => t.push(outLines[i2]));
-		const indexes = lines.map(() => 0);
-		const current = lines.map((l) => l[0]);
-		while (current.every((t) => t)) {
-			const minLength = Math.min(...current.map((t) => t.content.length));
-			for (let n = 0; n < count; n++) {
-				const token = current[n];
-				if (token.content.length === minLength) {
-					outLines[n].push(token);
-					indexes[n] += 1;
-					current[n] = lines[n][indexes[n]];
-				} else {
-					outLines[n].push({
-						...token,
-						content: token.content.slice(0, minLength)
-					});
-					current[n] = {
-						...token,
-						content: token.content.slice(minLength),
-						offset: token.offset + minLength
-					};
-				}
-			}
-		}
-	}
-	return outThemes;
-}
+/**
+* https://github.com/microsoft/vscode/blob/f7f05dee53fb33fe023db2e06e30a89d3094488f/src/vs/platform/theme/common/colorRegistry.ts#L258-L268
+*/
 const VSCODE_FALLBACK_EDITOR_FG = {
 	light: "#333333",
 	dark: "#bbbbbb"
@@ -672,6 +104,9 @@ const VSCODE_FALLBACK_EDITOR_BG = {
 	dark: "#1e1e1e"
 };
 const RESOLVED_KEY = "__shiki_resolved";
+/**
+* Normalize a textmate theme to shiki theme
+*/
 function normalizeTheme(rawTheme) {
 	if (rawTheme?.[RESOLVED_KEY]) return rawTheme;
 	const theme = { ...rawTheme };
@@ -684,11 +119,25 @@ function normalizeTheme(rawTheme) {
 	theme.settings ||= [];
 	let { bg, fg } = theme;
 	if (!bg || !fg) {
+		/**
+		* First try:
+		* Theme might contain a global `tokenColor` without `name` or `scope`
+		* Used as default value for foreground/background
+		*/
 		const globalSetting = theme.settings ? theme.settings.find((s) => !s.name && !s.scope) : void 0;
 		if (globalSetting?.settings?.foreground) fg = globalSetting.settings.foreground;
 		if (globalSetting?.settings?.background) bg = globalSetting.settings.background;
+		/**
+		* Second try:
+		* If there's no global `tokenColor` without `name` or `scope`
+		* Use `editor.foreground` and `editor.background`
+		*/
 		if (!fg && theme?.colors?.["editor.foreground"]) fg = theme.colors["editor.foreground"];
 		if (!bg && theme?.colors?.["editor.background"]) bg = theme.colors["editor.background"];
+		/**
+		* Last try:
+		* If there's no fg/bg color specified in theme, use default
+		*/
 		if (!fg) fg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
 		if (!bg) bg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
 		theme.fg = fg;
@@ -742,40 +191,35 @@ function normalizeTheme(rawTheme) {
 	});
 	return theme;
 }
+/**
+* Resolve
+*/
 async function resolveLangs(langs) {
 	return Array.from(new Set((await Promise.all(langs.filter((l) => !isSpecialLang(l)).map(async (lang) => await normalizeGetter(lang).then((r) => Array.isArray(r) ? r : [r])))).flat()));
 }
 async function resolveThemes(themes) {
-	const resolved = await Promise.all(themes.map(async (theme) => isSpecialTheme(theme) ? null : normalizeTheme(await normalizeGetter(theme))));
-	return resolved.filter((i) => !!i);
-}
-let _emitDeprecation = 3;
-let _emitError = false;
-function warnDeprecated(message, version = 3) {
-	if (!_emitDeprecation) return;
-	if (typeof _emitDeprecation === "number" && version > _emitDeprecation) return;
-	if (_emitError) throw new Error(`[SHIKI DEPRECATE]: ${message}`);
-	else console.trace(`[SHIKI DEPRECATE]: ${message}`);
+	return (await Promise.all(themes.map(async (theme) => isSpecialTheme(theme) ? null : normalizeTheme(await normalizeGetter(theme))))).filter((i) => !!i);
 }
-var ShikiError$1 = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ShikiError";
-	}
-};
 function resolveLangAlias(name, alias) {
 	if (!alias) return name;
 	if (alias[name]) {
-		const resolved = /* @__PURE__ */ new Set([name]);
+		const resolved = new Set([name]);
 		while (alias[name]) {
 			name = alias[name];
-			if (resolved.has(name)) throw new ShikiError$1(`Circular alias \`${Array.from(resolved).join(" -> ")} -> ${name}\``);
+			if (resolved.has(name)) throw new ShikiError(`Circular alias \`${Array.from(resolved).join(" -> ")} -> ${name}\``);
 			resolved.add(name);
 		}
 	}
 	return name;
 }
 var Registry$1 = class extends Registry {
+	_resolvedThemes = /* @__PURE__ */ new Map();
+	_resolvedGrammars = /* @__PURE__ */ new Map();
+	_langMap = /* @__PURE__ */ new Map();
+	_langGraph = /* @__PURE__ */ new Map();
+	_textmateThemeCache = /* @__PURE__ */ new WeakMap();
+	_loadedThemesCache = null;
+	_loadedLanguagesCache = null;
 	constructor(_resolver, _themes, _langs, _alias = {}) {
 		super(_resolver);
 		this._resolver = _resolver;
@@ -785,13 +229,6 @@ var Registry$1 = class extends Registry {
 		this._themes.map((t) => this.loadTheme(t));
 		this.loadLanguages(this._langs);
 	}
-	_resolvedThemes = /* @__PURE__ */ new Map();
-	_resolvedGrammars = /* @__PURE__ */ new Map();
-	_langMap = /* @__PURE__ */ new Map();
-	_langGraph = /* @__PURE__ */ new Map();
-	_textmateThemeCache = /* @__PURE__ */ new WeakMap();
-	_loadedThemesCache = null;
-	_loadedLanguagesCache = null;
 	getTheme(theme) {
 		if (typeof theme === "string") return this._resolvedThemes.get(theme);
 		else return this.loadTheme(theme);
@@ -859,16 +296,15 @@ var Registry$1 = class extends Registry {
 		if (missingLangs.length) {
 			const dependents = langsGraphArray.filter(([_, lang]) => {
 				if (!lang) return false;
-				const embedded = lang.embeddedLanguages || lang.embeddedLangs;
-				return embedded?.some((l) => missingLangs.map(([name]) => name).includes(l));
+				return (lang.embeddedLanguages || lang.embeddedLangs)?.some((l) => missingLangs.map(([name]) => name).includes(l));
 			}).filter((lang) => !missingLangs.includes(lang));
-			throw new ShikiError$1(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(", ")}, required by ${dependents.map(([name]) => `\`${name}\``).join(", ")}`);
+			throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(", ")}, required by ${dependents.map(([name]) => `\`${name}\``).join(", ")}`);
 		}
 		for (const [_, lang] of langsGraphArray) this._resolver.addLanguage(lang);
 		for (const [_, lang] of langsGraphArray) this.loadLanguage(lang);
 	}
 	getLoadedLanguages() {
-		if (!this._loadedLanguagesCache) this._loadedLanguagesCache = [.../* @__PURE__ */ new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])];
+		if (!this._loadedLanguagesCache) this._loadedLanguagesCache = [...new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])];
 		return this._loadedLanguagesCache;
 	}
 	resolveEmbeddedLanguages(lang) {
@@ -921,15 +357,19 @@ var Resolver = class {
 	}
 };
 let instancesCount = 0;
-function createShikiInternalSync(options) {
+/**
+* Get the minimal shiki primitive instance.
+*
+* Requires to provide the engine and all themes and languages upfront.
+*/
+function createShikiPrimitive(options) {
 	instancesCount += 1;
 	if (options.warnings !== false && instancesCount >= 10 && instancesCount % 10 === 0) console.warn(`[Shiki] ${instancesCount} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \`highlighter.dispose()\` to release unused instances.`);
 	let isDisposed = false;
-	if (!options.engine) throw new ShikiError$1("`engine` option is required for synchronous mode");
+	if (!options.engine) throw new ShikiError("`engine` option is required for synchronous mode");
 	const langs = (options.langs || []).flat(1);
 	const themes = (options.themes || []).flat(1).map(normalizeTheme);
-	const resolver = new Resolver(options.engine, langs);
-	const _registry = new Registry$1(resolver, themes, langs, options.langAlias);
+	const _registry = new Registry$1(new Resolver(options.engine, langs), themes, langs, options.langAlias);
 	let _lastTheme;
 	function resolveLangAlias$1(name) {
 		return resolveLangAlias(name, options.langAlias);
@@ -937,7 +377,7 @@ function createShikiInternalSync(options) {
 	function getLanguage(name) {
 		ensureNotDisposed();
 		const _lang = _registry.getGrammar(typeof name === "string" ? name : name.name);
-		if (!_lang) throw new ShikiError$1(`Language \`${name}\` not found, you may need to load it first`);
+		if (!_lang) throw new ShikiError(`Language \`${name}\` not found, you may need to load it first`);
 		return _lang;
 	}
 	function getTheme(name) {
@@ -950,7 +390,7 @@ function createShikiInternalSync(options) {
 		};
 		ensureNotDisposed();
 		const _theme = _registry.getTheme(name);
-		if (!_theme) throw new ShikiError$1(`Theme \`${name}\` not found, you may need to load it first`);
+		if (!_theme) throw new ShikiError(`Theme \`${name}\` not found, you may need to load it first`);
 		return _theme;
 	}
 	function setTheme(name) {
@@ -960,10 +400,9 @@ function createShikiInternalSync(options) {
 			_registry.setTheme(theme);
 			_lastTheme = name;
 		}
-		const colorMap = _registry.getColorMap();
 		return {
 			theme,
-			colorMap
+			colorMap: _registry.getColorMap()
 		};
 	}
 	function getLoadedThemes() {
@@ -974,62 +413,384 @@ function createShikiInternalSync(options) {
 		ensureNotDisposed();
 		return _registry.getLoadedLanguages();
 	}
-	function loadLanguageSync(...langs2) {
-		ensureNotDisposed();
-		_registry.loadLanguages(langs2.flat(1));
+	function loadLanguageSync(...langs$1) {
+		ensureNotDisposed();
+		_registry.loadLanguages(langs$1.flat(1));
+	}
+	async function loadLanguage(...langs$1) {
+		return loadLanguageSync(await resolveLangs(langs$1));
+	}
+	function loadThemeSync(...themes$1) {
+		ensureNotDisposed();
+		for (const theme of themes$1.flat(1)) _registry.loadTheme(theme);
+	}
+	async function loadTheme(...themes$1) {
+		ensureNotDisposed();
+		return loadThemeSync(await resolveThemes(themes$1));
+	}
+	function ensureNotDisposed() {
+		if (isDisposed) throw new ShikiError("Shiki instance has been disposed");
+	}
+	function dispose() {
+		if (isDisposed) return;
+		isDisposed = true;
+		_registry.dispose();
+		instancesCount -= 1;
+	}
+	return {
+		setTheme,
+		getTheme,
+		getLanguage,
+		getLoadedThemes,
+		getLoadedLanguages,
+		resolveLangAlias: resolveLangAlias$1,
+		loadLanguage,
+		loadLanguageSync,
+		loadTheme,
+		loadThemeSync,
+		dispose,
+		[Symbol.dispose]: dispose
+	};
+}
+/**
+* Get the minimal shiki primitive instance.
+*/
+async function createShikiPrimitiveAsync(options) {
+	if (!options.engine) console.warn("`engine` option is required. Use `createOnigurumaEngine` or `createJavaScriptRegexEngine` to create an engine.");
+	const [themes, langs, engine] = await Promise.all([
+		resolveThemes(options.themes || []),
+		resolveLangs(options.langs || []),
+		options.engine
+	]);
+	return createShikiPrimitive({
+		...options,
+		themes,
+		langs,
+		engine
+	});
+}
+/**
+* @deprecated Use `createShikiPrimitiveAsync` instead.
+*/
+const createShikiInternal = createShikiPrimitiveAsync;
+const _grammarStateMap = /* @__PURE__ */ new WeakMap();
+function setLastGrammarStateToMap(keys, state) {
+	_grammarStateMap.set(keys, state);
+}
+function getLastGrammarStateFromMap(keys) {
+	return _grammarStateMap.get(keys);
+}
+/**
+* GrammarState is a special reference object that holds the state of a grammar.
+*
+* It's used to highlight code snippets that are part of the target language.
+*/
+var GrammarState = class GrammarState$1 {
+	/**
+	* Theme to Stack mapping
+	*/
+	_stacks = {};
+	lang;
+	get themes() {
+		return Object.keys(this._stacks);
+	}
+	get theme() {
+		return this.themes[0];
+	}
+	get _stack() {
+		return this._stacks[this.theme];
+	}
+	/**
+	* Static method to create a initial grammar state.
+	*/
+	static initial(lang, themes) {
+		return new GrammarState$1(Object.fromEntries(toArray(themes).map((theme) => [theme, INITIAL])), lang);
+	}
+	constructor(...args) {
+		if (args.length === 2) {
+			const [stacksMap, lang] = args;
+			this.lang = lang;
+			this._stacks = stacksMap;
+		} else {
+			const [stack, lang, theme] = args;
+			this.lang = lang;
+			this._stacks = { [theme]: stack };
+		}
+	}
+	/**
+	* Get the internal stack object.
+	* @internal
+	*/
+	getInternalStack(theme = this.theme) {
+		return this._stacks[theme];
 	}
-	async function loadLanguage(...langs2) {
-		return loadLanguageSync(await resolveLangs(langs2));
+	getScopes(theme = this.theme) {
+		return getScopes(this._stacks[theme]);
 	}
-	function loadThemeSync(...themes2) {
-		ensureNotDisposed();
-		for (const theme of themes2.flat(1)) _registry.loadTheme(theme);
+	toJSON() {
+		return {
+			lang: this.lang,
+			theme: this.theme,
+			themes: this.themes,
+			scopes: this.getScopes()
+		};
 	}
-	async function loadTheme(...themes2) {
-		ensureNotDisposed();
-		return loadThemeSync(await resolveThemes(themes2));
+};
+function getScopes(stack) {
+	const scopes = [];
+	const visited = /* @__PURE__ */ new Set();
+	function pushScope(stack$1) {
+		if (visited.has(stack$1)) return;
+		visited.add(stack$1);
+		const name = stack$1?.nameScopesList?.scopeName;
+		if (name) scopes.push(name);
+		if (stack$1.parent) pushScope(stack$1.parent);
 	}
-	function ensureNotDisposed() {
-		if (isDisposed) throw new ShikiError$1("Shiki instance has been disposed");
+	pushScope(stack);
+	return scopes;
+}
+function getGrammarStack(state, theme) {
+	if (!(state instanceof GrammarState)) throw new ShikiError("Invalid grammar state");
+	return state.getInternalStack(theme);
+}
+/**
+* Code to tokens, with a simple theme.
+*/
+function codeToTokensBase(primitive, code, options = {}) {
+	const { theme: themeName = primitive.getLoadedThemes()[0] } = options;
+	if (isPlainLang(primitive.resolveLangAlias(options.lang || "text")) || isNoneTheme(themeName)) return splitLines(code).map((line) => [{
+		content: line[0],
+		offset: line[1]
+	}]);
+	const { theme, colorMap } = primitive.setTheme(themeName);
+	const _grammar = primitive.getLanguage(options.lang || "text");
+	if (options.grammarState) {
+		if (options.grammarState.lang !== _grammar.name) throw new ShikiError(`Grammar state language "${options.grammarState.lang}" does not match highlight language "${_grammar.name}"`);
+		if (!options.grammarState.themes.includes(theme.name)) throw new ShikiError(`Grammar state themes "${options.grammarState.themes}" do not contain highlight theme "${theme.name}"`);
 	}
-	function dispose() {
-		if (isDisposed) return;
-		isDisposed = true;
-		_registry.dispose();
-		instancesCount -= 1;
+	return tokenizeWithTheme(code, _grammar, theme, colorMap, options);
+}
+function tokenizeWithTheme(code, grammar, theme, colorMap, options) {
+	const result = _tokenizeWithTheme(code, grammar, theme, colorMap, options);
+	const grammarState = new GrammarState(result.stateStack, grammar.name, theme.name);
+	setLastGrammarStateToMap(result.tokens, grammarState);
+	return result.tokens;
+}
+function _tokenizeWithTheme(code, grammar, theme, colorMap, options) {
+	const colorReplacements = resolveColorReplacements(theme, options);
+	const { tokenizeMaxLineLength = 0, tokenizeTimeLimit = 500 } = options;
+	const lines = splitLines(code);
+	let stateStack = options.grammarState ? getGrammarStack(options.grammarState, theme.name) ?? INITIAL : options.grammarContextCode != null ? _tokenizeWithTheme(options.grammarContextCode, grammar, theme, colorMap, {
+		...options,
+		grammarState: void 0,
+		grammarContextCode: void 0
+	}).stateStack : INITIAL;
+	let actual = [];
+	const final = [];
+	for (let i = 0, len = lines.length; i < len; i++) {
+		const [line, lineOffset] = lines[i];
+		if (line === "") {
+			actual = [];
+			final.push([]);
+			continue;
+		}
+		if (tokenizeMaxLineLength > 0 && line.length >= tokenizeMaxLineLength) {
+			actual = [];
+			final.push([{
+				content: line,
+				offset: lineOffset,
+				color: "",
+				fontStyle: 0
+			}]);
+			continue;
+		}
+		let resultWithScopes;
+		let tokensWithScopes;
+		let tokensWithScopesIndex;
+		if (options.includeExplanation) {
+			resultWithScopes = grammar.tokenizeLine(line, stateStack, tokenizeTimeLimit);
+			tokensWithScopes = resultWithScopes.tokens;
+			tokensWithScopesIndex = 0;
+		}
+		const result = grammar.tokenizeLine2(line, stateStack, tokenizeTimeLimit);
+		const tokensLength = result.tokens.length / 2;
+		for (let j = 0; j < tokensLength; j++) {
+			const startIndex = result.tokens[2 * j];
+			const nextStartIndex = j + 1 < tokensLength ? result.tokens[2 * j + 2] : line.length;
+			if (startIndex === nextStartIndex) continue;
+			const metadata = result.tokens[2 * j + 1];
+			const color = applyColorReplacements(colorMap[EncodedTokenMetadata.getForeground(metadata)], colorReplacements);
+			const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);
+			const token = {
+				content: line.substring(startIndex, nextStartIndex),
+				offset: lineOffset + startIndex,
+				color,
+				fontStyle
+			};
+			if (options.includeExplanation) {
+				const themeSettingsSelectors = [];
+				if (options.includeExplanation !== "scopeName") for (const setting of theme.settings) {
+					let selectors;
+					switch (typeof setting.scope) {
+						case "string":
+							selectors = setting.scope.split(/,/).map((scope) => scope.trim());
+							break;
+						case "object":
+							selectors = setting.scope;
+							break;
+						default: continue;
+					}
+					themeSettingsSelectors.push({
+						settings: setting,
+						selectors: selectors.map((selector) => selector.split(/ /))
+					});
+				}
+				token.explanation = [];
+				let offset = 0;
+				while (startIndex + offset < nextStartIndex) {
+					const tokenWithScopes = tokensWithScopes[tokensWithScopesIndex];
+					const tokenWithScopesText = line.substring(tokenWithScopes.startIndex, tokenWithScopes.endIndex);
+					offset += tokenWithScopesText.length;
+					token.explanation.push({
+						content: tokenWithScopesText,
+						scopes: options.includeExplanation === "scopeName" ? explainThemeScopesNameOnly(tokenWithScopes.scopes) : explainThemeScopesFull(themeSettingsSelectors, tokenWithScopes.scopes)
+					});
+					tokensWithScopesIndex += 1;
+				}
+			}
+			actual.push(token);
+		}
+		final.push(actual);
+		actual = [];
+		stateStack = result.ruleStack;
 	}
 	return {
-		setTheme,
-		getTheme,
-		getLanguage,
-		getLoadedThemes,
-		getLoadedLanguages,
-		resolveLangAlias: resolveLangAlias$1,
-		loadLanguage,
-		loadLanguageSync,
-		loadTheme,
-		loadThemeSync,
-		dispose,
-		[Symbol.dispose]: dispose
+		tokens: final,
+		stateStack
 	};
 }
-async function createShikiInternal(options) {
-	if (!options.engine) warnDeprecated("`engine` option is required. Use `createOnigurumaEngine` or `createJavaScriptRegexEngine` to create an engine.");
-	const [themes, langs, engine] = await Promise.all([
-		resolveThemes(options.themes || []),
-		resolveLangs(options.langs || []),
-		options.engine
-	]);
-	return createShikiInternalSync({
-		...options,
-		themes,
-		langs,
-		engine
+function explainThemeScopesNameOnly(scopes) {
+	return scopes.map((scope) => ({ scopeName: scope }));
+}
+function explainThemeScopesFull(themeSelectors, scopes) {
+	const result = [];
+	for (let i = 0, len = scopes.length; i < len; i++) {
+		const scope = scopes[i];
+		result[i] = {
+			scopeName: scope,
+			themeMatches: explainThemeScope(themeSelectors, scope, scopes.slice(0, i))
+		};
+	}
+	return result;
+}
+function matchesOne(selector, scope) {
+	return selector === scope || scope.substring(0, selector.length) === selector && scope[selector.length] === ".";
+}
+function matches(selectors, scope, parentScopes) {
+	if (!matchesOne(selectors[selectors.length - 1], scope)) return false;
+	let selectorParentIndex = selectors.length - 2;
+	let parentIndex = parentScopes.length - 1;
+	while (selectorParentIndex >= 0 && parentIndex >= 0) {
+		if (matchesOne(selectors[selectorParentIndex], parentScopes[parentIndex])) selectorParentIndex -= 1;
+		parentIndex -= 1;
+	}
+	if (selectorParentIndex === -1) return true;
+	return false;
+}
+function explainThemeScope(themeSettingsSelectors, scope, parentScopes) {
+	const result = [];
+	for (const { selectors, settings } of themeSettingsSelectors) for (const selectorPieces of selectors) if (matches(selectorPieces, scope, parentScopes)) {
+		result.push(settings);
+		break;
+	}
+	return result;
+}
+/**
+* Get tokens with multiple themes
+*/
+function codeToTokensWithThemes(primitive, code, options) {
+	const themes = Object.entries(options.themes).filter((i) => i[1]).map((i) => ({
+		color: i[0],
+		theme: i[1]
+	}));
+	const themedTokens = themes.map((t) => {
+		const tokens$1 = codeToTokensBase(primitive, code, {
+			...options,
+			theme: t.theme
+		});
+		return {
+			tokens: tokens$1,
+			state: getLastGrammarStateFromMap(tokens$1),
+			theme: typeof t.theme === "string" ? t.theme : t.theme.name
+		};
 	});
+	const tokens = alignThemesTokenization(...themedTokens.map((i) => i.tokens));
+	const mergedTokens = tokens[0].map((line, lineIdx) => line.map((_token, tokenIdx) => {
+		const mergedToken = {
+			content: _token.content,
+			variants: {},
+			offset: _token.offset
+		};
+		if ("includeExplanation" in options && options.includeExplanation) mergedToken.explanation = _token.explanation;
+		tokens.forEach((t, themeIdx) => {
+			const { content: _, explanation: __, offset: ___,...styles } = t[lineIdx][tokenIdx];
+			mergedToken.variants[themes[themeIdx].color] = styles;
+		});
+		return mergedToken;
+	}));
+	const mergedGrammarState = themedTokens[0].state ? new GrammarState(Object.fromEntries(themedTokens.map((s) => [s.theme, s.state?.getInternalStack(s.theme)])), themedTokens[0].state.lang) : void 0;
+	if (mergedGrammarState) setLastGrammarStateToMap(mergedTokens, mergedGrammarState);
+	return mergedTokens;
+}
+/**
+* Break tokens from multiple themes into same tokenization.
+*
+* For example, given two themes that tokenize `console.log("hello")` as:
+*
+* - `console . log (" hello ")` (6 tokens)
+* - `console .log ( "hello" )` (5 tokens)
+*
+* This function will return:
+*
+* - `console . log ( " hello " )` (8 tokens)
+* - `console . log ( " hello " )` (8 tokens)
+*/
+function alignThemesTokenization(...themes) {
+	const outThemes = themes.map(() => []);
+	const count = themes.length;
+	for (let i = 0; i < themes[0].length; i++) {
+		const lines = themes.map((t) => t[i]);
+		const outLines = outThemes.map(() => []);
+		outThemes.forEach((t, i$1) => t.push(outLines[i$1]));
+		const indexes = lines.map(() => 0);
+		const current = lines.map((l) => l[0]);
+		while (current.every((t) => t)) {
+			const minLength = Math.min(...current.map((t) => t.content.length));
+			for (let n = 0; n < count; n++) {
+				const token = current[n];
+				if (token.content.length === minLength) {
+					outLines[n].push(token);
+					indexes[n] += 1;
+					current[n] = lines[n][indexes[n]];
+				} else {
+					outLines[n].push({
+						...token,
+						content: token.content.slice(0, minLength)
+					});
+					current[n] = {
+						...token,
+						content: token.content.slice(minLength),
+						offset: token.offset + minLength
+					};
+				}
+			}
+		}
+	}
+	return outThemes;
 }
 
 //#endregion
-//#region node_modules/shiki/dist/langs.mjs
+//#region node_modules/shiki/dist/langs-bundle-full-CQWtMIqW.mjs
 const bundledLanguagesInfo = [
 	{
 		"id": "abap",
@@ -2485,7 +2246,7 @@ const bundledThemesInfo = [
 	{
 		"id": "horizon-bright",
 		"displayName": "Horizon Bright",
-		"type": "dark",
+		"type": "light",
 		"import": () => import("@shikijs/themes/horizon-bright")
 	},
 	{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-shiki",
-  "version": "3.23.0",
+  "version": "4.0.1",
   "type": "module",
   "repository": "git+https://github.com/un-ts/mini-shiki.git",
   "homepage": "https://github.com/un-ts/mini-shiki#readme",
@@ -21,10 +21,10 @@
     "static"
   ],
   "dependencies": {
-    "@shikijs/engine-oniguruma": "^3.23.0",
-    "@shikijs/langs": "^3.23.0",
-    "@shikijs/themes": "^3.23.0",
-    "@shikijs/types": "^3.23.0",
+    "@shikijs/engine-oniguruma": "^4.0.1",
+    "@shikijs/langs": "^4.0.1",
+    "@shikijs/themes": "^4.0.1",
+    "@shikijs/types": "^4.0.1",
     "@shikijs/vscode-textmate": "^10.0.2"
   }
 }