@loopstack/loopstack-studio 0.25.1 → 0.26.0

package/dist/node_modules/@shikijs/primitive/dist/index.js

@@ -1,21 +1,20 @@
-import { ShikiError as e } from "../../types/dist/index.js";
-import { EncodedTokenMetadata as t, INITIAL as n, Registry as r, Theme as i } from "../../vscode-textmate/dist/index.js";
-//#region ../../node_modules/@shikijs/primitive/dist/index.mjs
-function a(e, t) {
-	let n = typeof e == "string" ? {} : { ...e.colorReplacements }, r = typeof e == "string" ? e : e.name;
-	for (let [e, i] of Object.entries(t?.colorReplacements || {})) typeof i == "string" ? n[e] = i : e === r && Object.assign(n, i);
-	return n;
+import { ShikiError } from "../../types/dist/index.js";
+import { EncodedTokenMetadata, INITIAL, Registry, Theme } from "../../vscode-textmate/dist/index.js";
+function resolveColorReplacements(e, x) {
+	let S = typeof e == "string" ? {} : { ...e.colorReplacements }, C = typeof e == "string" ? e : e.name;
+	for (let [e, w] of Object.entries(x?.colorReplacements || {})) typeof w == "string" ? S[e] = w : e === C && Object.assign(S, w);
+	return S;
 }
-function o(e, t) {
-	return e && (t?.[e?.toLowerCase()] || e);
+function applyColorReplacements(e, x) {
+	return e && (x?.[e?.toLowerCase()] || e);
 }
-function s(e) {
+function toArray(e) {
 	return Array.isArray(e) ? e : [e];
 }
-async function c(e) {
+async function normalizeGetter(e) {
 	return Promise.resolve(typeof e == "function" ? e() : e).then((e) => e.default || e);
 }
-function l(e) {
+function isPlainLang(e) {
 	return !e || [
 		"plaintext",
 		"txt",
@@ -23,96 +22,96 @@ function l(e) {
 		"plain"
 	].includes(e);
 }
-function u(e) {
-	return e === "ansi" || l(e);
+function isSpecialLang(e) {
+	return e === "ansi" || isPlainLang(e);
 }
-function d(e) {
+function isNoneTheme(e) {
 	return e === "none";
 }
-function f(e) {
-	return d(e);
+function isSpecialTheme(e) {
+	return isNoneTheme(e);
 }
-function p(e, t = !1) {
+function splitLines(e, x = !1) {
 	if (e.length === 0) return [["", 0]];
-	let n = e.split(/(\r?\n)/g), r = 0, i = [];
-	for (let e = 0; e < n.length; e += 2) {
-		let a = t ? n[e] + (n[e + 1] || "") : n[e];
-		i.push([a, r]), r += n[e].length, r += n[e + 1]?.length || 0;
+	let S = e.split(/(\r?\n)/g), C = 0, w = [];
+	for (let e = 0; e < S.length; e += 2) {
+		let T = x ? S[e] + (S[e + 1] || "") : S[e];
+		w.push([T, C]), C += S[e].length, C += S[e + 1]?.length || 0;
 	}
-	return i;
+	return w;
 }
-var m = {
+var VSCODE_FALLBACK_EDITOR_FG = {
 	light: "#333333",
 	dark: "#bbbbbb"
-}, h = {
+}, VSCODE_FALLBACK_EDITOR_BG = {
 	light: "#fffffe",
 	dark: "#1e1e1e"
-}, g = "__shiki_resolved";
-function _(e) {
-	if (e?.[g]) return e;
-	let t = { ...e };
-	t.tokenColors && !t.settings && (t.settings = t.tokenColors, delete t.tokenColors), t.type ||= "dark", t.colorReplacements = { ...t.colorReplacements }, t.settings ||= [];
-	let { bg: n, fg: r } = t;
-	if (!n || !r) {
-		let e = t.settings ? t.settings.find((e) => !e.name && !e.scope) : void 0;
-		e?.settings?.foreground && (r = e.settings.foreground), e?.settings?.background && (n = e.settings.background), !r && t?.colors?.["editor.foreground"] && (r = t.colors["editor.foreground"]), !n && t?.colors?.["editor.background"] && (n = t.colors["editor.background"]), r ||= t.type === "light" ? m.light : m.dark, n ||= t.type === "light" ? h.light : h.dark, t.fg = r, t.bg = n;
-	}
-	t.settings[0] && t.settings[0].settings && !t.settings[0].scope || t.settings.unshift({ settings: {
-		foreground: t.fg,
-		background: t.bg
+}, RESOLVED_KEY = "__shiki_resolved";
+function normalizeTheme(e) {
+	if (e?.[RESOLVED_KEY]) return e;
+	let x = { ...e };
+	x.tokenColors && !x.settings && (x.settings = x.tokenColors, delete x.tokenColors), x.type ||= "dark", x.colorReplacements = { ...x.colorReplacements }, x.settings ||= [];
+	let { bg: S, fg: C } = x;
+	if (!S || !C) {
+		let e = x.settings ? x.settings.find((e) => !e.name && !e.scope) : void 0;
+		e?.settings?.foreground && (C = e.settings.foreground), e?.settings?.background && (S = e.settings.background), !C && x?.colors?.["editor.foreground"] && (C = x.colors["editor.foreground"]), !S && x?.colors?.["editor.background"] && (S = x.colors["editor.background"]), C ||= x.type === "light" ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark, S ||= x.type === "light" ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark, x.fg = C, x.bg = S;
+	}
+	x.settings[0] && x.settings[0].settings && !x.settings[0].scope || x.settings.unshift({ settings: {
+		foreground: x.fg,
+		background: x.bg
 	} });
-	let i = 0, a = /* @__PURE__ */ new Map();
-	function o(e) {
-		if (a.has(e)) return a.get(e);
-		i += 1;
-		let n = `#${i.toString(16).padStart(8, "0").toLowerCase()}`;
-		return t.colorReplacements?.[`#${n}`] ? o(e) : (a.set(e, n), n);
-	}
-	t.settings = t.settings.map((e) => {
-		let n = e.settings?.foreground && !e.settings.foreground.startsWith("#"), r = e.settings?.background && !e.settings.background.startsWith("#");
-		if (!n && !r) return e;
-		let i = {
+	let w = 0, T = /* @__PURE__ */ new Map();
+	function E(e) {
+		if (T.has(e)) return T.get(e);
+		w += 1;
+		let S = `#${w.toString(16).padStart(8, "0").toLowerCase()}`;
+		return x.colorReplacements?.[`#${S}`] ? E(e) : (T.set(e, S), S);
+	}
+	x.settings = x.settings.map((e) => {
+		let S = e.settings?.foreground && !e.settings.foreground.startsWith("#"), C = e.settings?.background && !e.settings.background.startsWith("#");
+		if (!S && !C) return e;
+		let w = {
 			...e,
 			settings: { ...e.settings }
 		};
-		if (n) {
-			let n = o(e.settings.foreground);
-			t.colorReplacements[n] = e.settings.foreground, i.settings.foreground = n;
+		if (S) {
+			let S = E(e.settings.foreground);
+			x.colorReplacements[S] = e.settings.foreground, w.settings.foreground = S;
 		}
-		if (r) {
-			let n = o(e.settings.background);
-			t.colorReplacements[n] = e.settings.background, i.settings.background = n;
+		if (C) {
+			let S = E(e.settings.background);
+			x.colorReplacements[S] = e.settings.background, w.settings.background = S;
 		}
-		return i;
+		return w;
 	});
-	for (let e of Object.keys(t.colors || {})) if ((e === "editor.foreground" || e === "editor.background" || e.startsWith("terminal.ansi")) && !t.colors[e]?.startsWith("#")) {
-		let n = o(t.colors[e]);
-		t.colorReplacements[n] = t.colors[e], t.colors[e] = n;
+	for (let e of Object.keys(x.colors || {})) if ((e === "editor.foreground" || e === "editor.background" || e.startsWith("terminal.ansi")) && !x.colors[e]?.startsWith("#")) {
+		let S = E(x.colors[e]);
+		x.colorReplacements[S] = x.colors[e], x.colors[e] = S;
 	}
-	return Object.defineProperty(t, g, {
+	return Object.defineProperty(x, RESOLVED_KEY, {
 		enumerable: !1,
 		writable: !1,
 		value: !0
-	}), t;
+	}), x;
 }
-async function v(e) {
-	return Array.from(new Set((await Promise.all(e.filter((e) => !u(e)).map(async (e) => await c(e).then((e) => Array.isArray(e) ? e : [e])))).flat()));
+async function resolveLangs(e) {
+	return Array.from(new Set((await Promise.all(e.filter((e) => !isSpecialLang(e)).map(async (e) => await normalizeGetter(e).then((e) => Array.isArray(e) ? e : [e])))).flat()));
 }
-async function y(e) {
-	return (await Promise.all(e.map(async (e) => f(e) ? null : _(await c(e))))).filter((e) => !!e);
+async function resolveThemes(e) {
+	return (await Promise.all(e.map(async (e) => isSpecialTheme(e) ? null : normalizeTheme(await normalizeGetter(e))))).filter((e) => !!e);
 }
-function b(t, n) {
-	if (!n) return t;
-	if (n[t]) {
-		let r = new Set([t]);
-		for (; n[t];) {
-			if (t = n[t], r.has(t)) throw new e(`Circular alias \`${Array.from(r).join(" -> ")} -> ${t}\``);
-			r.add(t);
+function resolveLangAlias(x, S) {
+	if (!S) return x;
+	if (S[x]) {
+		let C = new Set([x]);
+		for (; S[x];) {
+			if (x = S[x], C.has(x)) throw new ShikiError(`Circular alias \`${Array.from(C).join(" -> ")} -> ${x}\``);
+			C.add(x);
 		}
 	}
-	return t;
+	return x;
 }
-var x = class extends r {
+var Registry$1 = class extends Registry {
 	_resolvedThemes = /* @__PURE__ */ new Map();
 	_resolvedGrammars = /* @__PURE__ */ new Map();
 	_langMap = /* @__PURE__ */ new Map();
@@ -120,71 +119,71 @@ var x = class extends r {
 	_textmateThemeCache = /* @__PURE__ */ new WeakMap();
 	_loadedThemesCache = null;
 	_loadedLanguagesCache = null;
-	constructor(e, t, n, r = {}) {
-		super(e), this._resolver = e, this._themes = t, this._langs = n, this._alias = r, this._themes.map((e) => this.loadTheme(e)), this.loadLanguages(this._langs);
+	constructor(e, x, S, C = {}) {
+		super(e), this._resolver = e, this._themes = x, this._langs = S, this._alias = C, this._themes.map((e) => this.loadTheme(e)), this.loadLanguages(this._langs);
 	}
 	getTheme(e) {
 		return typeof e == "string" ? this._resolvedThemes.get(e) : this.loadTheme(e);
 	}
 	loadTheme(e) {
-		let t = _(e);
-		return t.name && (this._resolvedThemes.set(t.name, t), this._loadedThemesCache = null), t;
+		let x = normalizeTheme(e);
+		return x.name && (this._resolvedThemes.set(x.name, x), this._loadedThemesCache = null), x;
 	}
 	getLoadedThemes() {
 		return this._loadedThemesCache ||= [...this._resolvedThemes.keys()], this._loadedThemesCache;
 	}
 	setTheme(e) {
-		let t = this._textmateThemeCache.get(e);
-		t || (t = i.createFromRawTheme(e), this._textmateThemeCache.set(e, t)), this._syncRegistry.setTheme(t);
+		let x = this._textmateThemeCache.get(e);
+		x || (x = Theme.createFromRawTheme(e), this._textmateThemeCache.set(e, x)), this._syncRegistry.setTheme(x);
 	}
 	getGrammar(e) {
-		return e = b(e, this._alias), this._resolvedGrammars.get(e);
+		return e = resolveLangAlias(e, this._alias), this._resolvedGrammars.get(e);
 	}
 	loadLanguage(e) {
 		if (this.getGrammar(e.name)) return;
-		let t = new Set([...this._langMap.values()].filter((t) => t.embeddedLangsLazy?.includes(e.name)));
+		let x = new Set([...this._langMap.values()].filter((x) => x.embeddedLangsLazy?.includes(e.name)));
 		this._resolver.addLanguage(e);
-		let n = {
+		let S = {
 			balancedBracketSelectors: e.balancedBracketSelectors || ["*"],
 			unbalancedBracketSelectors: e.unbalancedBracketSelectors || []
 		};
 		this._syncRegistry._rawGrammars.set(e.scopeName, e);
-		let r = this.loadGrammarWithConfiguration(e.scopeName, 1, n);
-		if (r.name = e.name, this._resolvedGrammars.set(e.name, r), e.aliases && e.aliases.forEach((t) => {
-			this._alias[t] = e.name;
-		}), this._loadedLanguagesCache = null, t.size) for (let e of t) this._resolvedGrammars.delete(e.name), this._loadedLanguagesCache = null, this._syncRegistry?._injectionGrammars?.delete(e.scopeName), this._syncRegistry?._grammars?.delete(e.scopeName), this.loadLanguage(this._langMap.get(e.name));
+		let C = this.loadGrammarWithConfiguration(e.scopeName, 1, S);
+		if (C.name = e.name, this._resolvedGrammars.set(e.name, C), e.aliases && e.aliases.forEach((x) => {
+			this._alias[x] = e.name;
+		}), this._loadedLanguagesCache = null, x.size) for (let e of x) this._resolvedGrammars.delete(e.name), this._loadedLanguagesCache = null, this._syncRegistry?._injectionGrammars?.delete(e.scopeName), this._syncRegistry?._grammars?.delete(e.scopeName), this.loadLanguage(this._langMap.get(e.name));
 	}
 	dispose() {
 		super.dispose(), this._resolvedThemes.clear(), this._resolvedGrammars.clear(), this._langMap.clear(), this._langGraph.clear(), this._loadedThemesCache = null;
 	}
-	loadLanguages(t) {
-		for (let e of t) this.resolveEmbeddedLanguages(e);
-		let n = Array.from(this._langGraph.entries()), r = n.filter(([e, t]) => !t);
-		if (r.length) {
-			let t = n.filter(([e, t]) => t ? (t.embeddedLanguages || t.embeddedLangs)?.some((e) => r.map(([e]) => e).includes(e)) : !1).filter((e) => !r.includes(e));
-			throw new e(`Missing languages ${r.map(([e]) => `\`${e}\``).join(", ")}, required by ${t.map(([e]) => `\`${e}\``).join(", ")}`);
+	loadLanguages(x) {
+		for (let e of x) this.resolveEmbeddedLanguages(e);
+		let S = Array.from(this._langGraph.entries()), C = S.filter(([e, x]) => !x);
+		if (C.length) {
+			let x = S.filter(([e, x]) => x ? (x.embeddedLanguages || x.embeddedLangs)?.some((e) => C.map(([e]) => e).includes(e)) : !1).filter((e) => !C.includes(e));
+			throw new ShikiError(`Missing languages ${C.map(([e]) => `\`${e}\``).join(", ")}, required by ${x.map(([e]) => `\`${e}\``).join(", ")}`);
 		}
-		for (let [e, t] of n) this._resolver.addLanguage(t);
-		for (let [e, t] of n) this.loadLanguage(t);
+		for (let [e, x] of S) this._resolver.addLanguage(x);
+		for (let [e, x] of S) this.loadLanguage(x);
 	}
 	getLoadedLanguages() {
 		return this._loadedLanguagesCache ||= [...new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])], this._loadedLanguagesCache;
 	}
 	resolveEmbeddedLanguages(e) {
 		this._langMap.set(e.name, e), this._langGraph.set(e.name, e);
-		let t = e.embeddedLanguages ?? e.embeddedLangs;
-		if (t) for (let e of t) this._langGraph.set(e, this._langMap.get(e));
+		let x = e.embeddedLanguages ?? e.embeddedLangs;
+		if (x) for (let e of x) this._langGraph.set(e, this._langMap.get(e));
 	}
-}, S = class {
+}, Resolver = class {
 	_langs = /* @__PURE__ */ new Map();
 	_scopeToLang = /* @__PURE__ */ new Map();
 	_injections = /* @__PURE__ */ new Map();
 	_onigLib;
-	constructor(e, t) {
+	constructor(e, x) {
 		this._onigLib = {
-			createOnigScanner: (t) => e.createScanner(t),
-			createOnigString: (t) => e.createString(t)
-		}, t.forEach((e) => this.addLanguage(e));
+			createOnigScanner: (x) => e.createScanner(x),
+			createOnigString: (x) => e.createString(x)
+		}, x.forEach((e) => this.addLanguage(e));
 	}
 	get onigLib() {
 		return this._onigLib;
@@ -196,118 +195,118 @@ var x = class extends r {
 		return this._scopeToLang.get(e);
 	}
 	addLanguage(e) {
-		this._langs.set(e.name, e), e.aliases && e.aliases.forEach((t) => {
-			this._langs.set(t, e);
-		}), this._scopeToLang.set(e.scopeName, e), e.injectTo && e.injectTo.forEach((t) => {
-			this._injections.get(t) || this._injections.set(t, []), this._injections.get(t).push(e.scopeName);
+		this._langs.set(e.name, e), e.aliases && e.aliases.forEach((x) => {
+			this._langs.set(x, e);
+		}), this._scopeToLang.set(e.scopeName, e), e.injectTo && e.injectTo.forEach((x) => {
+			this._injections.get(x) || this._injections.set(x, []), this._injections.get(x).push(e.scopeName);
 		});
 	}
 	getInjections(e) {
-		let t = e.split("."), n = [];
-		for (let e = 1; e <= t.length; e++) {
-			let r = t.slice(0, e).join(".");
-			n = [...n, ...this._injections.get(r) || []];
+		let x = e.split("."), S = [];
+		for (let e = 1; e <= x.length; e++) {
+			let C = x.slice(0, e).join(".");
+			S = [...S, ...this._injections.get(C) || []];
 		}
-		return n;
-	}
-}, C = 0;
-function w(t) {
-	C += 1, t.warnings !== !1 && C >= 10 && C % 10 == 0 && console.warn(`[Shiki] ${C} 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 n = !1;
-	if (!t.engine) throw new e("`engine` option is required for synchronous mode");
-	let r = (t.langs || []).flat(1), i = (t.themes || []).flat(1).map(_), a = new x(new S(t.engine, r), i, r, t.langAlias), o;
-	function s(e) {
-		return b(e, t.langAlias);
-	}
-	function c(t) {
-		w();
-		let n = a.getGrammar(typeof t == "string" ? t : t.name);
-		if (!n) throw new e(`Language \`${t}\` not found, you may need to load it first`);
-		return n;
-	}
-	function l(t) {
-		if (t === "none") return {
+		return S;
+	}
+}, instancesCount = 0;
+function createShikiPrimitive(x) {
+	instancesCount += 1, x.warnings !== !1 && 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 S = !1;
+	if (!x.engine) throw new ShikiError("`engine` option is required for synchronous mode");
+	let C = (x.langs || []).flat(1), w = (x.themes || []).flat(1).map(normalizeTheme), T = new Registry$1(new Resolver(x.engine, C), w, C, x.langAlias), E;
+	function D(e) {
+		return resolveLangAlias(e, x.langAlias);
+	}
+	function O(x) {
+		V();
+		let S = T.getGrammar(typeof x == "string" ? x : x.name);
+		if (!S) throw new ShikiError(`Language \`${x}\` not found, you may need to load it first`);
+		return S;
+	}
+	function k(x) {
+		if (x === "none") return {
 			bg: "",
 			fg: "",
 			name: "none",
 			settings: [],
 			type: "dark"
 		};
-		w();
-		let n = a.getTheme(t);
-		if (!n) throw new e(`Theme \`${t}\` not found, you may need to load it first`);
-		return n;
-	}
-	function u(e) {
-		w();
-		let t = l(e);
-		return o !== e && (a.setTheme(t), o = e), {
-			theme: t,
-			colorMap: a.getColorMap()
+		V();
+		let S = T.getTheme(x);
+		if (!S) throw new ShikiError(`Theme \`${x}\` not found, you may need to load it first`);
+		return S;
+	}
+	function A(e) {
+		V();
+		let x = k(e);
+		return E !== e && (T.setTheme(x), E = e), {
+			theme: x,
+			colorMap: T.getColorMap()
 		};
 	}
-	function d() {
-		return w(), a.getLoadedThemes();
+	function j() {
+		return V(), T.getLoadedThemes();
 	}
-	function f() {
-		return w(), a.getLoadedLanguages();
+	function M() {
+		return V(), T.getLoadedLanguages();
 	}
-	function p(...e) {
-		w(), a.loadLanguages(e.flat(1));
+	function N(...e) {
+		V(), T.loadLanguages(e.flat(1));
 	}
-	async function m(...e) {
-		return p(await v(e));
+	async function P(...e) {
+		return N(await resolveLangs(e));
 	}
-	function h(...e) {
-		w();
-		for (let t of e.flat(1)) a.loadTheme(t);
+	function F(...e) {
+		V();
+		for (let x of e.flat(1)) T.loadTheme(x);
 	}
-	async function g(...e) {
-		return w(), h(await y(e));
+	async function I(...e) {
+		return V(), F(await resolveThemes(e));
 	}
-	function w() {
-		if (n) throw new e("Shiki instance has been disposed");
+	function V() {
+		if (S) throw new ShikiError("Shiki instance has been disposed");
 	}
-	function T() {
-		n || (n = !0, a.dispose(), --C);
+	function H() {
+		S || (S = !0, T.dispose(), --instancesCount);
 	}
 	return {
-		setTheme: u,
-		getTheme: l,
-		getLanguage: c,
-		getLoadedThemes: d,
-		getLoadedLanguages: f,
-		resolveLangAlias: s,
-		loadLanguage: m,
-		loadLanguageSync: p,
-		loadTheme: g,
-		loadThemeSync: h,
-		dispose: T,
-		[Symbol.dispose]: T
+		setTheme: A,
+		getTheme: k,
+		getLanguage: O,
+		getLoadedThemes: j,
+		getLoadedLanguages: M,
+		resolveLangAlias: D,
+		loadLanguage: P,
+		loadLanguageSync: N,
+		loadTheme: I,
+		loadThemeSync: F,
+		dispose: H,
+		[Symbol.dispose]: H
 	};
 }
-async function T(e) {
+async function createShikiPrimitiveAsync(e) {
 	e.engine || console.warn("`engine` option is required. Use `createOnigurumaEngine` or `createJavaScriptRegexEngine` to create an engine.");
-	let [t, n, r] = await Promise.all([
-		y(e.themes || []),
-		v(e.langs || []),
+	let [x, S, C] = await Promise.all([
+		resolveThemes(e.themes || []),
+		resolveLangs(e.langs || []),
 		e.engine
 	]);
-	return w({
+	return createShikiPrimitive({
 		...e,
-		themes: t,
-		langs: n,
-		engine: r
+		themes: x,
+		langs: S,
+		engine: C
 	});
 }
-var E = /* @__PURE__ */ new WeakMap();
-function D(e, t) {
-	E.set(e, t);
+var _grammarStateMap = /* @__PURE__ */ new WeakMap();
+function setLastGrammarStateToMap(e, x) {
+	_grammarStateMap.set(e, x);
 }
-function O(e) {
-	return E.get(e);
+function getLastGrammarStateFromMap(e) {
+	return _grammarStateMap.get(e);
 }
-var k = class e {
+var GrammarState = class e {
 	_stacks = {};
 	lang;
 	get themes() {
@@ -319,23 +318,23 @@ var k = class e {
 	get _stack() {
 		return this._stacks[this.theme];
 	}
-	static initial(t, r) {
-		return new e(Object.fromEntries(s(r).map((e) => [e, n])), t);
+	static initial(x, C) {
+		return new e(Object.fromEntries(toArray(C).map((e) => [e, INITIAL])), x);
 	}
 	constructor(...e) {
 		if (e.length === 2) {
-			let [t, n] = e;
-			this.lang = n, this._stacks = t;
+			let [x, S] = e;
+			this.lang = S, this._stacks = x;
 		} else {
-			let [t, n, r] = e;
-			this.lang = n, this._stacks = { [r]: t };
+			let [x, S, C] = e;
+			this.lang = S, this._stacks = { [C]: x };
 		}
 	}
 	getInternalStack(e = this.theme) {
 		return this._stacks[e];
 	}
 	getScopes(e = this.theme) {
-		return A(this._stacks[e]);
+		return getScopes(this._stacks[e]);
 	}
 	toJSON() {
 		return {
@@ -346,195 +345,194 @@ var k = class e {
 		};
 	}
 };
-function A(e) {
-	let t = [], n = /* @__PURE__ */ new Set();
-	function r(e) {
-		if (n.has(e)) return;
-		n.add(e);
-		let i = e?.nameScopesList?.scopeName;
-		i && t.push(i), e.parent && r(e.parent);
-	}
-	return r(e), t;
+function getScopes(e) {
+	let x = [], S = /* @__PURE__ */ new Set();
+	function C(e) {
+		if (S.has(e)) return;
+		S.add(e);
+		let w = e?.nameScopesList?.scopeName;
+		w && x.push(w), e.parent && C(e.parent);
+	}
+	return C(e), x;
 }
-function j(t, n) {
-	if (!(t instanceof k)) throw new e("Invalid grammar state");
-	return t.getInternalStack(n);
+function getGrammarStack(x, S) {
+	if (!(x instanceof GrammarState)) throw new ShikiError("Invalid grammar state");
+	return x.getInternalStack(S);
 }
-function M(t, n, r = {}) {
-	let { theme: i = t.getLoadedThemes()[0] } = r;
-	if (l(t.resolveLangAlias(r.lang || "text")) || d(i)) return p(n).map((e) => [{
+function codeToTokensBase(x, S, C = {}) {
+	let { theme: w = x.getLoadedThemes()[0] } = C;
+	if (isPlainLang(x.resolveLangAlias(C.lang || "text")) || isNoneTheme(w)) return splitLines(S).map((e) => [{
 		content: e[0],
 		offset: e[1]
 	}]);
-	let { theme: a, colorMap: o } = t.setTheme(i), s = t.getLanguage(r.lang || "text");
-	if (r.grammarState) {
-		if (r.grammarState.lang !== s.name) throw new e(`Grammar state language "${r.grammarState.lang}" does not match highlight language "${s.name}"`);
-		if (!r.grammarState.themes.includes(a.name)) throw new e(`Grammar state themes "${r.grammarState.themes}" do not contain highlight theme "${a.name}"`);
+	let { theme: T, colorMap: E } = x.setTheme(w), D = x.getLanguage(C.lang || "text");
+	if (C.grammarState) {
+		if (C.grammarState.lang !== D.name) throw new ShikiError(`Grammar state language "${C.grammarState.lang}" does not match highlight language "${D.name}"`);
+		if (!C.grammarState.themes.includes(T.name)) throw new ShikiError(`Grammar state themes "${C.grammarState.themes}" do not contain highlight theme "${T.name}"`);
 	}
-	return P(n, s, a, o, r);
+	return tokenizeWithTheme(S, D, T, E, C);
 }
-function N(...t) {
-	if (t.length === 2) return O(t[1]);
-	let [n, r, i = {}] = t, { lang: a = "text", theme: o = n.getLoadedThemes()[0] } = i;
-	if (l(a) || d(o)) throw new e("Plain language does not have grammar state");
-	if (a === "ansi") throw new e("ANSI language does not have grammar state");
-	let { theme: s, colorMap: c } = n.setTheme(o), u = n.getLanguage(a);
-	return new k(F(r, u, s, c, i).stateStack, u.name, s.name);
+function getLastGrammarState(...x) {
+	if (x.length === 2) return getLastGrammarStateFromMap(x[1]);
+	let [S, C, w = {}] = x, { lang: T = "text", theme: E = S.getLoadedThemes()[0] } = w;
+	if (isPlainLang(T) || isNoneTheme(E)) throw new ShikiError("Plain language does not have grammar state");
+	if (T === "ansi") throw new ShikiError("ANSI language does not have grammar state");
+	let { theme: D, colorMap: O } = S.setTheme(E), A = S.getLanguage(T);
+	return new GrammarState(_tokenizeWithTheme(C, A, D, O, w).stateStack, A.name, D.name);
 }
-function P(e, t, n, r, i) {
-	let a = F(e, t, n, r, i), o = new k(a.stateStack, t.name, n.name);
-	return D(a.tokens, o), a.tokens;
+function tokenizeWithTheme(e, x, S, C, w) {
+	let T = _tokenizeWithTheme(e, x, S, C, w), E = new GrammarState(T.stateStack, x.name, S.name);
+	return setLastGrammarStateToMap(T.tokens, E), T.tokens;
 }
-function F(e, r, i, s, c) {
-	let l = a(i, c), { tokenizeMaxLineLength: u = 0, tokenizeTimeLimit: d = 500 } = c, f = p(e), m = c.grammarState ? j(c.grammarState, i.name) ?? n : c.grammarContextCode == null ? n : F(c.grammarContextCode, r, i, s, {
-		...c,
+function _tokenizeWithTheme(e, C, w, D, O) {
+	let k = resolveColorReplacements(w, O), { tokenizeMaxLineLength: A = 0, tokenizeTimeLimit: j = 500 } = O, M = splitLines(e), P = O.grammarState ? getGrammarStack(O.grammarState, w.name) ?? INITIAL : O.grammarContextCode == null ? INITIAL : _tokenizeWithTheme(O.grammarContextCode, C, w, D, {
+		...O,
 		grammarState: void 0,
 		grammarContextCode: void 0
-	}).stateStack, h = [], g = [];
-	for (let e = 0, n = f.length; e < n; e++) {
-		let [n, a] = f[e];
-		if (n === "") {
-			h = [], g.push([]);
+	}).stateStack, F = [], I = [];
+	for (let e = 0, S = M.length; e < S; e++) {
+		let [S, T] = M[e];
+		if (S === "") {
+			F = [], I.push([]);
 			continue;
 		}
-		if (u > 0 && n.length >= u) {
-			h = [], g.push([{
-				content: n,
-				offset: a,
+		if (A > 0 && S.length >= A) {
+			F = [], I.push([{
+				content: S,
+				offset: T,
 				color: "",
 				fontStyle: 0
 			}]);
 			continue;
 		}
-		let p, _, v;
-		c.includeExplanation && (p = r.tokenizeLine(n, m, d), _ = p.tokens, v = 0);
-		let y = r.tokenizeLine2(n, m, d), b = y.tokens.length / 2;
-		for (let e = 0; e < b; e++) {
-			let r = y.tokens[2 * e], u = e + 1 < b ? y.tokens[2 * e + 2] : n.length;
-			if (r === u) continue;
-			let d = y.tokens[2 * e + 1], f = o(s[t.getForeground(d)], l), p = t.getFontStyle(d), m = {
-				content: n.substring(r, u),
-				offset: a + r,
-				color: f,
-				fontStyle: p
+		let N, L, R;
+		O.includeExplanation && (N = C.tokenizeLine(S, P, j), L = N.tokens, R = 0);
+		let z = C.tokenizeLine2(S, P, j), B = z.tokens.length / 2;
+		for (let e = 0; e < B; e++) {
+			let C = z.tokens[2 * e], A = e + 1 < B ? z.tokens[2 * e + 2] : S.length;
+			if (C === A) continue;
+			let j = z.tokens[2 * e + 1], M = applyColorReplacements(D[EncodedTokenMetadata.getForeground(j)], k), N = EncodedTokenMetadata.getFontStyle(j), P = {
+				content: S.substring(C, A),
+				offset: T + C,
+				color: M,
+				fontStyle: N
 			};
-			if (c.includeExplanation) {
+			if (O.includeExplanation) {
 				let e = [];
-				if (c.includeExplanation !== "scopeName") for (let t of i.settings) {
-					let n;
-					switch (typeof t.scope) {
+				if (O.includeExplanation !== "scopeName") for (let x of w.settings) {
+					let S;
+					switch (typeof x.scope) {
 						case "string":
-							n = t.scope.split(/,/).map((e) => e.trim());
+							S = x.scope.split(/,/).map((e) => e.trim());
 							break;
 						case "object":
-							n = t.scope;
+							S = x.scope;
 							break;
 						default: continue;
 					}
 					e.push({
-						settings: t,
-						selectors: n.map((e) => e.split(/ /))
+						settings: x,
+						selectors: S.map((e) => e.split(/ /))
 					});
 				}
-				m.explanation = [];
-				let t = 0;
-				for (; r + t < u;) {
-					let r = _[v], i = n.substring(r.startIndex, r.endIndex);
-					t += i.length, m.explanation.push({
-						content: i,
-						scopes: c.includeExplanation === "scopeName" ? I(r.scopes) : L(e, r.scopes)
-					}), v += 1;
+				P.explanation = [];
+				let x = 0;
+				for (; C + x < A;) {
+					let C = L[R], w = S.substring(C.startIndex, C.endIndex);
+					x += w.length, P.explanation.push({
+						content: w,
+						scopes: O.includeExplanation === "scopeName" ? explainThemeScopesNameOnly(C.scopes) : explainThemeScopesFull(e, C.scopes)
+					}), R += 1;
 				}
 			}
-			h.push(m);
+			F.push(P);
 		}
-		g.push(h), h = [], m = y.ruleStack;
+		I.push(F), F = [], P = z.ruleStack;
 	}
 	return {
-		tokens: g,
-		stateStack: m
+		tokens: I,
+		stateStack: P
 	};
 }
-function I(e) {
+function explainThemeScopesNameOnly(e) {
 	return e.map((e) => ({ scopeName: e }));
 }
-function L(e, t) {
-	let n = [];
-	for (let r = 0, i = t.length; r < i; r++) {
-		let i = t[r];
-		n[r] = {
-			scopeName: i,
-			themeMatches: B(e, i, t.slice(0, r))
+function explainThemeScopesFull(e, x) {
+	let S = [];
+	for (let C = 0, w = x.length; C < w; C++) {
+		let w = x[C];
+		S[C] = {
+			scopeName: w,
+			themeMatches: explainThemeScope(e, w, x.slice(0, C))
 		};
 	}
-	return n;
+	return S;
 }
-function R(e, t) {
-	return e === t || t.substring(0, e.length) === e && t[e.length] === ".";
+function matchesOne(e, x) {
+	return e === x || x.substring(0, e.length) === e && x[e.length] === ".";
 }
-function z(e, t, n) {
-	if (!R(e[e.length - 1], t)) return !1;
-	let r = e.length - 2, i = n.length - 1;
-	for (; r >= 0 && i >= 0;) R(e[r], n[i]) && --r, --i;
-	return r === -1;
+function matches(e, x, S) {
+	if (!matchesOne(e[e.length - 1], x)) return !1;
+	let C = e.length - 2, w = S.length - 1;
+	for (; C >= 0 && w >= 0;) matchesOne(e[C], S[w]) && --C, --w;
+	return C === -1;
 }
-function B(e, t, n) {
-	let r = [];
-	for (let { selectors: i, settings: a } of e) for (let e of i) if (z(e, t, n)) {
-		r.push(a);
+function explainThemeScope(e, x, S) {
+	let C = [];
+	for (let { selectors: w, settings: T } of e) for (let e of w) if (matches(e, x, S)) {
+		C.push(T);
 		break;
 	}
-	return r;
+	return C;
 }
-function V(e, t, n, r = M) {
-	let i = Object.entries(n.themes).filter((e) => e[1]).map((e) => ({
+function codeToTokensWithThemes(e, x, S, C = codeToTokensBase) {
+	let w = Object.entries(S.themes).filter((e) => e[1]).map((e) => ({
 		color: e[0],
 		theme: e[1]
-	})), a = i.map((i) => {
-		let a = r(e, t, {
-			...n,
-			theme: i.theme
+	})), T = w.map((w) => {
+		let T = C(e, x, {
+			...S,
+			theme: w.theme
 		});
 		return {
-			tokens: a,
-			state: O(a),
-			theme: typeof i.theme == "string" ? i.theme : i.theme.name
+			tokens: T,
+			state: getLastGrammarStateFromMap(T),
+			theme: typeof w.theme == "string" ? w.theme : w.theme.name
 		};
-	}), o = H(...a.map((e) => e.tokens)), s = o[0].map((e, t) => e.map((e, r) => {
-		let a = {
+	}), E = alignThemesTokenization(...T.map((e) => e.tokens)), D = E[0].map((e, x) => e.map((e, C) => {
+		let T = {
 			content: e.content,
 			variants: {},
 			offset: e.offset
 		};
-		return "includeExplanation" in n && n.includeExplanation && (a.explanation = e.explanation), o.forEach((e, n) => {
-			let { content: o, explanation: s, offset: c, ...l } = e[t][r];
-			a.variants[i[n].color] = l;
-		}), a;
-	})), c = a[0].state ? new k(Object.fromEntries(a.map((e) => [e.theme, e.state?.getInternalStack(e.theme)])), a[0].state.lang) : void 0;
-	return c && D(s, c), s;
+		return "includeExplanation" in S && S.includeExplanation && (T.explanation = e.explanation), E.forEach((e, S) => {
+			let { content: E, explanation: D, offset: O, ...k } = e[x][C];
+			T.variants[w[S].color] = k;
+		}), T;
+	})), O = T[0].state ? new GrammarState(Object.fromEntries(T.map((e) => [e.theme, e.state?.getInternalStack(e.theme)])), T[0].state.lang) : void 0;
+	return O && setLastGrammarStateToMap(D, O), D;
 }
-function H(...e) {
-	let t = e.map(() => []), n = e.length;
-	for (let r = 0; r < e[0].length; r++) {
-		let i = e.map((e) => e[r]), a = t.map(() => []);
-		t.forEach((e, t) => e.push(a[t]));
-		let o = i.map(() => 0), s = i.map((e) => e[0]);
-		for (; s.every((e) => e);) {
-			let e = Math.min(...s.map((e) => e.content.length));
-			for (let t = 0; t < n; t++) {
-				let n = s[t];
-				n.content.length === e ? (a[t].push(n), o[t] += 1, s[t] = i[t][o[t]]) : (a[t].push({
-					...n,
-					content: n.content.slice(0, e)
-				}), s[t] = {
-					...n,
-					content: n.content.slice(e),
-					offset: n.offset + e
+function alignThemesTokenization(...e) {
+	let x = e.map(() => []), S = e.length;
+	for (let C = 0; C < e[0].length; C++) {
+		let w = e.map((e) => e[C]), T = x.map(() => []);
+		x.forEach((e, x) => e.push(T[x]));
+		let E = w.map(() => 0), D = w.map((e) => e[0]);
+		for (; D.every((e) => e);) {
+			let e = Math.min(...D.map((e) => e.content.length));
+			for (let x = 0; x < S; x++) {
+				let S = D[x];
+				S.content.length === e ? (T[x].push(S), E[x] += 1, D[x] = w[x][E[x]]) : (T[x].push({
+					...S,
+					content: S.content.slice(0, e)
+				}), D[x] = {
+					...S,
+					content: S.content.slice(e),
+					offset: S.offset + e
 				});
 			}
 		}
 	}
-	return t;
+	return x;
 }
-//#endregion
-export { o as applyColorReplacements, M as codeToTokensBase, V as codeToTokensWithThemes, w as createShikiPrimitive, T as createShikiPrimitiveAsync, N as getLastGrammarState, O as getLastGrammarStateFromMap, d as isNoneTheme, l as isPlainLang, u as isSpecialLang, f as isSpecialTheme, c as normalizeGetter, _ as normalizeTheme, a as resolveColorReplacements, D as setLastGrammarStateToMap, p as splitLines, s as toArray, P as tokenizeWithTheme };
+export { applyColorReplacements, codeToTokensBase, codeToTokensWithThemes, createShikiPrimitive, createShikiPrimitiveAsync, getLastGrammarState, getLastGrammarStateFromMap, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, setLastGrammarStateToMap, splitLines, toArray, tokenizeWithTheme };