@shikijs/core 1.2.2 → 1.2.4

package/dist/chunk-tokens.d.mts

@@ -394,6 +394,18 @@ type RuleId = {
     __brand: typeof ruleIdSymbol;
 };
 
+declare class Theme {
+    private readonly _colorMap;
+    private readonly _defaults;
+    private readonly _root;
+    static createFromRawTheme(source: IRawTheme | undefined, colorMap?: string[]): Theme;
+    static createFromParsedTheme(source: ParsedThemeRule[], colorMap?: string[]): Theme;
+    private readonly _cachedMatchRoot;
+    constructor(_colorMap: ColorMap, _defaults: StyleAttributes, _root: ThemeTrieElement);
+    getColorMap(): string[];
+    getDefaults(): StyleAttributes;
+    match(scopePath: ScopeStack | null): StyleAttributes | null;
+}
 /**
  * Identifiers with a binary dot operator.
  * Examples: `baz` or `foo.bar`
@@ -423,6 +435,76 @@ interface IRawThemeSetting {
         readonly background?: string;
     };
 }
+declare class ScopeStack {
+    readonly parent: ScopeStack | null;
+    readonly scopeName: ScopeName;
+    static push(path: ScopeStack | null, scopeNames: ScopeName[]): ScopeStack | null;
+    static from(first: ScopeName, ...segments: ScopeName[]): ScopeStack;
+    static from(...segments: ScopeName[]): ScopeStack | null;
+    constructor(parent: ScopeStack | null, scopeName: ScopeName);
+    push(scopeName: ScopeName): ScopeStack;
+    getSegments(): ScopeName[];
+    toString(): string;
+    extends(other: ScopeStack): boolean;
+    getExtensionIfDefined(base: ScopeStack | null): string[] | undefined;
+}
+declare class StyleAttributes {
+    readonly fontStyle: OrMask<FontStyle$1>;
+    readonly foregroundId: number;
+    readonly backgroundId: number;
+    constructor(fontStyle: OrMask<FontStyle$1>, foregroundId: number, backgroundId: number);
+}
+declare class ParsedThemeRule {
+    readonly scope: ScopeName;
+    readonly parentScopes: ScopeName[] | null;
+    readonly index: number;
+    readonly fontStyle: OrMask<FontStyle$1>;
+    readonly foreground: string | null;
+    readonly background: string | null;
+    constructor(scope: ScopeName, parentScopes: ScopeName[] | null, index: number, fontStyle: OrMask<FontStyle$1>, foreground: string | null, background: string | null);
+}
+declare const enum FontStyle$1 {
+    NotSet = -1,
+    None = 0,
+    Italic = 1,
+    Bold = 2,
+    Underline = 4,
+    Strikethrough = 8
+}
+declare class ColorMap {
+    private readonly _isFrozen;
+    private _lastColorId;
+    private _id2color;
+    private _color2id;
+    constructor(_colorMap?: string[]);
+    getId(color: string | null): number;
+    getColorMap(): string[];
+}
+declare class ThemeTrieElementRule {
+    scopeDepth: number;
+    parentScopes: ScopeName[] | null;
+    fontStyle: number;
+    foreground: number;
+    background: number;
+    constructor(scopeDepth: number, parentScopes: ScopeName[] | null, fontStyle: number, foreground: number, background: number);
+    clone(): ThemeTrieElementRule;
+    static cloneArr(arr: ThemeTrieElementRule[]): ThemeTrieElementRule[];
+    acceptOverwrite(scopeDepth: number, fontStyle: number, foreground: number, background: number): void;
+}
+interface ITrieChildrenMap {
+    [segment: string]: ThemeTrieElement;
+}
+declare class ThemeTrieElement {
+    private readonly _mainRule;
+    private readonly _children;
+    private readonly _rulesWithParentScopes;
+    constructor(_mainRule: ThemeTrieElementRule, rulesWithParentScopes?: ThemeTrieElementRule[], _children?: ITrieChildrenMap);
+    private static _sortBySpecificity;
+    private static _cmpBySpecificity;
+    match(scope: ScopeName): ThemeTrieElementRule[];
+    insert(scopeDepth: number, scope: ScopeName, parentScopes: ScopeName[] | null, fontStyle: number, foreground: number, background: number): void;
+    private _doInsertHere;
+}
 
 interface IRawGrammar extends ILocatable {
     repository: IRawRepository;
@@ -1228,4 +1310,4 @@ declare enum FontStyle {
     Underline = 4
 }
 
-export { type DynamicImportThemeRegistration as $, type ShikiTransformer as A, type BundledHighlighterOptions as B, type CodeToHastOptions as C, type AnsiLanguage as D, type Element as E, FontStyle as F, type ResolveBundleKey as G, type HighlighterCoreOptions as H, INITIAL as I, type LanguageRegistration as J, type BundledLanguageInfo as K, type LanguageInput as L, type MaybeArray as M, type Nodes as N, type DynamicImportLanguageRegistration as O, type PlainTextLanguage as P, type CodeOptionsSingleTheme as Q, Registry as R, type StateStack as S, type ThemeInput as T, type CodeOptionsMultipleThemes as U, type CodeOptionsThemes as V, type CodeToHastOptionsCommon as W, type CodeOptionsMeta as X, type CodeToHastRenderOptionsCommon as Y, type ThemeRegistrationRaw as Z, type ThemeRegistration as _, type IRawTheme as a, type BundledThemeInfo as a0, type ThemedTokenScopeExplanation as a1, type ThemedTokenExplanation as a2, type TokenBase as a3, type TransformerOptions as a4, type ShikiTransformerContextMeta as a5, type ShikiTransformerContext as a6, type Awaitable as a7, type MaybeGetter as a8, type MaybeModule as a9, type StringLiteralUnion as aa, type DecorationOptions as ab, type DecorationItem as ac, type ResolvedDecorationItem as ad, type DecorationTransformType as ae, type Offset as af, type OffsetOrPosition as ag, type ResolvedPosition as ah, type IRawGrammar as b, type IGrammar as c, type IGrammarConfiguration as d, type IOnigLib as e, type RegistryOptions as f, type IRawThemeSetting as g, type Root as h, type CodeToTokensOptions as i, type TokensResult as j, type RequireKeys as k, type CodeToTokensBaseOptions as l, type ThemedToken as m, type CodeToTokensWithThemesOptions as n, type ThemedTokenWithVariants as o, type SpecialLanguage as p, type SpecialTheme as q, type TokenStyles as r, type Position as s, type ThemeRegistrationResolved as t, type TokenizeWithThemeOptions as u, type ShikiTransformerContextCommon as v, type CodeToHastRenderOptions as w, type ShikiTransformerContextSource as x, type RootContent as y, type ThemeRegistrationAny as z };
+export { type ThemeRegistration as $, type ThemeRegistrationAny as A, type BundledHighlighterOptions as B, type CodeToHastOptions as C, type ShikiTransformer as D, type Element as E, FontStyle as F, type AnsiLanguage as G, type HighlighterCoreOptions as H, INITIAL as I, type ResolveBundleKey as J, type LanguageRegistration as K, type LanguageInput as L, type MaybeArray as M, type Nodes as N, type BundledLanguageInfo as O, type PlainTextLanguage as P, type DynamicImportLanguageRegistration as Q, Registry as R, type StateStack as S, Theme as T, type CodeOptionsSingleTheme as U, type CodeOptionsMultipleThemes as V, type CodeOptionsThemes as W, type CodeToHastOptionsCommon as X, type CodeOptionsMeta as Y, type CodeToHastRenderOptionsCommon as Z, type ThemeRegistrationRaw as _, type IRawTheme as a, type DynamicImportThemeRegistration as a0, type BundledThemeInfo as a1, type ThemedTokenScopeExplanation as a2, type ThemedTokenExplanation as a3, type TokenBase as a4, type TransformerOptions as a5, type ShikiTransformerContextMeta as a6, type ShikiTransformerContext as a7, type Awaitable as a8, type MaybeGetter as a9, type MaybeModule as aa, type StringLiteralUnion as ab, type DecorationOptions as ac, type DecorationItem as ad, type ResolvedDecorationItem as ae, type DecorationTransformType as af, type Offset as ag, type OffsetOrPosition as ah, type ResolvedPosition as ai, type IRawGrammar as b, type IGrammar as c, type IGrammarConfiguration as d, type IOnigLib as e, type RegistryOptions as f, type IRawThemeSetting as g, type ThemeInput as h, type Root as i, type CodeToTokensOptions as j, type TokensResult as k, type RequireKeys as l, type CodeToTokensBaseOptions as m, type ThemedToken as n, type CodeToTokensWithThemesOptions as o, type ThemedTokenWithVariants as p, type SpecialLanguage as q, type SpecialTheme as r, type TokenStyles as s, type Position as t, type ThemeRegistrationResolved as u, type TokenizeWithThemeOptions as v, type ShikiTransformerContextCommon as w, type CodeToHastRenderOptions as x, type ShikiTransformerContextSource as y, type RootContent as z };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { HighlighterCore, HighlighterGeneric, ShikiInternal } from './types.mjs';
-import { H as HighlighterCoreOptions, B as BundledHighlighterOptions, L as LanguageInput, T as ThemeInput, C as CodeToHastOptions, h as Root, i as CodeToTokensOptions, j as TokensResult, k as RequireKeys, l as CodeToTokensBaseOptions, m as ThemedToken, n as CodeToTokensWithThemesOptions, o as ThemedTokenWithVariants, M as MaybeArray, P as PlainTextLanguage, p as SpecialLanguage, q as SpecialTheme, E as Element, r as TokenStyles, s as Position, c as IGrammar, t as ThemeRegistrationResolved, u as TokenizeWithThemeOptions, v as ShikiTransformerContextCommon, w as CodeToHastRenderOptions, x as ShikiTransformerContextSource, N as Nodes$1, y as RootContent$1, z as ThemeRegistrationAny, A as ShikiTransformer } from './chunk-tokens.mjs';
-export { D as AnsiLanguage, a7 as Awaitable, K as BundledLanguageInfo, a0 as BundledThemeInfo, X as CodeOptionsMeta, U as CodeOptionsMultipleThemes, Q as CodeOptionsSingleTheme, V as CodeOptionsThemes, W as CodeToHastOptionsCommon, Y as CodeToHastRenderOptionsCommon, ac as DecorationItem, ab as DecorationOptions, ae as DecorationTransformType, O as DynamicImportLanguageRegistration, $ as DynamicImportThemeRegistration, F as FontStyle, J as LanguageRegistration, a8 as MaybeGetter, a9 as MaybeModule, af as Offset, ag as OffsetOrPosition, b as RawGrammar, a as RawTheme, g as RawThemeSetting, G as ResolveBundleKey, ad as ResolvedDecorationItem, ah as ResolvedPosition, a6 as ShikiTransformerContext, a5 as ShikiTransformerContextMeta, aa as StringLiteralUnion, _ as ThemeRegistration, Z as ThemeRegistrationRaw, a2 as ThemedTokenExplanation, a1 as ThemedTokenScopeExplanation, a3 as TokenBase, a4 as TransformerOptions } from './chunk-tokens.mjs';
+import { H as HighlighterCoreOptions, B as BundledHighlighterOptions, L as LanguageInput, h as ThemeInput, C as CodeToHastOptions, i as Root, j as CodeToTokensOptions, k as TokensResult, l as RequireKeys, m as CodeToTokensBaseOptions, n as ThemedToken, o as CodeToTokensWithThemesOptions, p as ThemedTokenWithVariants, M as MaybeArray, P as PlainTextLanguage, q as SpecialLanguage, r as SpecialTheme, E as Element, s as TokenStyles, t as Position, c as IGrammar, u as ThemeRegistrationResolved, v as TokenizeWithThemeOptions, w as ShikiTransformerContextCommon, x as CodeToHastRenderOptions, y as ShikiTransformerContextSource, N as Nodes$1, z as RootContent$1, A as ThemeRegistrationAny, D as ShikiTransformer } from './chunk-tokens.mjs';
+export { G as AnsiLanguage, a8 as Awaitable, O as BundledLanguageInfo, a1 as BundledThemeInfo, Y as CodeOptionsMeta, V as CodeOptionsMultipleThemes, U as CodeOptionsSingleTheme, W as CodeOptionsThemes, X as CodeToHastOptionsCommon, Z as CodeToHastRenderOptionsCommon, ad as DecorationItem, ac as DecorationOptions, af as DecorationTransformType, Q as DynamicImportLanguageRegistration, a0 as DynamicImportThemeRegistration, F as FontStyle, K as LanguageRegistration, a9 as MaybeGetter, aa as MaybeModule, ag as Offset, ah as OffsetOrPosition, b as RawGrammar, a as RawTheme, g as RawThemeSetting, J as ResolveBundleKey, ae as ResolvedDecorationItem, ai as ResolvedPosition, a7 as ShikiTransformerContext, a6 as ShikiTransformerContextMeta, ab as StringLiteralUnion, $ as ThemeRegistration, _ as ThemeRegistrationRaw, a3 as ThemedTokenExplanation, a2 as ThemedTokenScopeExplanation, a4 as TokenBase, a5 as TransformerOptions } from './chunk-tokens.mjs';
 import { L as LoadWasmOptions } from './chunk-index.mjs';
 export { W as WebAssemblyInstantiator, l as loadWasm } from './chunk-index.mjs';
 
@@ -112,6 +112,7 @@ declare function splitToken<T extends Pick<ThemedToken, 'content' | 'offset'>>(t
  */
 declare function splitTokens<T extends Pick<ThemedToken, 'content' | 'offset'>>(tokens: T[][], breakpoints: number[] | Set<number>): T[][];
 declare function applyColorReplacements(color: string, replacements?: Record<string, string>): string;
+declare function applyColorReplacements(color?: string | undefined, replacements?: Record<string, string>): string | undefined;
 declare function getTokenStyleObject(token: TokenStyles): Record<string, string>;
 declare function stringifyTokenStyle(token: Record<string, string>): string;
 /**

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { StackElementMetadata, INITIAL, Registry as Registry$1 } from './textmate.mjs';
+import { StackElementMetadata, INITIAL, Registry as Registry$1, Theme } from './textmate.mjs';
 import { FontStyle } from './types.mjs';
 
 function toArray(x) {
@@ -122,6 +122,8 @@ function splitTokens(tokens, breakpoints) {
     });
 }
 function applyColorReplacements(color, replacements) {
+    if (!color)
+        return color;
     return replacements?.[color?.toLowerCase()] || color;
 }
 function getTokenStyleObject(token) {
@@ -458,6 +460,7 @@ function tokenizeAnsiWithTheme(theme, fileContents, options) {
             bgColor = token.background ? colorPalette.value(token.background) : undefined;
         }
         color = applyColorReplacements(color, colorReplacements);
+        bgColor = applyColorReplacements(bgColor, colorReplacements);
         if (token.decorations.has('dim'))
             color = dimColor(color);
         let fontStyle = FontStyle.None;
@@ -563,13 +566,12 @@ function tokenizeWithTheme(code, grammar, theme, colorMap, options) {
             if (startIndex === nextStartIndex)
                 continue;
             const metadata = result.tokens[2 * j + 1];
-            const foreground = StackElementMetadata.getForeground(metadata);
-            const foregroundColor = applyColorReplacements(colorMap[foreground], colorReplacements);
+            const color = applyColorReplacements(colorMap[StackElementMetadata.getForeground(metadata)], colorReplacements);
             const fontStyle = StackElementMetadata.getFontStyle(metadata);
             const token = {
                 content: line.substring(startIndex, nextStartIndex),
                 offset: lineOffset + startIndex,
-                color: foregroundColor,
+                color,
                 fontStyle,
             };
             if (options.includeExplanation) {
@@ -748,7 +750,7 @@ function codeToTokens(internal, code, options) {
     let themeName;
     let rootStyle;
     if ('themes' in options) {
-        const { defaultColor = 'light', cssVariablePrefix = '--shiki-', } = options;
+        const { defaultColor = 'light', cssVariablePrefix = '--shiki-', colorReplacements, } = options;
         const themes = Object.entries(options.themes)
             .filter(i => i[1])
             .map(i => ({ color: i[0], theme: i[1] }))
@@ -762,16 +764,21 @@ function codeToTokens(internal, code, options) {
         const themesOrder = themes.map(t => t.color);
         tokens = themeTokens
             .map(line => line.map(token => mergeToken(token, themesOrder, cssVariablePrefix, defaultColor)));
-        fg = themes.map((t, idx) => (idx === 0 && defaultColor ? '' : `${cssVariablePrefix + t.color}:`) + (themeRegs[idx].fg || 'inherit')).join(';');
-        bg = themes.map((t, idx) => (idx === 0 && defaultColor ? '' : `${cssVariablePrefix + t.color}-bg:`) + (themeRegs[idx].bg || 'inherit')).join(';');
+        fg = themes.map((t, idx) => (idx === 0 && defaultColor
+            ? ''
+            : `${cssVariablePrefix + t.color}:`) + (applyColorReplacements(themeRegs[idx].fg, colorReplacements) || 'inherit')).join(';');
+        bg = themes.map((t, idx) => (idx === 0 && defaultColor
+            ? ''
+            : `${cssVariablePrefix + t.color}-bg:`) + (applyColorReplacements(themeRegs[idx].bg, colorReplacements) || 'inherit')).join(';');
         themeName = `shiki-themes ${themeRegs.map(t => t.name).join(' ')}`;
         rootStyle = defaultColor ? undefined : [fg, bg].join(';');
     }
     else if ('theme' in options) {
+        const { colorReplacements, } = options;
         tokens = codeToTokensBase(internal, code, options);
         const _theme = internal.getTheme(options.theme);
-        bg = _theme.bg;
-        fg = _theme.fg;
+        bg = applyColorReplacements(_theme.bg, colorReplacements);
+        fg = applyColorReplacements(_theme.fg, colorReplacements);
         themeName = _theme.name;
     }
     else {
@@ -5104,16 +5111,20 @@ class Registry extends Registry$1 {
     _resolver;
     _themes;
     _langs;
+    _alias;
     _resolvedThemes = {};
     _resolvedGrammars = {};
     _langMap = {};
     _langGraph = new Map();
-    alias = {};
-    constructor(_resolver, _themes, _langs) {
+    _textmateThemeCache = new WeakMap();
+    _loadedThemesCache = null;
+    _loadedLanguagesCache = null;
+    constructor(_resolver, _themes, _langs, _alias = {}) {
         super(_resolver);
         this._resolver = _resolver;
         this._themes = _themes;
         this._langs = _langs;
+        this._alias = _alias;
         _themes.forEach(t => this.loadTheme(t));
         _langs.forEach(l => this.loadLanguage(l));
     }
@@ -5125,18 +5136,37 @@ class Registry extends Registry$1 {
     }
     loadTheme(theme) {
         const _theme = normalizeTheme(theme);
-        if (_theme.name)
+        if (_theme.name) {
             this._resolvedThemes[_theme.name] = _theme;
+            // Reset cache
+            this._loadedThemesCache = null;
+        }
         return _theme;
     }
     getLoadedThemes() {
-        return Object.keys(this._resolvedThemes);
+        if (!this._loadedThemesCache)
+            this._loadedThemesCache = Object.keys(this._resolvedThemes);
+        return this._loadedThemesCache;
+    }
+    // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`
+    // is expensive. Themes can switch often especially for dual-theme support.
+    //
+    // The parent class also accepts `colorMap` as the second parameter, but since we don't use that,
+    // we omit here so it's easier to cache the themes.
+    setTheme(theme) {
+        let textmateTheme = this._textmateThemeCache.get(theme);
+        if (!textmateTheme) {
+            textmateTheme = Theme.createFromRawTheme(theme);
+            this._textmateThemeCache.set(theme, textmateTheme);
+        }
+        // @ts-expect-error Access private `_syncRegistry`, but should work in runtime
+        this._syncRegistry.setTheme(textmateTheme);
     }
     getGrammar(name) {
-        if (this.alias[name]) {
+        if (this._alias[name]) {
             const resolved = new Set([name]);
-            while (this.alias[name]) {
-                name = this.alias[name];
+            while (this._alias[name]) {
+                name = this._alias[name];
                 if (resolved.has(name))
                     throw new ShikiError(`Circular alias \`${Array.from(resolved).join(' -> ')} -> ${name}\``);
                 resolved.add(name);
@@ -5159,13 +5189,17 @@ class Registry extends Registry$1 {
         this._resolvedGrammars[lang.name] = g;
         if (lang.aliases) {
             lang.aliases.forEach((alias) => {
-                this.alias[alias] = lang.name;
+                this._alias[alias] = lang.name;
             });
         }
+        // Reset cache
+        this._loadedLanguagesCache = null;
         // If there is a language that embeds this language lazily, we need to reload it
         if (embeddedLazilyBy.size) {
             for (const e of embeddedLazilyBy) {
                 delete this._resolvedGrammars[e.name];
+                // Reset cache
+                this._loadedLanguagesCache = null;
                 // @ts-expect-error clear cache
                 this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
                 // @ts-expect-error clear cache
@@ -5195,7 +5229,9 @@ class Registry extends Registry$1 {
             await this.loadLanguage(lang);
     }
     getLoadedLanguages() {
-        return Object.keys({ ...this._resolvedGrammars, ...this.alias });
+        if (!this._loadedLanguagesCache)
+            this._loadedLanguagesCache = Object.keys({ ...this._resolvedGrammars, ...this._alias });
+        return this._loadedLanguagesCache;
     }
     resolveEmbeddedLanguages(lang) {
         this._langMap[lang.name] = lang;
@@ -5286,8 +5322,7 @@ async function getShikiInternal(options = {}) {
             return createOnigString(s);
         },
     }), langs);
-    const _registry = new Registry(resolver, themes, langs);
-    Object.assign(_registry.alias, options.langAlias);
+    const _registry = new Registry(resolver, themes, langs, options.langAlias);
     await _registry.init();
     let _lastTheme;
     function getLanguage(name) {

package/dist/textmate.d.mts

@@ -1,5 +1,5 @@
 import { F as FontStyle } from './chunk-tokens.mjs';
-export { c as IGrammar, d as IGrammarConfiguration, I as INITIAL, e as IOnigLib, b as IRawGrammar, a as IRawTheme, g as IRawThemeSetting, R as Registry, f as RegistryOptions, S as StateStack } from './chunk-tokens.mjs';
+export { c as IGrammar, d as IGrammarConfiguration, I as INITIAL, e as IOnigLib, b as IRawGrammar, a as IRawTheme, g as IRawThemeSetting, R as Registry, f as RegistryOptions, S as StateStack, T as Theme } from './chunk-tokens.mjs';
 import './chunk-index.mjs';
 
 declare const enum TemporaryStandardTokenType {

package/dist/textmate.mjs

@@ -3132,4 +3132,4 @@ class StackElementMetadata {
     }
 }
 
-export { INITIAL, Registry$1 as Registry, StackElementMetadata };
+export { INITIAL, Registry$1 as Registry, StackElementMetadata, Theme };

package/dist/types.d.mts

@@ -1,5 +1,5 @@
-import { T as ThemeInput, q as SpecialTheme, L as LanguageInput, p as SpecialLanguage, z as ThemeRegistrationAny, t as ThemeRegistrationResolved, J as LanguageRegistration, c as IGrammar, C as CodeToHastOptions, G as ResolveBundleKey, h as Root, i as CodeToTokensOptions, j as TokensResult, l as CodeToTokensBaseOptions, m as ThemedToken, n as CodeToTokensWithThemesOptions, o as ThemedTokenWithVariants } from './chunk-tokens.mjs';
-export { D as AnsiLanguage, a7 as Awaitable, B as BundledHighlighterOptions, K as BundledLanguageInfo, a0 as BundledThemeInfo, X as CodeOptionsMeta, U as CodeOptionsMultipleThemes, Q as CodeOptionsSingleTheme, V as CodeOptionsThemes, W as CodeToHastOptionsCommon, w as CodeToHastRenderOptions, Y as CodeToHastRenderOptionsCommon, ac as DecorationItem, ab as DecorationOptions, ae as DecorationTransformType, O as DynamicImportLanguageRegistration, $ as DynamicImportThemeRegistration, F as FontStyle, H as HighlighterCoreOptions, M as MaybeArray, a8 as MaybeGetter, a9 as MaybeModule, af as Offset, ag as OffsetOrPosition, P as PlainTextLanguage, s as Position, b as RawGrammar, a as RawTheme, g as RawThemeSetting, k as RequireKeys, ad as ResolvedDecorationItem, ah as ResolvedPosition, A as ShikiTransformer, a6 as ShikiTransformerContext, v as ShikiTransformerContextCommon, a5 as ShikiTransformerContextMeta, x as ShikiTransformerContextSource, aa as StringLiteralUnion, _ as ThemeRegistration, Z as ThemeRegistrationRaw, a2 as ThemedTokenExplanation, a1 as ThemedTokenScopeExplanation, a3 as TokenBase, r as TokenStyles, u as TokenizeWithThemeOptions, a4 as TransformerOptions } from './chunk-tokens.mjs';
+import { h as ThemeInput, r as SpecialTheme, L as LanguageInput, q as SpecialLanguage, A as ThemeRegistrationAny, u as ThemeRegistrationResolved, K as LanguageRegistration, c as IGrammar, C as CodeToHastOptions, J as ResolveBundleKey, i as Root, j as CodeToTokensOptions, k as TokensResult, m as CodeToTokensBaseOptions, n as ThemedToken, o as CodeToTokensWithThemesOptions, p as ThemedTokenWithVariants } from './chunk-tokens.mjs';
+export { G as AnsiLanguage, a8 as Awaitable, B as BundledHighlighterOptions, O as BundledLanguageInfo, a1 as BundledThemeInfo, Y as CodeOptionsMeta, V as CodeOptionsMultipleThemes, U as CodeOptionsSingleTheme, W as CodeOptionsThemes, X as CodeToHastOptionsCommon, x as CodeToHastRenderOptions, Z as CodeToHastRenderOptionsCommon, ad as DecorationItem, ac as DecorationOptions, af as DecorationTransformType, Q as DynamicImportLanguageRegistration, a0 as DynamicImportThemeRegistration, F as FontStyle, H as HighlighterCoreOptions, M as MaybeArray, a9 as MaybeGetter, aa as MaybeModule, ag as Offset, ah as OffsetOrPosition, P as PlainTextLanguage, t as Position, b as RawGrammar, a as RawTheme, g as RawThemeSetting, l as RequireKeys, ae as ResolvedDecorationItem, ai as ResolvedPosition, D as ShikiTransformer, a7 as ShikiTransformerContext, w as ShikiTransformerContextCommon, a6 as ShikiTransformerContextMeta, y as ShikiTransformerContextSource, ab as StringLiteralUnion, $ as ThemeRegistration, _ as ThemeRegistrationRaw, a3 as ThemedTokenExplanation, a2 as ThemedTokenScopeExplanation, a4 as TokenBase, s as TokenStyles, v as TokenizeWithThemeOptions, a5 as TransformerOptions } from './chunk-tokens.mjs';
 export { W as WebAssemblyInstantiator } from './chunk-index.mjs';
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/core",
   "type": "module",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Core of Shiki",
   "author": "Pine Wu <octref@gmail.com>; Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",