@luan.sh/pi-copy-mode 0.3.2

package/node_modules/@pierre/theming/dist/modules/createThemeResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThemeResolver.js","names":[],"sources":["../../src/modules/createThemeResolver.ts"],"sourcesContent":["/**\n * Generic theme resolver: a pure cache + registry with no Shiki, no theme JSON,\n * and no bundled fallbacks. Callers register named loaders; this module dedupes\n * concurrent loads (same loader runs at most once per name per cache cycle) and\n * caches resolved ThemeLike objects for synchronous access after the first\n * successful load.\n * The `{ default: theme }` unwrap handles the common pattern of dynamic ESM\n * imports (`import('some-theme.json')`) that wrap the value under `default`.\n */\n\nimport type { ThemeLike } from './types';\nimport { type DefaultExport, unwrapDefault } from './unwrapDefault';\n\n// A loader is a zero-argument async factory that returns either a ThemeLike\n// directly or a module-style `{ default: ThemeLike }` (the shape produced by\n// `import()` on a JSON theme file or a re-exporting ESM module).\nexport interface ThemeLoader<TTheme extends ThemeLike = ThemeLike> {\n  (): Promise<TTheme | DefaultExport<TTheme>>;\n}\n\nexport interface ThemeResolver<TTheme extends ThemeLike = ThemeLike> {\n  // Seed the resolved cache with an already-resolved theme under `name`,\n  // without registering or running a loader. Intended for environments that\n  // receive a fully-resolved theme object out of band (for example a worker\n  // that is handed pre-resolved themes by the main thread and cannot run a\n  // loader itself). A subsequent getResolvedTheme/getResolvedOrResolveTheme/\n  // resolveTheme for `name` returns the seeded theme; a later resolveTheme is\n  // served from the cache and never invokes a registered loader for that name.\n  seedResolvedTheme(name: string, theme: TTheme): void;\n\n  // Seed multiple resolved themes. Accepts any iterable of `[name, theme]`\n  // entries so callers can pass arrays or Maps without reshaping.\n  seedResolvedThemes(entries: Iterable<readonly [string, TTheme]>): void;\n\n  // Clear the resolved cache and in-flight promises. Registered loaders are\n  // kept so subsequent resolveTheme calls re-run them.\n  clearResolvedThemes(): void;\n\n  // Returns the cached ThemeLike synchronously when warm; otherwise returns\n  // the resolveTheme Promise so callers can await it when cold.\n  getResolvedOrResolveTheme(name: string): TTheme | Promise<TTheme>;\n\n  // Synchronous cache read. Returns undefined if the theme has not been\n  // resolved yet.\n  getResolvedTheme(name: string): TTheme | undefined;\n\n  // Synchronous cache read for a batch. Throws UnresolvedThemeError naming the\n  // first missing theme if any requested name is not warm.\n  getResolvedThemes(names: readonly string[]): TTheme[];\n\n  // Registry/cache introspection helpers for callers that need to avoid an async\n  // tick or decide whether to register a fallback loader.\n  hasRegisteredTheme(name: string): boolean;\n  hasResolvedTheme(name: string): boolean;\n  hasResolvedThemes(names: readonly string[]): boolean;\n\n  // Register a named loader. Throws DuplicateThemeError if a loader for\n  // `name` is already present.\n  registerTheme(name: string, loader: ThemeLoader<TTheme>): void;\n\n  // Register a loader only when `name` has no loader yet. Returns true when the\n  // loader was added and false when a loader already existed.\n  registerThemeIfAbsent(name: string, loader: ThemeLoader<TTheme>): boolean;\n\n  // Resolve a theme by name. Dedupes concurrent calls and caches the result.\n  // Rejects with UnregisteredThemeError if no loader has been registered.\n  resolveTheme(name: string): Promise<TTheme>;\n\n  // Resolve a batch of themes in input order. Each name still goes through the\n  // same cache and in-flight dedupe as resolveTheme.\n  resolveThemes(names: readonly string[]): Promise<TTheme[]>;\n}\n\n// Thrown when a caller tries to register a second loader for an already-known\n// theme name. The generic resolver is strict — idempotency layers live above.\nexport class DuplicateThemeError extends Error {\n  constructor(name: string) {\n    super(`Theme \"${name}\" is already registered`);\n    this.name = 'DuplicateThemeError';\n  }\n}\n\n// Thrown when resolveTheme is called for a name with no registered loader.\nexport class UnregisteredThemeError extends Error {\n  constructor(name: string) {\n    super(`No loader registered for theme \"${name}\"`);\n    this.name = 'UnregisteredThemeError';\n  }\n}\n\n// Thrown when callers require a synchronously resolved theme but the cache does\n// not contain that name. This is distinct from UnregisteredThemeError: the\n// theme may have a loader, it just has not been resolved or seeded yet.\nexport class UnresolvedThemeError extends Error {\n  constructor(name: string) {\n    super(`Theme \"${name}\" has not been resolved`);\n    this.name = 'UnresolvedThemeError';\n  }\n}\n\n// Creates an isolated ThemeResolver instance with its own loader registry,\n// resolved-theme cache, and in-flight dedupe map. Multiple instances never\n// share state.\nexport function createThemeResolver<\n  TTheme extends ThemeLike = ThemeLike,\n>(): ThemeResolver<TTheme> {\n  // Maps theme name → registered loader function (set at register time).\n  const loaders = new Map<string, ThemeLoader<TTheme>>();\n\n  // Synchronous cache of successfully resolved ThemeLike objects.\n  const resolved = new Map<string, TTheme>();\n\n  // In-flight dedupe map: while a load is running, subsequent callers for the\n  // same name receive the same Promise instead of launching another load.\n  const inflight = new Map<string, Promise<TTheme>>();\n\n  // Incremented whenever resolved/in-flight state is cleared. A loader that\n  // started before a clear may still settle later; the generation check prevents\n  // that stale promise from repopulating the cache.\n  let cacheGeneration = 0;\n\n  function registerTheme(name: string, loader: ThemeLoader<TTheme>): void {\n    if (loaders.has(name)) {\n      throw new DuplicateThemeError(name);\n    }\n    loaders.set(name, loader);\n  }\n\n  function registerThemeIfAbsent(\n    name: string,\n    loader: ThemeLoader<TTheme>\n  ): boolean {\n    if (loaders.has(name)) return false;\n    loaders.set(name, loader);\n    return true;\n  }\n\n  function hasRegisteredTheme(name: string): boolean {\n    return loaders.has(name);\n  }\n\n  // Resolves a theme by name. Returns immediately if the theme is already in\n  // the synchronous cache, dedupes concurrent calls via the inflight map, and\n  // clears the inflight entry after settlement (success or failure) so that\n  // failed loads can be retried by the next caller.\n  function resolveTheme(name: string): Promise<TTheme> {\n    const cached = resolved.get(name);\n    if (cached !== undefined) {\n      return Promise.resolve(cached);\n    }\n\n    const existing = inflight.get(name);\n    if (existing !== undefined) {\n      return existing;\n    }\n\n    const loader = loaders.get(name);\n    if (loader === undefined) {\n      return Promise.reject(new UnregisteredThemeError(name));\n    }\n\n    const generation = cacheGeneration;\n    const promise = loader()\n      .then((result) => {\n        // A loader may return either a bare ThemeLike or an ES-module namespace\n        // object ({ default: ThemeLike }) — the latter is typical when the\n        // loader calls a dynamic import() on a JSON or .ts theme file and the\n        // bundler/runtime wraps the value under `default`. We treat any object\n        // carrying a top-level `default` key as the module-namespace form.\n        // Real ThemeLike theme objects never carry a top-level `default` key,\n        // so the heuristic is unambiguous in practice.\n        const theme = unwrapDefault(result);\n        if (generation === cacheGeneration) {\n          resolved.set(name, theme);\n        }\n        if (inflight.get(name) === promise) {\n          inflight.delete(name);\n        }\n        return theme;\n      })\n      .catch((err: unknown) => {\n        // Clear the inflight entry so a later call can retry.\n        if (inflight.get(name) === promise) {\n          inflight.delete(name);\n        }\n        throw err;\n      });\n\n    inflight.set(name, promise);\n    return promise;\n  }\n\n  function resolveThemes(names: readonly string[]): Promise<TTheme[]> {\n    return Promise.all(names.map((name) => resolveTheme(name)));\n  }\n\n  // Seeds the resolved cache directly with a pre-resolved theme. No loader is\n  // registered or run — the value is simply made available to subsequent\n  // getResolvedTheme/getResolvedOrResolveTheme/resolveTheme calls. Used by\n  // callers (e.g. workers) that obtain a fully-resolved theme object out of\n  // band and want it served synchronously without a loader round-trip.\n  function seedResolvedTheme(name: string, theme: TTheme): void {\n    resolved.set(name, theme);\n  }\n\n  function seedResolvedThemes(\n    entries: Iterable<readonly [string, TTheme]>\n  ): void {\n    for (const [name, theme] of entries) {\n      seedResolvedTheme(name, theme);\n    }\n  }\n\n  function getResolvedTheme(name: string): TTheme | undefined {\n    return resolved.get(name);\n  }\n\n  function getResolvedThemes(names: readonly string[]): TTheme[] {\n    const themes: TTheme[] = [];\n    for (const name of names) {\n      const theme = resolved.get(name);\n      if (theme === undefined) {\n        throw new UnresolvedThemeError(name);\n      }\n      themes.push(theme);\n    }\n    return themes;\n  }\n\n  function hasResolvedTheme(name: string): boolean {\n    return resolved.has(name);\n  }\n\n  function hasResolvedThemes(names: readonly string[]): boolean {\n    for (const name of names) {\n      if (!resolved.has(name)) return false;\n    }\n    return true;\n  }\n\n  // Returns the cached ThemeLike synchronously if available, otherwise falls\n  // through to resolveTheme so callers can await the returned Promise. This\n  // matches the \"get hot, resolve cold\" pattern used throughout the diffs\n  // package (getResolvedOrResolveTheme semantics).\n  function getResolvedOrResolveTheme(name: string): TTheme | Promise<TTheme> {\n    const cached = resolved.get(name);\n    if (cached !== undefined) {\n      return cached;\n    }\n    return resolveTheme(name);\n  }\n\n  // Clears the resolved cache and any in-flight promises so that subsequent\n  // calls re-run loaders from scratch. Registered loaders are preserved.\n  function clearResolvedThemes(): void {\n    cacheGeneration++;\n    resolved.clear();\n    inflight.clear();\n  }\n\n  return {\n    clearResolvedThemes,\n    getResolvedOrResolveTheme,\n    getResolvedTheme,\n    getResolvedThemes,\n    hasRegisteredTheme,\n    hasResolvedTheme,\n    hasResolvedThemes,\n    registerTheme,\n    registerThemeIfAbsent,\n    resolveTheme,\n    resolveThemes,\n    seedResolvedTheme,\n    seedResolvedThemes,\n  };\n}\n"],"mappings":"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"}

package/node_modules/@pierre/theming/dist/modules/normalizeThemeColors.d.ts

@@ -0,0 +1,7 @@
+import { ThemeLike } from "./types.js";
+
+//#region src/modules/normalizeThemeColors.d.ts
+declare function normalizeThemeColors(theme: ThemeLike): ThemeLike;
+//#endregion
+export { normalizeThemeColors };
+//# sourceMappingURL=normalizeThemeColors.d.ts.map

package/node_modules/@pierre/theming/dist/modules/normalizeThemeColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeThemeColors.d.ts","names":[],"sources":["../../src/modules/normalizeThemeColors.ts"],"mappings":";;;iBA8CgB,oBAAA,CAAqB,KAAA,EAAO,SAAA,GAAY,SAAS"}

package/node_modules/@pierre/theming/dist/modules/normalizeThemeColors.js

@@ -0,0 +1,88 @@
+import { hoverWouldEraseText, isFullyTransparent } from "./color.js";
+//#region src/modules/normalizeThemeColors.ts
+/**
+* normalizeThemeColors is the public front door for reading the colors a
+* Shiki/VS Code theme defines. It returns a SAME-SHAPE theme (same top-level
+* fields, same `colors` key vocabulary) whose `colors` map has the standard
+* fallback chains applied and a few universal repairs done, so every consumer
+* reads one resolved set of workbench keys instead of re-deriving the chains.
+*
+* It does NOT touch syntax/editor token colors or the base fg/bg/type — those
+* are owned by Shiki's normalizeTheme upstream, and this function assumes a
+* theme that has already passed through it. Do not confuse the two:
+* `normalizeTheme` (Shiki) normalizes the whole theme; `normalizeThemeColors`
+* (here) only resolves the workbench `colors` map.
+*
+* What it fills (mechanical fallback, no opinion):
+*   - surfaces: editor/sideBar background+foreground, input.background,
+*     sideBarSectionHeader.foreground, list.activeSelectionForeground — via the
+*     editor→base and sideBar→editor→base precedence.
+*   - git status: gitDecoration.{added,modified,deleted}ResourceForeground via
+*     the gitDecoration → terminal.ansi* → editorGutter.* chain.
+*   - focus ring: list.focusOutline set to the first NON-transparent of
+*     [list.focusOutline, focusBorder].
+*
+* What it repairs (universal correctness, the ceiling of what it adds):
+*   - drops list.hoverBackground when it exactly equals the sidebar surface or
+*     would land on top of the row text (hoverWouldEraseText) — a hover that
+*     erases legibility is broken for any consumer.
+*
+* What it deliberately leaves alone (consumer presentation opinion):
+*   - the selection lookup (list.activeSelectionBackground vs the same-surface
+*     swap to list.focusBackground) stays a consumer recipe; the raw keys pass
+*     through untouched so a consumer can apply its own choice.
+*
+* The result is pure, frozen, and WeakMap-memoized per input theme, and the
+* function is idempotent: normalizeThemeColors(normalizeThemeColors(t)) yields
+* an equal result. That idempotency is what lets it run lazily at read time
+* (the default) OR be pre-applied at load time and seeded — without a consumer
+* ever getting a different answer.
+*
+* The fallback chains are small and used only here, so they are inlined rather
+* than split into a separate resolver module.
+*/
+const cache = /* @__PURE__ */ new WeakMap();
+function normalizeThemeColors(theme) {
+	const cached = cache.get(theme);
+	if (cached != null) return cached;
+	const originalColors = theme.colors ?? {};
+	const colors = { ...originalColors };
+	const editorBackground = originalColors["editor.background"] ?? theme.bg;
+	const editorForeground = originalColors["editor.foreground"] ?? theme.fg;
+	const sidebarBackground = originalColors["sideBar.background"] ?? editorBackground;
+	const sidebarForeground = originalColors["sideBar.foreground"] ?? editorForeground;
+	fill(colors, "editor.background", editorBackground);
+	fill(colors, "editor.foreground", editorForeground);
+	fill(colors, "sideBar.background", sidebarBackground);
+	fill(colors, "sideBar.foreground", sidebarForeground);
+	fill(colors, "input.background", originalColors["input.background"] ?? sidebarBackground);
+	fill(colors, "sideBarSectionHeader.foreground", originalColors["sideBarSectionHeader.foreground"] ?? sidebarForeground);
+	fill(colors, "list.activeSelectionForeground", originalColors["list.activeSelectionForeground"] ?? sidebarForeground);
+	fill(colors, "gitDecoration.addedResourceForeground", firstColor(originalColors["gitDecoration.addedResourceForeground"], originalColors["terminal.ansiGreen"], originalColors["editorGutter.addedBackground"]));
+	fill(colors, "gitDecoration.modifiedResourceForeground", firstColor(originalColors["gitDecoration.modifiedResourceForeground"], originalColors["terminal.ansiBlue"], originalColors["editorGutter.modifiedBackground"]));
+	fill(colors, "gitDecoration.deletedResourceForeground", firstColor(originalColors["gitDecoration.deletedResourceForeground"], originalColors["terminal.ansiRed"], originalColors["editorGutter.deletedBackground"]));
+	const focusRing = (isFullyTransparent(originalColors["list.focusOutline"]) ? void 0 : originalColors["list.focusOutline"]) ?? (isFullyTransparent(originalColors["focusBorder"]) ? void 0 : originalColors["focusBorder"]);
+	if (focusRing != null) colors["list.focusOutline"] = focusRing;
+	else delete colors["list.focusOutline"];
+	const hover = originalColors["list.hoverBackground"];
+	if (hover != null && (matchesSurface(hover, sidebarBackground) || hoverWouldEraseText(hover, sidebarBackground, sidebarForeground))) delete colors["list.hoverBackground"];
+	const result = Object.freeze({
+		...theme,
+		colors: Object.freeze(colors)
+	});
+	cache.set(theme, result);
+	return result;
+}
+function fill(colors, key, value) {
+	if (value != null && value !== "") colors[key] = value;
+}
+function firstColor(...candidates) {
+	for (const candidate of candidates) if (candidate != null && candidate !== "") return candidate;
+}
+function matchesSurface(color, surface) {
+	return surface != null && color.toLowerCase() === surface.toLowerCase();
+}
+//#endregion
+export { normalizeThemeColors };
+
+//# sourceMappingURL=normalizeThemeColors.js.map

package/node_modules/@pierre/theming/dist/modules/normalizeThemeColors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeThemeColors.js","names":[],"sources":["../../src/modules/normalizeThemeColors.ts"],"sourcesContent":["/**\n * normalizeThemeColors is the public front door for reading the colors a\n * Shiki/VS Code theme defines. It returns a SAME-SHAPE theme (same top-level\n * fields, same `colors` key vocabulary) whose `colors` map has the standard\n * fallback chains applied and a few universal repairs done, so every consumer\n * reads one resolved set of workbench keys instead of re-deriving the chains.\n *\n * It does NOT touch syntax/editor token colors or the base fg/bg/type — those\n * are owned by Shiki's normalizeTheme upstream, and this function assumes a\n * theme that has already passed through it. Do not confuse the two:\n * `normalizeTheme` (Shiki) normalizes the whole theme; `normalizeThemeColors`\n * (here) only resolves the workbench `colors` map.\n *\n * What it fills (mechanical fallback, no opinion):\n *   - surfaces: editor/sideBar background+foreground, input.background,\n *     sideBarSectionHeader.foreground, list.activeSelectionForeground — via the\n *     editor→base and sideBar→editor→base precedence.\n *   - git status: gitDecoration.{added,modified,deleted}ResourceForeground via\n *     the gitDecoration → terminal.ansi* → editorGutter.* chain.\n *   - focus ring: list.focusOutline set to the first NON-transparent of\n *     [list.focusOutline, focusBorder].\n *\n * What it repairs (universal correctness, the ceiling of what it adds):\n *   - drops list.hoverBackground when it exactly equals the sidebar surface or\n *     would land on top of the row text (hoverWouldEraseText) — a hover that\n *     erases legibility is broken for any consumer.\n *\n * What it deliberately leaves alone (consumer presentation opinion):\n *   - the selection lookup (list.activeSelectionBackground vs the same-surface\n *     swap to list.focusBackground) stays a consumer recipe; the raw keys pass\n *     through untouched so a consumer can apply its own choice.\n *\n * The result is pure, frozen, and WeakMap-memoized per input theme, and the\n * function is idempotent: normalizeThemeColors(normalizeThemeColors(t)) yields\n * an equal result. That idempotency is what lets it run lazily at read time\n * (the default) OR be pre-applied at load time and seeded — without a consumer\n * ever getting a different answer.\n *\n * The fallback chains are small and used only here, so they are inlined rather\n * than split into a separate resolver module.\n */\nimport { hoverWouldEraseText, isFullyTransparent } from './color';\nimport type { ThemeLike } from './types';\n\nconst cache = new WeakMap<ThemeLike, ThemeLike>();\n\nexport function normalizeThemeColors(theme: ThemeLike): ThemeLike {\n  const cached = cache.get(theme);\n  if (cached != null) return cached;\n\n  const originalColors = theme.colors ?? {};\n  const colors: Record<string, string> = { ...originalColors };\n\n  // Surface precedence: the editor falls back to the base theme bg/fg, and the\n  // sidebar falls back to the editor. Plain `??` so an explicit value is honored\n  // and the chain never invents a color.\n  const editorBackground = originalColors['editor.background'] ?? theme.bg;\n  const editorForeground = originalColors['editor.foreground'] ?? theme.fg;\n  const sidebarBackground =\n    originalColors['sideBar.background'] ?? editorBackground;\n  const sidebarForeground =\n    originalColors['sideBar.foreground'] ?? editorForeground;\n\n  // Write each resolved surface back onto its canonical key so consumers read a\n  // single key instead of re-walking the chain.\n  fill(colors, 'editor.background', editorBackground);\n  fill(colors, 'editor.foreground', editorForeground);\n  fill(colors, 'sideBar.background', sidebarBackground);\n  fill(colors, 'sideBar.foreground', sidebarForeground);\n  fill(\n    colors,\n    'input.background',\n    originalColors['input.background'] ?? sidebarBackground\n  );\n  fill(\n    colors,\n    'sideBarSectionHeader.foreground',\n    originalColors['sideBarSectionHeader.foreground'] ?? sidebarForeground\n  );\n  fill(\n    colors,\n    'list.activeSelectionForeground',\n    originalColors['list.activeSelectionForeground'] ?? sidebarForeground\n  );\n\n  // Git status foreground chains: the dedicated gitDecoration key, then the\n  // terminal ANSI color, then the editor gutter background (which catches\n  // gutter-only themes like vesper). firstColor skips empty strings so a blank\n  // key falls through to the next tier.\n  fill(\n    colors,\n    'gitDecoration.addedResourceForeground',\n    firstColor(\n      originalColors['gitDecoration.addedResourceForeground'],\n      originalColors['terminal.ansiGreen'],\n      originalColors['editorGutter.addedBackground']\n    )\n  );\n  fill(\n    colors,\n    'gitDecoration.modifiedResourceForeground',\n    firstColor(\n      originalColors['gitDecoration.modifiedResourceForeground'],\n      originalColors['terminal.ansiBlue'],\n      originalColors['editorGutter.modifiedBackground']\n    )\n  );\n  fill(\n    colors,\n    'gitDecoration.deletedResourceForeground',\n    firstColor(\n      originalColors['gitDecoration.deletedResourceForeground'],\n      originalColors['terminal.ansiRed'],\n      originalColors['editorGutter.deletedBackground']\n    )\n  );\n\n  // Focus ring: first non-transparent of [list.focusOutline, focusBorder]. A\n  // transparent outline is rejected so the resolved key is always a visible\n  // color; if neither candidate is visible the key is left absent.\n  const focusRing =\n    (isFullyTransparent(originalColors['list.focusOutline'])\n      ? undefined\n      : originalColors['list.focusOutline']) ??\n    (isFullyTransparent(originalColors['focusBorder'])\n      ? undefined\n      : originalColors['focusBorder']);\n  if (focusRing != null) {\n    colors['list.focusOutline'] = focusRing;\n  } else {\n    delete colors['list.focusOutline'];\n  }\n\n  // Hover repair: a hover background that exactly matches the surface, or that\n  // sits closer to the text color than the surface (so it would erase the row\n  // text), is unusable for any consumer — drop it and let the consumer apply its\n  // own hover default.\n  const hover = originalColors['list.hoverBackground'];\n  if (\n    hover != null &&\n    (matchesSurface(hover, sidebarBackground) ||\n      hoverWouldEraseText(hover, sidebarBackground, sidebarForeground))\n  ) {\n    delete colors['list.hoverBackground'];\n  }\n\n  const result = Object.freeze({ ...theme, colors: Object.freeze(colors) });\n  cache.set(theme, result);\n  return result;\n}\n\n// Writes `value` to `key` only when it is a real color, so an absent source key\n// stays absent rather than being coerced to undefined/''.\nfunction fill(\n  colors: Record<string, string>,\n  key: string,\n  value: string | undefined\n): void {\n  if (value != null && value !== '') colors[key] = value;\n}\n\n// Returns the first non-empty color among the candidates, in priority order.\n// Skipping '' lets a blank workbench key fall through to the next tier.\nfunction firstColor(...candidates: (string | undefined)[]): string | undefined {\n  for (const candidate of candidates) {\n    if (candidate != null && candidate !== '') return candidate;\n  }\n  return undefined;\n}\n\n// Case-insensitive exact-string surface match (NOT a luminance-based compare).\n// Matches the equality the hover repair has always used.\nfunction matchesSurface(color: string, surface: string | undefined): boolean {\n  return surface != null && color.toLowerCase() === surface.toLowerCase();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAM,wBAAQ,IAAI,QAA8B;AAEhD,SAAgB,qBAAqB,OAA6B;CAChE,MAAM,SAAS,MAAM,IAAI,KAAK;CAC9B,IAAI,UAAU,MAAM,OAAO;CAE3B,MAAM,iBAAiB,MAAM,UAAU,CAAC;CACxC,MAAM,SAAiC,EAAE,GAAG,eAAe;CAK3D,MAAM,mBAAmB,eAAe,wBAAwB,MAAM;CACtE,MAAM,mBAAmB,eAAe,wBAAwB,MAAM;CACtE,MAAM,oBACJ,eAAe,yBAAyB;CAC1C,MAAM,oBACJ,eAAe,yBAAyB;CAI1C,KAAK,QAAQ,qBAAqB,gBAAgB;CAClD,KAAK,QAAQ,qBAAqB,gBAAgB;CAClD,KAAK,QAAQ,sBAAsB,iBAAiB;CACpD,KAAK,QAAQ,sBAAsB,iBAAiB;CACpD,KACE,QACA,oBACA,eAAe,uBAAuB,iBACxC;CACA,KACE,QACA,mCACA,eAAe,sCAAsC,iBACvD;CACA,KACE,QACA,kCACA,eAAe,qCAAqC,iBACtD;CAMA,KACE,QACA,yCACA,WACE,eAAe,0CACf,eAAe,uBACf,eAAe,+BACjB,CACF;CACA,KACE,QACA,4CACA,WACE,eAAe,6CACf,eAAe,sBACf,eAAe,kCACjB,CACF;CACA,KACE,QACA,2CACA,WACE,eAAe,4CACf,eAAe,qBACf,eAAe,iCACjB,CACF;CAKA,MAAM,aACH,mBAAmB,eAAe,oBAAoB,IACnD,KAAA,IACA,eAAe,0BAClB,mBAAmB,eAAe,cAAc,IAC7C,KAAA,IACA,eAAe;CACrB,IAAI,aAAa,MACf,OAAO,uBAAuB;MAE9B,OAAO,OAAO;CAOhB,MAAM,QAAQ,eAAe;CAC7B,IACE,SAAS,SACR,eAAe,OAAO,iBAAiB,KACtC,oBAAoB,OAAO,mBAAmB,iBAAiB,IAEjE,OAAO,OAAO;CAGhB,MAAM,SAAS,OAAO,OAAO;EAAE,GAAG;EAAO,QAAQ,OAAO,OAAO,MAAM;CAAE,CAAC;CACxE,MAAM,IAAI,OAAO,MAAM;CACvB,OAAO;AACT;AAIA,SAAS,KACP,QACA,KACA,OACM;CACN,IAAI,SAAS,QAAQ,UAAU,IAAI,OAAO,OAAO;AACnD;AAIA,SAAS,WAAW,GAAG,YAAwD;CAC7E,KAAK,MAAM,aAAa,YACtB,IAAI,aAAa,QAAQ,cAAc,IAAI,OAAO;AAGtD;AAIA,SAAS,eAAe,OAAe,SAAsC;CAC3E,OAAO,WAAW,QAAQ,MAAM,YAAY,MAAM,QAAQ,YAAY;AACxE"}

package/node_modules/@pierre/theming/dist/modules/types.d.ts

@@ -0,0 +1,13 @@
+//#region src/modules/types.d.ts
+interface ThemeLike {
+  bg?: string;
+  colors?: Record<string, string>;
+  fg?: string;
+  name?: string;
+  type?: 'dark' | 'light';
+}
+type ColorScheme = 'dark' | 'light';
+type ColorMode = ColorScheme | 'system';
+//#endregion
+export { ColorMode, ColorScheme, ThemeLike };
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@pierre/theming/dist/modules/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/modules/types.ts"],"mappings":";UAAiB,SAAA;EACf,EAAA;EACA,MAAA,GAAS,MAAM;EACf,EAAA;EACA,IAAA;EACA,IAAA;AAAA;AAAA,KAGU,WAAA;AAAA,KAEA,SAAA,GAAY,WAAW"}

package/node_modules/@pierre/theming/dist/modules/unwrapDefault.d.ts

@@ -0,0 +1,8 @@
+//#region src/modules/unwrapDefault.d.ts
+interface DefaultExport<T> {
+  default: T;
+}
+declare function unwrapDefault<T>(value: T | DefaultExport<T>): T;
+//#endregion
+export { DefaultExport, unwrapDefault };
+//# sourceMappingURL=unwrapDefault.d.ts.map

package/node_modules/@pierre/theming/dist/modules/unwrapDefault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapDefault.d.ts","names":[],"sources":["../../src/modules/unwrapDefault.ts"],"mappings":";UAAiB,aAAA;EACf,OAAA,EAAS,CAAC;AAAA;AAAA,iBAMI,aAAA,IAAiB,KAAA,EAAO,CAAA,GAAI,aAAA,CAAc,CAAA,IAAK,CAAA"}

package/node_modules/@pierre/theming/dist/modules/unwrapDefault.js

@@ -0,0 +1,8 @@
+//#region src/modules/unwrapDefault.ts
+function unwrapDefault(value) {
+	return value !== null && typeof value === "object" && "default" in value ? value.default : value;
+}
+//#endregion
+export { unwrapDefault };
+
+//# sourceMappingURL=unwrapDefault.js.map

package/node_modules/@pierre/theming/dist/modules/unwrapDefault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapDefault.js","names":[],"sources":["../../src/modules/unwrapDefault.ts"],"sourcesContent":["export interface DefaultExport<T> {\n  default: T;\n}\n\n// Unwraps the module-namespace shape produced by dynamic import() loaders while\n// leaving bare theme objects untouched. ThemeLike values do not use a top-level\n// `default` key, so this heuristic is safe for theming loaders.\nexport function unwrapDefault<T>(value: T | DefaultExport<T>): T {\n  return value !== null && typeof value === 'object' && 'default' in value\n    ? value.default\n    : value;\n}\n"],"mappings":";AAOA,SAAgB,cAAiB,OAAgC;CAC/D,OAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,aAAa,QAC/D,MAAM,UACN;AACN"}

package/node_modules/@pierre/theming/dist/react.d.ts

@@ -0,0 +1,7 @@
+import { ThemeController, ThemeControllerState } from "./modules/createThemeController.js";
+
+//#region src/react.d.ts
+declare function useThemeController(controller: ThemeController): ThemeControllerState;
+//#endregion
+export { useThemeController };
+//# sourceMappingURL=react.d.ts.map

package/node_modules/@pierre/theming/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","names":[],"sources":["../src/react.ts"],"mappings":";;;iBAkBgB,kBAAA,CACd,UAAA,EAAY,eAAA,GACX,oBAAoB"}

package/node_modules/@pierre/theming/dist/react.js

@@ -0,0 +1,16 @@
+import { useSyncExternalStore } from "react";
+//#region src/react.ts
+/**
+* React bindings for @pierre/theming. A thin useSyncExternalStore wrapper over
+* the framework-agnostic controller with no logic of its own — all state,
+* persistence, and resolution live in the controller, so a non-React app can use
+* it directly. React is an optional peer dependency; importing this entry is the
+* only place React is required.
+*/
+function useThemeController(controller) {
+	return useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
+}
+//#endregion
+export { useThemeController };
+
+//# sourceMappingURL=react.js.map

package/node_modules/@pierre/theming/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../src/react.ts"],"sourcesContent":["/**\n * React bindings for @pierre/theming. A thin useSyncExternalStore wrapper over\n * the framework-agnostic controller with no logic of its own — all state,\n * persistence, and resolution live in the controller, so a non-React app can use\n * it directly. React is an optional peer dependency; importing this entry is the\n * only place React is required.\n */\n\nimport { useSyncExternalStore } from 'react';\n\nimport type { ThemeController, ThemeControllerState } from './index';\n\n// Binds a ThemeController to React via useSyncExternalStore and returns its\n// current state — mode, the selected theme names, the resolved theme, and\n// resolvedColorScheme. The controller emits a new state object only when\n// something changes, so the snapshot reference is stable between renders (no\n// tearing, no render loop). getState doubles as the server snapshot — it returns\n// the initial selection on the server and hydrates on the client.\nexport function useThemeController(\n  controller: ThemeController\n): ThemeControllerState {\n  return useSyncExternalStore(\n    controller.subscribe,\n    controller.getState,\n    controller.getState\n  );\n}\n"],"mappings":";;;;;;;;;AAkBA,SAAgB,mBACd,YACsB;CACtB,OAAO,qBACL,WAAW,WACX,WAAW,UACX,WAAW,QACb;AACF"}

package/node_modules/@pierre/theming/dist/themes.d.ts

@@ -0,0 +1,10 @@
+import { ThemeCollection } from "./modules/createThemeCollection.js";
+import { pierreThemes } from "./collections/pierre.js";
+import { shikiThemes } from "./collections/shiki.js";
+import { CreateThemeOptions, createTheme } from "./modules/createTheme.js";
+
+//#region src/themes.d.ts
+declare const themes: ThemeCollection;
+//#endregion
+export { type CreateThemeOptions, createTheme, pierreThemes, shikiThemes, themes };
+//# sourceMappingURL=themes.d.ts.map

package/node_modules/@pierre/theming/dist/themes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"themes.d.ts","names":[],"sources":["../src/themes.ts"],"mappings":";;;;;;cAoBa,MAAA,EAAQ,eAEnB"}

package/node_modules/@pierre/theming/dist/themes.js

@@ -0,0 +1,15 @@
+import { createThemeCollection } from "./modules/createThemeCollection.js";
+import { createTheme } from "./modules/createTheme.js";
+import { pierreThemes } from "./collections/pierre.js";
+import { shikiThemes } from "./collections/shiki.js";
+//#region src/themes.ts
+/**
+* Bundled theme collections for @pierre/theming.
+* This is the only public package entry that imports Shiki normalization,
+* Shiki-packaged theme modules, or first-party Pierre theme modules.
+*/
+const themes = createThemeCollection({ themes: [pierreThemes, shikiThemes] });
+//#endregion
+export { createTheme, pierreThemes, shikiThemes, themes };
+
+//# sourceMappingURL=themes.js.map

package/node_modules/@pierre/theming/dist/themes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"themes.js","names":[],"sources":["../src/themes.ts"],"sourcesContent":["/**\n * Bundled theme collections for @pierre/theming.\n * This is the only public package entry that imports Shiki normalization,\n * Shiki-packaged theme modules, or first-party Pierre theme modules.\n */\n\nimport { pierreThemes } from './collections/pierre';\nimport { shikiThemes } from './collections/shiki';\nimport { createThemeCollection, type ThemeCollection } from './index';\n\nexport { createTheme, type CreateThemeOptions } from './modules/createTheme';\nexport { pierreThemes } from './collections/pierre';\nexport { shikiThemes } from './collections/shiki';\n\n/*\n * Combined bundled themes\n */\n\n// The default bundled collection keeps the app-facing order stable: Pierre\n// first, then Shiki, while still allowing callers to filter, pick, or reorder.\nexport const themes: ThemeCollection = createThemeCollection({\n  themes: [pierreThemes, shikiThemes],\n});\n"],"mappings":";;;;;;;;;;AAoBA,MAAa,SAA0B,sBAAsB,EAC3D,QAAQ,CAAC,cAAc,WAAW,EACpC,CAAC"}

package/node_modules/@pierre/theming/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@pierre/theming",
+  "version": "1.0.1",
+  "license": "apache-2.0",
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/*"
+      ],
+      "color": [
+        "dist/color.d.ts"
+      ],
+      "react": [
+        "dist/react.d.ts"
+      ],
+      "themes": [
+        "dist/themes.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./color": {
+      "types": "./dist/color.d.ts",
+      "import": "./dist/color.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./themes": {
+      "types": "./dist/themes.d.ts",
+      "import": "./dist/themes.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@shikijs/themes": "4.4.1",
+    "@types/react": "19.2.7",
+    "@types/react-dom": "19.2.3",
+    "react": "19.2.7",
+    "react-dom": "19.2.7",
+    "shiki": "4.4.1",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3",
+    "@pierre/theme": "2.0.0"
+  },
+  "peerDependencies": {
+    "@pierre/theme": "^1.1.0 || ^2.0.0",
+    "@shikijs/themes": "^3.0.0 || ^4.0.0",
+    "react": "^18.3.1 || ^19.0.0",
+    "react-dom": "^18.3.1 || ^19.0.0",
+    "shiki": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "shiki": {
+      "optional": true
+    },
+    "@pierre/theme": {
+      "optional": true
+    },
+    "@shikijs/themes": {
+      "optional": true
+    }
+  },
+  "scripts": {}
+}

package/node_modules/@shikijs/core/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@shikijs/core/README.md

@@ -0,0 +1,5 @@
+# @shikijs/core
+
+The core functionality of [Shiki](https://github.com/shikijs/shiki), without any grammar of themes bundled.
+
+It's the same as importing `shiki/core`.

package/node_modules/@shikijs/core/dist/index.d.mts

@@ -0,0 +1,227 @@
+import { Awaitable, BundledHighlighterOptions, CodeOptionsMultipleThemes, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, CreateBundledHighlighterOptions, CreateHighlighterFactory, GrammarState, HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, Position, RequireKeys, ShikiPrimitive, ShikiTransformer, ShikiTransformerContextCommon, ShikiTransformerContextSource, ThemeRegistration, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokenStyles, TokenizeWithThemeOptions, TokensResult } from "@shikijs/types";
+import { ShikiError, applyColorReplacements, codeToTokensWithThemes, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, getLastGrammarState, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, toArray, tokenizeWithTheme } from "@shikijs/primitive";
+import { toHtml } from "hast-util-to-html";
+import { Element, Root } from "hast";
+export * from "@shikijs/types";
+//#region src/constructors/bundle-factory.d.ts
+/**
+ * Create a `createHighlighter` function with bundled themes, languages, and engine.
+ *
+ * @example
+ * ```ts
+ * const createHighlighter = createBundledHighlighter({
+ *   langs: {
+ *     typescript: () => import('@shikijs/langs/typescript'),
+ *     // ...
+ *   },
+ *   themes: {
+ *     nord: () => import('@shikijs/themes/nord'),
+ *     // ...
+ *   },
+ *   engine: () => createOnigurumaEngine(), // or createJavaScriptRegexEngine()
+ * })
+ * ```
+ *
+ * @param options
+ */
+declare function createBundledHighlighter<BundledLangs extends string, BundledThemes extends string>(options: CreateBundledHighlighterOptions<BundledLangs, BundledThemes>): CreateHighlighterFactory<BundledLangs, BundledThemes>;
+interface ShorthandsBundle<L extends string, T extends string> {
+  /**
+   * Shorthand for `codeToHtml` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToHtml()`, this function is async.
+   */
+  codeToHtml: (code: string, options: CodeToHastOptions<L, T>) => Promise<string>;
+  /**
+   * Shorthand for `codeToHtml` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToHtml()`, this function is async.
+   */
+  codeToHast: (code: string, options: CodeToHastOptions<L, T>) => Promise<Root>;
+  /**
+   * Shorthand for `codeToTokens` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToTokens()`, this function is async.
+   */
+  codeToTokens: (code: string, options: CodeToTokensOptions<L, T>) => Promise<TokensResult>;
+  /**
+   * Shorthand for `codeToTokensBase` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToTokensBase()`, this function is async.
+   */
+  codeToTokensBase: (code: string, options: RequireKeys<CodeToTokensBaseOptions<L, T>, 'theme' | 'lang'>) => Promise<ThemedToken[][]>;
+  /**
+   * Shorthand for `codeToTokensWithThemes` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToTokensWithThemes()`, this function is async.
+   */
+  codeToTokensWithThemes: (code: string, options: RequireKeys<CodeToTokensWithThemesOptions<L, T>, 'themes' | 'lang'>) => Promise<ThemedTokenWithVariants[][]>;
+  /**
+   * Get the singleton highlighter.
+   */
+  getSingletonHighlighter: (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
+  /**
+   * Shorthand for `getLastGrammarState` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   */
+  getLastGrammarState: ((element: ThemedToken[][] | Root) => GrammarState) | ((code: string, options: CodeToTokensBaseOptions<L, T>) => Promise<GrammarState>);
+}
+declare function makeSingletonHighlighter<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>): (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
+interface CreateSingletonShorthandsOptions<L extends string, T extends string> {
+  /**
+   * A custom function to guess embedded languages to be loaded.
+   */
+  guessEmbeddedLanguages?: (code: string, lang: string | undefined, highlighter: HighlighterGeneric<L, T>) => Awaitable<string[] | undefined>;
+}
+declare function createSingletonShorthands<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>, config?: CreateSingletonShorthandsOptions<L, T>): ShorthandsBundle<L, T>;
+//#endregion
+//#region src/constructors/highlighter.d.ts
+/**
+ * Create a Shiki core highlighter instance, with no languages or themes bundled.
+ * Wasm and each language and theme must be loaded manually.
+ *
+ * @see http://shiki.style/guide/bundles#fine-grained-bundle
+ */
+declare function createHighlighterCore(options: HighlighterCoreOptions<false>): Promise<HighlighterCore>;
+/**
+ * Create a Shiki core highlighter instance, with no languages or themes bundled.
+ * Wasm and each language and theme must be loaded manually.
+ *
+ * Synchronous version of `createHighlighterCore`, which requires to provide the engine and all themes and languages upfront.
+ *
+ * @see http://shiki.style/guide/bundles#fine-grained-bundle
+ */
+declare function createHighlighterCoreSync(options: HighlighterCoreOptions<true>): HighlighterCore;
+declare function makeSingletonHighlighterCore(createHighlighter: typeof createHighlighterCore): (options: HighlighterCoreOptions) => Promise<HighlighterCore>;
+declare const getSingletonHighlighterCore: (options: HighlighterCoreOptions) => Promise<HighlighterCore>;
+//#endregion
+//#region src/highlight/code-to-hast.d.ts
+declare function codeToHast(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions, transformerContext?: ShikiTransformerContextCommon): Root;
+declare function tokensToHast(tokens: ThemedToken[][], options: CodeToHastRenderOptions, transformerContext: ShikiTransformerContextSource, grammarState?: GrammarState | undefined): Root;
+//#endregion
+//#region src/highlight/code-to-html.d.ts
+declare const hastToHtml: typeof toHtml;
+/**
+ * Get highlighted code in HTML.
+ */
+declare function codeToHtml(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions): string;
+//#endregion
+//#region src/highlight/code-to-tokens.d.ts
+/**
+ * High-level code-to-tokens API.
+ *
+ * It will use `codeToTokensWithThemes` or `codeToTokensBase` based on the options.
+ */
+declare function codeToTokens(primitive: ShikiPrimitive, code: string, options: CodeToTokensOptions): TokensResult;
+//#endregion
+//#region src/highlight/code-to-tokens-ansi.d.ts
+declare function tokenizeAnsiWithTheme(theme: ThemeRegistrationResolved, fileContents: string, options?: TokenizeWithThemeOptions): ThemedToken[][];
+//#endregion
+//#region src/highlight/code-to-tokens-base.d.ts
+/**
+ * Code to tokens, with a simple theme.
+ * This wraps the tokenizer's implementation to add ANSI support.
+ */
+declare function codeToTokensBase(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): ThemedToken[][];
+//#endregion
+//#region src/theme-css-variables.d.ts
+interface CssVariablesThemeOptions {
+  /**
+   * Theme name. Need to unique if multiple css variables themes are created
+   *
+   * @default 'css-variables'
+   */
+  name?: string;
+  /**
+   * Prefix for css variables
+   *
+   * @default '--shiki-'
+   */
+  variablePrefix?: string;
+  /**
+   * Default value for css variables, the key is without the prefix
+   *
+   * @example `{ 'token-comment': '#888' }` will generate `var(--shiki-token-comment, #888)` for comments
+   */
+  variableDefaults?: Record<string, string>;
+  /**
+   * Enable font style
+   *
+   * @default true
+   */
+  fontStyle?: boolean;
+}
+/**
+ * A factory function to create a css-variable-based theme
+ *
+ * @see https://shiki.style/guide/theme-colors#css-variables-theme
+ */
+declare function createCssVariablesTheme(options?: CssVariablesThemeOptions): ThemeRegistration;
+//#endregion
+//#region src/transformer-decorations.d.ts
+/**
+ * A built-in transformer to add decorations to the highlighted code.
+ */
+declare function transformerDecorations(): ShikiTransformer;
+//#endregion
+//#region src/utils/hast.d.ts
+/**
+ * Utility to append class to a hast node
+ *
+ * If the `property.class` is a string, it will be splitted by space and converted to an array.
+ */
+declare function addClassToHast(node: Element, className: string | string[]): Element;
+//#endregion
+//#region src/utils/strings.d.ts
+/**
+ * Creates a converter between index and position in a code block.
+ *
+ * Overflow/underflow are unchecked.
+ */
+declare function createPositionConverter(code: string): {
+  lines: string[];
+  indexToPos: (index: number) => Position;
+  posToIndex: (line: number, character: number) => number;
+};
+/**
+ * Guess embedded languages from given code and highlighter.
+ *
+ * When highlighter is provided, only bundled languages will be included.
+ *
+ * @param code - The code string to analyze
+ * @param _lang - The primary language of the code (currently unused)
+ * @param highlighter - Optional highlighter instance to validate languages
+ * @returns Array of detected language identifiers
+ *
+ * @example
+ * ```ts
+ * // Detects 'javascript' from Vue SFC
+ * guessEmbeddedLanguages('<script lang="javascript">')
+ *
+ * // Detects 'python' from markdown code block
+ * guessEmbeddedLanguages('```python\nprint("hi")\n```')
+ * ```
+ */
+declare function guessEmbeddedLanguages(code: string, _lang: string | undefined, highlighter?: HighlighterGeneric<any, any>): string[];
+//#endregion
+//#region src/utils/tokens.d.ts
+/**
+ * Split a token into multiple tokens by given offsets.
+ *
+ * The offsets are relative to the token, and should be sorted.
+ */
+declare function splitToken<T extends Pick<ThemedToken, 'content' | 'offset'>>(token: T, offsets: number[]): T[];
+/**
+ * Split 2D tokens array by given breakpoints.
+ */
+declare function splitTokens<T extends Pick<ThemedToken, 'content' | 'offset'>>(tokens: T[][], breakpoints: number[] | Set<number>): T[][];
+declare function flatTokenVariants(merged: ThemedTokenWithVariants, variantsOrder: string[], cssVariablePrefix: string, defaultColor: CodeOptionsMultipleThemes['defaultColor'], colorsRendering?: CodeOptionsMultipleThemes['colorsRendering']): ThemedToken;
+declare function getTokenStyleObject(token: TokenStyles): Record<string, string>;
+declare function stringifyTokenStyle(token: string | Record<string, string>): string;
+//#endregion
+export { CreateSingletonShorthandsOptions, CssVariablesThemeOptions, ShikiError, ShorthandsBundle, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createBundledHighlighter, createCssVariablesTheme, createHighlighterCore, createHighlighterCoreSync, createPositionConverter, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, createSingletonShorthands, flatTokenVariants, getLastGrammarState, getSingletonHighlighterCore, getTokenStyleObject, guessEmbeddedLanguages, hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };