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

package/dist/ui/node_modules/.pnpm/@shikijs_primitive@4.0.2/node_modules/@shikijs/primitive/dist/index.qwik.mjs

@@ -1,798 +1,729 @@
-import { _defineProperty } from "../../../../../../../_virtual/_@oxc-project_runtime@0.115.0/helpers/defineProperty.qwik.mjs";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { ShikiError } from "../../../../../@shikijs_types@4.0.2/node_modules/@shikijs/types/dist/index.qwik.mjs";
-import { EncodedTokenMetadata, INITIAL, Registry as Registry$1, Theme } from "../../../../../@shikijs_vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.qwik.mjs";
-//#region ../../node_modules/.pnpm/@shikijs+primitive@4.0.2/node_modules/@shikijs/primitive/dist/index.mjs
+import { INITIAL, EncodedTokenMetadata, Registry as Registry$1, Theme } from "../../../../../@shikijs_vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.qwik.mjs";
 function resolveColorReplacements(theme, options) {
-	const replacements = typeof theme === "string" ? {} : { ...theme.colorReplacements };
-	const themeName = typeof theme === "string" ? theme : theme.name;
-	for (const [key, value] of Object.entries(options?.colorReplacements || {})) if (typeof value === "string") replacements[key] = value;
-	else if (key === themeName) Object.assign(replacements, value);
-	return replacements;
+  const replacements = typeof theme === "string" ? {} : { ...theme.colorReplacements };
+  const themeName = typeof theme === "string" ? theme : theme.name;
+  for (const [key, value] of Object.entries(options?.colorReplacements || {})) if (typeof value === "string") replacements[key] = value;
+  else if (key === themeName) Object.assign(replacements, value);
+  return replacements;
 }
 function applyColorReplacements(color, replacements) {
-	if (!color) return color;
-	return replacements?.[color?.toLowerCase()] || color;
+  if (!color) return color;
+  return replacements?.[color?.toLowerCase()] || color;
 }
 function toArray(x) {
-	return Array.isArray(x) ? x : [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);
+  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",
-		"txt",
-		"text",
-		"plain"
-	].includes(lang);
+  return !lang || [
+    "plaintext",
+    "txt",
+    "text",
+    "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);
+  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";
+  return theme === "none";
 }
-/**
-* Check if the theme is specially handled or bypassed by Shiki.
-*
-* Hard-coded themes: `none`.
-*/
 function isSpecialTheme(theme) {
-	return isNoneTheme(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);
-	let index = 0;
-	const lines = [];
-	for (let i = 0; i < parts.length; i += 2) {
-		const line = preserveEnding ? parts[i] + (parts[i + 1] || "") : parts[i];
-		lines.push([line, index]);
-		index += parts[i].length;
-		index += parts[i + 1]?.length || 0;
-	}
-	return lines;
+  if (code.length === 0) return [["", 0]];
+  const parts = code.split(/(\r?\n)/g);
+  let index = 0;
+  const lines = [];
+  for (let i = 0; i < parts.length; i += 2) {
+    const line = preserveEnding ? parts[i] + (parts[i + 1] || "") : parts[i];
+    lines.push([line, index]);
+    index += parts[i].length;
+    index += parts[i + 1]?.length || 0;
+  }
+  return lines;
 }
-/**
-* https://github.com/microsoft/vscode/blob/f7f05dee53fb33fe023db2e06e30a89d3094488f/src/vs/platform/theme/common/colorRegistry.ts#L258-L268
-*/
-var VSCODE_FALLBACK_EDITOR_FG = {
-	light: "#333333",
-	dark: "#bbbbbb"
+const VSCODE_FALLBACK_EDITOR_FG = {
+  light: "#333333",
+  dark: "#bbbbbb"
 };
-var VSCODE_FALLBACK_EDITOR_BG = {
-	light: "#fffffe",
-	dark: "#1e1e1e"
+const VSCODE_FALLBACK_EDITOR_BG = {
+  light: "#fffffe",
+  dark: "#1e1e1e"
 };
-var RESOLVED_KEY = "__shiki_resolved";
-/**
-* Normalize a textmate theme to shiki theme
-*/
+const RESOLVED_KEY = "__shiki_resolved";
 function normalizeTheme(rawTheme) {
-	if (rawTheme?.[RESOLVED_KEY]) return rawTheme;
-	const theme = { ...rawTheme };
-	if (theme.tokenColors && !theme.settings) {
-		theme.settings = theme.tokenColors;
-		delete theme.tokenColors;
-	}
-	theme.type || (theme.type = "dark");
-	theme.colorReplacements = { ...theme.colorReplacements };
-	theme.settings || (theme.settings = []);
-	let { bg, fg } = theme;
-	if (!bg || !fg) {
-		/**
-		* 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;
-		theme.bg = bg;
-	}
-	if (!(theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope)) theme.settings.unshift({ settings: {
-		foreground: theme.fg,
-		background: theme.bg
-	} });
-	let replacementCount = 0;
-	const replacementMap = /* @__PURE__ */ new Map();
-	function getReplacementColor(value) {
-		if (replacementMap.has(value)) return replacementMap.get(value);
-		replacementCount += 1;
-		const hex = `#${replacementCount.toString(16).padStart(8, "0").toLowerCase()}`;
-		if (theme.colorReplacements?.[`#${hex}`]) return getReplacementColor(value);
-		replacementMap.set(value, hex);
-		return hex;
-	}
-	theme.settings = theme.settings.map((setting) => {
-		const replaceFg = setting.settings?.foreground && !setting.settings.foreground.startsWith("#");
-		const replaceBg = setting.settings?.background && !setting.settings.background.startsWith("#");
-		if (!replaceFg && !replaceBg) return setting;
-		const clone = {
-			...setting,
-			settings: { ...setting.settings }
-		};
-		if (replaceFg) {
-			const replacement = getReplacementColor(setting.settings.foreground);
-			theme.colorReplacements[replacement] = setting.settings.foreground;
-			clone.settings.foreground = replacement;
-		}
-		if (replaceBg) {
-			const replacement = getReplacementColor(setting.settings.background);
-			theme.colorReplacements[replacement] = setting.settings.background;
-			clone.settings.background = replacement;
-		}
-		return clone;
-	});
-	for (const key of Object.keys(theme.colors || {})) if (key === "editor.foreground" || key === "editor.background" || key.startsWith("terminal.ansi")) {
-		if (!theme.colors[key]?.startsWith("#")) {
-			const replacement = getReplacementColor(theme.colors[key]);
-			theme.colorReplacements[replacement] = theme.colors[key];
-			theme.colors[key] = replacement;
-		}
-	}
-	Object.defineProperty(theme, RESOLVED_KEY, {
-		enumerable: false,
-		writable: false,
-		value: true
-	});
-	return theme;
+  if (rawTheme?.[RESOLVED_KEY]) return rawTheme;
+  const theme = { ...rawTheme };
+  if (theme.tokenColors && !theme.settings) {
+    theme.settings = theme.tokenColors;
+    delete theme.tokenColors;
+  }
+  theme.type || (theme.type = "dark");
+  theme.colorReplacements = { ...theme.colorReplacements };
+  theme.settings || (theme.settings = []);
+  let { bg, fg } = theme;
+  if (!bg || !fg) {
+    const globalSetting = theme.settings ? theme.settings.find((s) => !s.name && !s.scope) : void 0;
+    if (globalSetting?.settings?.foreground) fg = globalSetting.settings.foreground;
+    if (globalSetting?.settings?.background) bg = globalSetting.settings.background;
+    if (!fg && theme?.colors?.["editor.foreground"]) fg = theme.colors["editor.foreground"];
+    if (!bg && theme?.colors?.["editor.background"]) bg = theme.colors["editor.background"];
+    if (!fg) fg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
+    if (!bg) bg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
+    theme.fg = fg;
+    theme.bg = bg;
+  }
+  if (!(theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope)) theme.settings.unshift({ settings: {
+    foreground: theme.fg,
+    background: theme.bg
+  } });
+  let replacementCount = 0;
+  const replacementMap = /* @__PURE__ */ new Map();
+  function getReplacementColor(value) {
+    if (replacementMap.has(value)) return replacementMap.get(value);
+    replacementCount += 1;
+    const hex = `#${replacementCount.toString(16).padStart(8, "0").toLowerCase()}`;
+    if (theme.colorReplacements?.[`#${hex}`]) return getReplacementColor(value);
+    replacementMap.set(value, hex);
+    return hex;
+  }
+  theme.settings = theme.settings.map((setting) => {
+    const replaceFg = setting.settings?.foreground && !setting.settings.foreground.startsWith("#");
+    const replaceBg = setting.settings?.background && !setting.settings.background.startsWith("#");
+    if (!replaceFg && !replaceBg) return setting;
+    const clone = {
+      ...setting,
+      settings: { ...setting.settings }
+    };
+    if (replaceFg) {
+      const replacement = getReplacementColor(setting.settings.foreground);
+      theme.colorReplacements[replacement] = setting.settings.foreground;
+      clone.settings.foreground = replacement;
+    }
+    if (replaceBg) {
+      const replacement = getReplacementColor(setting.settings.background);
+      theme.colorReplacements[replacement] = setting.settings.background;
+      clone.settings.background = replacement;
+    }
+    return clone;
+  });
+  for (const key of Object.keys(theme.colors || {})) if (key === "editor.foreground" || key === "editor.background" || key.startsWith("terminal.ansi")) {
+    if (!theme.colors[key]?.startsWith("#")) {
+      const replacement = getReplacementColor(theme.colors[key]);
+      theme.colorReplacements[replacement] = theme.colors[key];
+      theme.colors[key] = replacement;
+    }
+  }
+  Object.defineProperty(theme, RESOLVED_KEY, {
+    enumerable: false,
+    writable: false,
+    value: true
+  });
+  return theme;
 }
-/**
-* 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()));
+  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) {
-	return (await Promise.all(themes.map(async (theme) => isSpecialTheme(theme) ? null : normalizeTheme(await normalizeGetter(theme))))).filter((i) => !!i);
+  return (await Promise.all(themes.map(async (theme) => isSpecialTheme(theme) ? null : normalizeTheme(await normalizeGetter(theme))))).filter((i) => !!i);
 }
 function resolveLangAlias(name, alias) {
-	if (!alias) return name;
-	if (alias[name]) {
-		const resolved = new Set([name]);
-		while (alias[name]) {
-			name = alias[name];
-			if (resolved.has(name)) throw new ShikiError(`Circular alias \`${Array.from(resolved).join(" -> ")} -> ${name}\``);
-			resolved.add(name);
-		}
-	}
-	return name;
+  if (!alias) return name;
+  if (alias[name]) {
+    const resolved = /* @__PURE__ */ new Set([name]);
+    while (alias[name]) {
+      name = alias[name];
+      if (resolved.has(name)) throw new ShikiError(`Circular alias \`${Array.from(resolved).join(" -> ")} -> ${name}\``);
+      resolved.add(name);
+    }
+  }
+  return name;
 }
 var Registry = class extends Registry$1 {
-	constructor(_resolver, _themes, _langs, _alias = {}) {
-		super(_resolver);
-		_defineProperty(this, "_resolvedThemes", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_resolvedGrammars", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_langMap", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_langGraph", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_textmateThemeCache", /* @__PURE__ */ new WeakMap());
-		_defineProperty(this, "_loadedThemesCache", null);
-		_defineProperty(this, "_loadedLanguagesCache", null);
-		this._resolver = _resolver;
-		this._themes = _themes;
-		this._langs = _langs;
-		this._alias = _alias;
-		this._themes.map((t) => this.loadTheme(t));
-		this.loadLanguages(this._langs);
-	}
-	getTheme(theme) {
-		if (typeof theme === "string") return this._resolvedThemes.get(theme);
-		else return this.loadTheme(theme);
-	}
-	loadTheme(theme) {
-		const _theme = normalizeTheme(theme);
-		if (_theme.name) {
-			this._resolvedThemes.set(_theme.name, _theme);
-			this._loadedThemesCache = null;
-		}
-		return _theme;
-	}
-	getLoadedThemes() {
-		if (!this._loadedThemesCache) this._loadedThemesCache = [...this._resolvedThemes.keys()];
-		return this._loadedThemesCache;
-	}
-	setTheme(theme) {
-		let textmateTheme = this._textmateThemeCache.get(theme);
-		if (!textmateTheme) {
-			textmateTheme = Theme.createFromRawTheme(theme);
-			this._textmateThemeCache.set(theme, textmateTheme);
-		}
-		this._syncRegistry.setTheme(textmateTheme);
-	}
-	getGrammar(name) {
-		name = resolveLangAlias(name, this._alias);
-		return this._resolvedGrammars.get(name);
-	}
-	loadLanguage(lang) {
-		if (this.getGrammar(lang.name)) return;
-		const embeddedLazilyBy = new Set([...this._langMap.values()].filter((i) => i.embeddedLangsLazy?.includes(lang.name)));
-		this._resolver.addLanguage(lang);
-		const grammarConfig = {
-			balancedBracketSelectors: lang.balancedBracketSelectors || ["*"],
-			unbalancedBracketSelectors: lang.unbalancedBracketSelectors || []
-		};
-		this._syncRegistry._rawGrammars.set(lang.scopeName, lang);
-		const g = this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
-		g.name = lang.name;
-		this._resolvedGrammars.set(lang.name, g);
-		if (lang.aliases) lang.aliases.forEach((alias) => {
-			this._alias[alias] = lang.name;
-		});
-		this._loadedLanguagesCache = null;
-		if (embeddedLazilyBy.size) for (const e of embeddedLazilyBy) {
-			this._resolvedGrammars.delete(e.name);
-			this._loadedLanguagesCache = null;
-			this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
-			this._syncRegistry?._grammars?.delete(e.scopeName);
-			this.loadLanguage(this._langMap.get(e.name));
-		}
-	}
-	dispose() {
-		super.dispose();
-		this._resolvedThemes.clear();
-		this._resolvedGrammars.clear();
-		this._langMap.clear();
-		this._langGraph.clear();
-		this._loadedThemesCache = null;
-	}
-	loadLanguages(langs) {
-		for (const lang of langs) this.resolveEmbeddedLanguages(lang);
-		const langsGraphArray = Array.from(this._langGraph.entries());
-		const missingLangs = langsGraphArray.filter(([_, lang]) => !lang);
-		if (missingLangs.length) {
-			const dependents = langsGraphArray.filter(([_, lang]) => {
-				if (!lang) return false;
-				return (lang.embeddedLanguages || lang.embeddedLangs)?.some((l) => missingLangs.map(([name]) => name).includes(l));
-			}).filter((lang) => !missingLangs.includes(lang));
-			throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(", ")}, required by ${dependents.map(([name]) => `\`${name}\``).join(", ")}`);
-		}
-		for (const [_, lang] of langsGraphArray) this._resolver.addLanguage(lang);
-		for (const [_, lang] of langsGraphArray) this.loadLanguage(lang);
-	}
-	getLoadedLanguages() {
-		if (!this._loadedLanguagesCache) this._loadedLanguagesCache = [...new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])];
-		return this._loadedLanguagesCache;
-	}
-	resolveEmbeddedLanguages(lang) {
-		this._langMap.set(lang.name, lang);
-		this._langGraph.set(lang.name, lang);
-		const embedded = lang.embeddedLanguages ?? lang.embeddedLangs;
-		if (embedded) for (const embeddedLang of embedded) this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));
-	}
+  constructor(_resolver, _themes, _langs, _alias = {}) {
+    super(_resolver);
+    __publicField(this, "_resolvedThemes", /* @__PURE__ */ new Map());
+    __publicField(this, "_resolvedGrammars", /* @__PURE__ */ new Map());
+    __publicField(this, "_langMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_langGraph", /* @__PURE__ */ new Map());
+    __publicField(this, "_textmateThemeCache", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "_loadedThemesCache", null);
+    __publicField(this, "_loadedLanguagesCache", null);
+    this._resolver = _resolver;
+    this._themes = _themes;
+    this._langs = _langs;
+    this._alias = _alias;
+    this._themes.map((t) => this.loadTheme(t));
+    this.loadLanguages(this._langs);
+  }
+  getTheme(theme) {
+    if (typeof theme === "string") return this._resolvedThemes.get(theme);
+    else return this.loadTheme(theme);
+  }
+  loadTheme(theme) {
+    const _theme = normalizeTheme(theme);
+    if (_theme.name) {
+      this._resolvedThemes.set(_theme.name, _theme);
+      this._loadedThemesCache = null;
+    }
+    return _theme;
+  }
+  getLoadedThemes() {
+    if (!this._loadedThemesCache) this._loadedThemesCache = [...this._resolvedThemes.keys()];
+    return this._loadedThemesCache;
+  }
+  setTheme(theme) {
+    let textmateTheme = this._textmateThemeCache.get(theme);
+    if (!textmateTheme) {
+      textmateTheme = Theme.createFromRawTheme(theme);
+      this._textmateThemeCache.set(theme, textmateTheme);
+    }
+    this._syncRegistry.setTheme(textmateTheme);
+  }
+  getGrammar(name) {
+    name = resolveLangAlias(name, this._alias);
+    return this._resolvedGrammars.get(name);
+  }
+  loadLanguage(lang) {
+    if (this.getGrammar(lang.name)) return;
+    const embeddedLazilyBy = new Set([...this._langMap.values()].filter((i) => i.embeddedLangsLazy?.includes(lang.name)));
+    this._resolver.addLanguage(lang);
+    const grammarConfig = {
+      balancedBracketSelectors: lang.balancedBracketSelectors || ["*"],
+      unbalancedBracketSelectors: lang.unbalancedBracketSelectors || []
+    };
+    this._syncRegistry._rawGrammars.set(lang.scopeName, lang);
+    const g = this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
+    g.name = lang.name;
+    this._resolvedGrammars.set(lang.name, g);
+    if (lang.aliases) lang.aliases.forEach((alias) => {
+      this._alias[alias] = lang.name;
+    });
+    this._loadedLanguagesCache = null;
+    if (embeddedLazilyBy.size) for (const e of embeddedLazilyBy) {
+      this._resolvedGrammars.delete(e.name);
+      this._loadedLanguagesCache = null;
+      this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
+      this._syncRegistry?._grammars?.delete(e.scopeName);
+      this.loadLanguage(this._langMap.get(e.name));
+    }
+  }
+  dispose() {
+    super.dispose();
+    this._resolvedThemes.clear();
+    this._resolvedGrammars.clear();
+    this._langMap.clear();
+    this._langGraph.clear();
+    this._loadedThemesCache = null;
+  }
+  loadLanguages(langs) {
+    for (const lang of langs) this.resolveEmbeddedLanguages(lang);
+    const langsGraphArray = Array.from(this._langGraph.entries());
+    const missingLangs = langsGraphArray.filter(([_, lang]) => !lang);
+    if (missingLangs.length) {
+      const dependents = langsGraphArray.filter(([_, lang]) => {
+        if (!lang) return false;
+        return (lang.embeddedLanguages || lang.embeddedLangs)?.some((l) => missingLangs.map(([name]) => name).includes(l));
+      }).filter((lang) => !missingLangs.includes(lang));
+      throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(", ")}, required by ${dependents.map(([name]) => `\`${name}\``).join(", ")}`);
+    }
+    for (const [_, lang] of langsGraphArray) this._resolver.addLanguage(lang);
+    for (const [_, lang] of langsGraphArray) this.loadLanguage(lang);
+  }
+  getLoadedLanguages() {
+    if (!this._loadedLanguagesCache) this._loadedLanguagesCache = [.../* @__PURE__ */ new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])];
+    return this._loadedLanguagesCache;
+  }
+  resolveEmbeddedLanguages(lang) {
+    this._langMap.set(lang.name, lang);
+    this._langGraph.set(lang.name, lang);
+    const embedded = lang.embeddedLanguages ?? lang.embeddedLangs;
+    if (embedded) for (const embeddedLang of embedded) this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));
+  }
 };
 var Resolver = class {
-	constructor(engine, langs) {
-		_defineProperty(this, "_langs", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_scopeToLang", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_injections", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_onigLib", void 0);
-		this._onigLib = {
-			createOnigScanner: (patterns) => engine.createScanner(patterns),
-			createOnigString: (s) => engine.createString(s)
-		};
-		langs.forEach((i) => this.addLanguage(i));
-	}
-	get onigLib() {
-		return this._onigLib;
-	}
-	getLangRegistration(langIdOrAlias) {
-		return this._langs.get(langIdOrAlias);
-	}
-	loadGrammar(scopeName) {
-		return this._scopeToLang.get(scopeName);
-	}
-	addLanguage(l) {
-		this._langs.set(l.name, l);
-		if (l.aliases) l.aliases.forEach((a) => {
-			this._langs.set(a, l);
-		});
-		this._scopeToLang.set(l.scopeName, l);
-		if (l.injectTo) l.injectTo.forEach((i) => {
-			if (!this._injections.get(i)) this._injections.set(i, []);
-			this._injections.get(i).push(l.scopeName);
-		});
-	}
-	getInjections(scopeName) {
-		const scopeParts = scopeName.split(".");
-		let injections = [];
-		for (let i = 1; i <= scopeParts.length; i++) {
-			const subScopeName = scopeParts.slice(0, i).join(".");
-			injections = [...injections, ...this._injections.get(subScopeName) || []];
-		}
-		return injections;
-	}
+  constructor(engine, langs) {
+    __publicField(this, "_langs", /* @__PURE__ */ new Map());
+    __publicField(this, "_scopeToLang", /* @__PURE__ */ new Map());
+    __publicField(this, "_injections", /* @__PURE__ */ new Map());
+    __publicField(this, "_onigLib");
+    this._onigLib = {
+      createOnigScanner: (patterns) => engine.createScanner(patterns),
+      createOnigString: (s) => engine.createString(s)
+    };
+    langs.forEach((i) => this.addLanguage(i));
+  }
+  get onigLib() {
+    return this._onigLib;
+  }
+  getLangRegistration(langIdOrAlias) {
+    return this._langs.get(langIdOrAlias);
+  }
+  loadGrammar(scopeName) {
+    return this._scopeToLang.get(scopeName);
+  }
+  addLanguage(l) {
+    this._langs.set(l.name, l);
+    if (l.aliases) l.aliases.forEach((a) => {
+      this._langs.set(a, l);
+    });
+    this._scopeToLang.set(l.scopeName, l);
+    if (l.injectTo) l.injectTo.forEach((i) => {
+      if (!this._injections.get(i)) this._injections.set(i, []);
+      this._injections.get(i).push(l.scopeName);
+    });
+  }
+  getInjections(scopeName) {
+    const scopeParts = scopeName.split(".");
+    let injections = [];
+    for (let i = 1; i <= scopeParts.length; i++) {
+      const subScopeName = scopeParts.slice(0, i).join(".");
+      injections = [...injections, ...this._injections.get(subScopeName) || []];
+    }
+    return injections;
+  }
 };
-var instancesCount = 0;
-/**
-* Get the minimal shiki primitive instance.
-*
-* Requires to provide the engine and all themes and languages upfront.
-*/
+let instancesCount = 0;
 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("`engine` option is required for synchronous mode");
-	const langs = (options.langs || []).flat(1);
-	const themes = (options.themes || []).flat(1).map(normalizeTheme);
-	const _registry = new Registry(new Resolver(options.engine, langs), themes, langs, options.langAlias);
-	let _lastTheme;
-	function resolveLangAlias$1(name) {
-		return resolveLangAlias(name, options.langAlias);
-	}
-	function getLanguage(name) {
-		ensureNotDisposed();
-		const _lang = _registry.getGrammar(typeof name === "string" ? name : name.name);
-		if (!_lang) throw new ShikiError(`Language \`${name}\` not found, you may need to load it first`);
-		return _lang;
-	}
-	function getTheme(name) {
-		if (name === "none") return {
-			bg: "",
-			fg: "",
-			name: "none",
-			settings: [],
-			type: "dark"
-		};
-		ensureNotDisposed();
-		const _theme = _registry.getTheme(name);
-		if (!_theme) throw new ShikiError(`Theme \`${name}\` not found, you may need to load it first`);
-		return _theme;
-	}
-	function setTheme(name) {
-		ensureNotDisposed();
-		const theme = getTheme(name);
-		if (_lastTheme !== name) {
-			_registry.setTheme(theme);
-			_lastTheme = name;
-		}
-		return {
-			theme,
-			colorMap: _registry.getColorMap()
-		};
-	}
-	function getLoadedThemes() {
-		ensureNotDisposed();
-		return _registry.getLoadedThemes();
-	}
-	function getLoadedLanguages() {
-		ensureNotDisposed();
-		return _registry.getLoadedLanguages();
-	}
-	function loadLanguageSync(...langs) {
-		ensureNotDisposed();
-		_registry.loadLanguages(langs.flat(1));
-	}
-	async function loadLanguage(...langs) {
-		return loadLanguageSync(await resolveLangs(langs));
-	}
-	function loadThemeSync(...themes) {
-		ensureNotDisposed();
-		for (const theme of themes.flat(1)) _registry.loadTheme(theme);
-	}
-	async function loadTheme(...themes) {
-		ensureNotDisposed();
-		return loadThemeSync(await resolveThemes(themes));
-	}
-	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
-	};
+  instancesCount += 1;
+  if (options.warnings !== false && instancesCount >= 10 && instancesCount % 10 === 0) console.warn(`[Shiki] ${instancesCount} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \`highlighter.dispose()\` to release unused instances.`);
+  let isDisposed = false;
+  if (!options.engine) throw new ShikiError("`engine` option is required for synchronous mode");
+  const langs = (options.langs || []).flat(1);
+  const themes = (options.themes || []).flat(1).map(normalizeTheme);
+  const _registry = new Registry(new Resolver(options.engine, langs), themes, langs, options.langAlias);
+  let _lastTheme;
+  function resolveLangAlias$1(name) {
+    return resolveLangAlias(name, options.langAlias);
+  }
+  function getLanguage(name) {
+    ensureNotDisposed();
+    const _lang = _registry.getGrammar(typeof name === "string" ? name : name.name);
+    if (!_lang) throw new ShikiError(`Language \`${name}\` not found, you may need to load it first`);
+    return _lang;
+  }
+  function getTheme(name) {
+    if (name === "none") return {
+      bg: "",
+      fg: "",
+      name: "none",
+      settings: [],
+      type: "dark"
+    };
+    ensureNotDisposed();
+    const _theme = _registry.getTheme(name);
+    if (!_theme) throw new ShikiError(`Theme \`${name}\` not found, you may need to load it first`);
+    return _theme;
+  }
+  function setTheme(name) {
+    ensureNotDisposed();
+    const theme = getTheme(name);
+    if (_lastTheme !== name) {
+      _registry.setTheme(theme);
+      _lastTheme = name;
+    }
+    return {
+      theme,
+      colorMap: _registry.getColorMap()
+    };
+  }
+  function getLoadedThemes() {
+    ensureNotDisposed();
+    return _registry.getLoadedThemes();
+  }
+  function getLoadedLanguages() {
+    ensureNotDisposed();
+    return _registry.getLoadedLanguages();
+  }
+  function loadLanguageSync(...langs2) {
+    ensureNotDisposed();
+    _registry.loadLanguages(langs2.flat(1));
+  }
+  async function loadLanguage(...langs2) {
+    return loadLanguageSync(await resolveLangs(langs2));
+  }
+  function loadThemeSync(...themes2) {
+    ensureNotDisposed();
+    for (const theme of themes2.flat(1)) _registry.loadTheme(theme);
+  }
+  async function loadTheme(...themes2) {
+    ensureNotDisposed();
+    return loadThemeSync(await resolveThemes(themes2));
+  }
+  function ensureNotDisposed() {
+    if (isDisposed) throw new ShikiError("Shiki instance has been disposed");
+  }
+  function dispose() {
+    if (isDisposed) return;
+    isDisposed = true;
+    _registry.dispose();
+    instancesCount -= 1;
+  }
+  return {
+    setTheme,
+    getTheme,
+    getLanguage,
+    getLoadedThemes,
+    getLoadedLanguages,
+    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
-	});
+  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
+  });
 }
-var _grammarStateMap = /* @__PURE__ */ new WeakMap();
+const _grammarStateMap = /* @__PURE__ */ new WeakMap();
 function setLastGrammarStateToMap(keys, state) {
-	_grammarStateMap.set(keys, state);
+  _grammarStateMap.set(keys, state);
 }
 function getLastGrammarStateFromMap(keys) {
-	return _grammarStateMap.get(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 {
-	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) {
-		_defineProperty(
-			this,
-			/**
-			* Theme to Stack mapping
-			*/
-			"_stacks",
-			{}
-		);
-		_defineProperty(this, "lang", void 0);
-		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()
-		};
-	}
+var GrammarState = class GrammarState2 {
+  constructor(...args) {
+    /**
+    * Theme to Stack mapping
+    */
+    __publicField(this, "_stacks", {});
+    __publicField(this, "lang");
+    if (args.length === 2) {
+      const [stacksMap, lang] = args;
+      this.lang = lang;
+      this._stacks = stacksMap;
+    } else {
+      const [stack, lang, theme] = args;
+      this.lang = lang;
+      this._stacks = { [theme]: stack };
+    }
+  }
+  get themes() {
+    return Object.keys(this._stacks);
+  }
+  get theme() {
+    return this.themes[0];
+  }
+  get _stack() {
+    return this._stacks[this.theme];
+  }
+  /**
+  * Static method to create a initial grammar state.
+  */
+  static initial(lang, themes) {
+    return new GrammarState2(Object.fromEntries(toArray(themes).map((theme) => [theme, INITIAL])), lang);
+  }
+  /**
+  * Get the internal stack object.
+  * @internal
+  */
+  getInternalStack(theme = this.theme) {
+    return this._stacks[theme];
+  }
+  getScopes(theme = this.theme) {
+    return getScopes(this._stacks[theme]);
+  }
+  toJSON() {
+    return {
+      lang: this.lang,
+      theme: this.theme,
+      themes: this.themes,
+      scopes: this.getScopes()
+    };
+  }
 };
 function getScopes(stack) {
-	const scopes = [];
-	const visited = /* @__PURE__ */ new Set();
-	function pushScope(stack) {
-		if (visited.has(stack)) return;
-		visited.add(stack);
-		const name = stack?.nameScopesList?.scopeName;
-		if (name) scopes.push(name);
-		if (stack.parent) pushScope(stack.parent);
-	}
-	pushScope(stack);
-	return scopes;
+  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);
+  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}"`);
-	}
-	return tokenizeWithTheme(code, _grammar, theme, colorMap, 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}"`);
+  }
+  return tokenizeWithTheme(code, _grammar, theme, colorMap, options);
 }
 function getLastGrammarState(...args) {
-	if (args.length === 2) return getLastGrammarStateFromMap(args[1]);
-	const [primitive, code, options = {}] = args;
-	const { lang = "text", theme: themeName = primitive.getLoadedThemes()[0] } = options;
-	if (isPlainLang(lang) || isNoneTheme(themeName)) throw new ShikiError("Plain language does not have grammar state");
-	if (lang === "ansi") throw new ShikiError("ANSI language does not have grammar state");
-	const { theme, colorMap } = primitive.setTheme(themeName);
-	const _grammar = primitive.getLanguage(lang);
-	return new GrammarState(_tokenizeWithTheme(code, _grammar, theme, colorMap, options).stateStack, _grammar.name, theme.name);
+  if (args.length === 2) return getLastGrammarStateFromMap(args[1]);
+  const [primitive, code, options = {}] = args;
+  const { lang = "text", theme: themeName = primitive.getLoadedThemes()[0] } = options;
+  if (isPlainLang(lang) || isNoneTheme(themeName)) throw new ShikiError("Plain language does not have grammar state");
+  if (lang === "ansi") throw new ShikiError("ANSI language does not have grammar state");
+  const { theme, colorMap } = primitive.setTheme(themeName);
+  const _grammar = primitive.getLanguage(lang);
+  return new GrammarState(_tokenizeWithTheme(code, _grammar, theme, colorMap, options).stateStack, _grammar.name, theme.name);
 }
 function tokenizeWithTheme(code, grammar, theme, colorMap, options) {
-	const result = _tokenizeWithTheme(code, grammar, theme, colorMap, options);
-	const grammarState = new GrammarState(result.stateStack, grammar.name, theme.name);
-	setLastGrammarStateToMap(result.tokens, grammarState);
-	return result.tokens;
+  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
-	};
+  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 }));
+  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;
+  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] === ".";
+  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;
+  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;
+  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, codeToTokensBaseFn = codeToTokensBase) {
-	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 = codeToTokensBaseFn(primitive, code, {
-			...options,
-			theme: t.theme
-		});
-		return {
-			tokens,
-			state: getLastGrammarStateFromMap(tokens),
-			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;
+  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 = codeToTokensBaseFn(primitive, code, {
+      ...options,
+      theme: t.theme
+    });
+    return {
+      tokens: tokens2,
+      state: getLastGrammarStateFromMap(tokens2),
+      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) => t.push(outLines[i]));
-		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;
+  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;
 }
-//#endregion
-export { applyColorReplacements, codeToTokensBase, codeToTokensWithThemes, createShikiPrimitive, createShikiPrimitiveAsync, getLastGrammarState, getLastGrammarStateFromMap, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, setLastGrammarStateToMap, splitLines, toArray, tokenizeWithTheme };
+export {
+  GrammarState,
+  Registry,
+  Resolver,
+  ShikiError,
+  alignThemesTokenization,
+  applyColorReplacements,
+  codeToTokensBase,
+  codeToTokensWithThemes,
+  createShikiPrimitive,
+  createShikiPrimitiveAsync,
+  getGrammarStack,
+  getLastGrammarState,
+  getLastGrammarStateFromMap,
+  isNoneTheme,
+  isPlainLang,
+  isSpecialLang,
+  isSpecialTheme,
+  normalizeGetter,
+  normalizeTheme,
+  resolveColorReplacements,
+  resolveLangAlias,
+  resolveLangs,
+  resolveThemes,
+  setLastGrammarStateToMap,
+  splitLines,
+  toArray,
+  tokenizeWithTheme
+};