@shikijs/core 1.2.3 → 1.3.0

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;
@@ -799,6 +881,7 @@ interface ShikiTransformerContext extends ShikiTransformerContextSource {
     readonly pre: Element;
     readonly code: Element;
     readonly lines: Element[];
+    readonly structure: CodeToHastOptions['structure'];
     /**
      * Utility to append class to a hast node
      *
@@ -1011,6 +1094,15 @@ interface CodeToHastOptionsCommon<Languages extends string = string> extends Tra
      * @default true
      */
     mergeWhitespaces?: boolean | 'never';
+    /**
+     * The structure of the generated HAST and HTML.
+     *
+     * - `classic`: The classic structure with `<pre>` and `<code>` elements, each line wrapped with a `<span class="line">` element.
+     * - `inline`: All tokens are rendered as `<span>`, line breaks are rendered as `<br>`. No `<pre>` or `<code>` elements. Default forground and background colors are not applied.
+     *
+     * @default 'classic'
+     */
+    structure?: 'classic' | 'inline';
 }
 interface CodeOptionsMeta {
     /**
@@ -1228,4 +1320,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';
 

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) {
@@ -1032,10 +1032,11 @@ function codeToHast(internal, code, options, transformerContext = {
 function tokensToHast(tokens, options, transformerContext) {
     const transformers = getTransformers(options);
     const lines = [];
-    const tree = {
+    const root = {
         type: 'root',
         children: [],
     };
+    const { structure = 'classic', } = options;
     let preNode = {
         type: 'element',
         tagName: 'pre',
@@ -1057,6 +1058,7 @@ function tokensToHast(tokens, options, transformerContext) {
     const lineNodes = [];
     const context = {
         ...transformerContext,
+        structure,
         addClassToHast,
         get source() {
             return transformerContext.source;
@@ -1068,7 +1070,7 @@ function tokensToHast(tokens, options, transformerContext) {
             return options;
         },
         get root() {
-            return tree;
+            return root;
         },
         get pre() {
             return preNode;
@@ -1081,8 +1083,12 @@ function tokensToHast(tokens, options, transformerContext) {
         },
     };
     tokens.forEach((line, idx) => {
-        if (idx)
-            lines.push({ type: 'text', value: '\n' });
+        if (idx) {
+            if (structure === 'inline')
+                root.children.push({ type: 'element', tagName: 'br', properties: {}, children: [] });
+            else if (structure === 'classic')
+                lines.push({ type: 'text', value: '\n' });
+        }
         let lineNode = {
             type: 'element',
             tagName: 'span',
@@ -1102,21 +1108,28 @@ function tokensToHast(tokens, options, transformerContext) {
                 tokenNode.properties.style = style;
             for (const transformer of transformers)
                 tokenNode = transformer?.span?.call(context, tokenNode, idx + 1, col, lineNode) || tokenNode;
-            lineNode.children.push(tokenNode);
+            if (structure === 'inline')
+                root.children.push(tokenNode);
+            else if (structure === 'classic')
+                lineNode.children.push(tokenNode);
             col += token.content.length;
         }
-        for (const transformer of transformers)
-            lineNode = transformer?.line?.call(context, lineNode, idx + 1) || lineNode;
-        lineNodes.push(lineNode);
-        lines.push(lineNode);
+        if (structure === 'classic') {
+            for (const transformer of transformers)
+                lineNode = transformer?.line?.call(context, lineNode, idx + 1) || lineNode;
+            lineNodes.push(lineNode);
+            lines.push(lineNode);
+        }
     });
-    for (const transformer of transformers)
-        codeNode = transformer?.code?.call(context, codeNode) || codeNode;
-    preNode.children.push(codeNode);
-    for (const transformer of transformers)
-        preNode = transformer?.pre?.call(context, preNode) || preNode;
-    tree.children.push(preNode);
-    let result = tree;
+    if (structure === 'classic') {
+        for (const transformer of transformers)
+            codeNode = transformer?.code?.call(context, codeNode) || codeNode;
+        preNode.children.push(codeNode);
+        for (const transformer of transformers)
+            preNode = transformer?.pre?.call(context, preNode) || preNode;
+        root.children.push(preNode);
+    }
+    let result = root;
     for (const transformer of transformers)
         result = transformer?.root?.call(context, result) || result;
     return result;
@@ -3259,6 +3272,12 @@ function stringifyEntities(value, options) {
  */
 
 
+const htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g;
+
+// Declare arrays as variables so it can be cached by `stringifyEntities`
+const bogusCommentEntitySubset = ['>'];
+const commentEntitySubset = ['<', '>'];
+
 /**
  * Serialize a comment.
  *
@@ -3279,10 +3298,12 @@ function comment(node, _1, _2, state) {
     ? '<?' +
         stringifyEntities(
           node.value,
-          Object.assign({}, state.settings.characterReferences, {subset: ['>']})
+          Object.assign({}, state.settings.characterReferences, {
+            subset: bogusCommentEntitySubset
+          })
         ) +
         '>'
-    : '<!--' + node.value.replace(/^>|^->|<!--|-->|--!>|<!-$/g, encode) + '-->'
+    : '<!--' + node.value.replace(htmlCommentRegex, encode) + '-->'
 
   /**
    * @param {string} $0
@@ -3291,7 +3312,7 @@ function comment(node, _1, _2, state) {
     return stringifyEntities(
       $0,
       Object.assign({}, state.settings.characterReferences, {
-        subset: ['<', '>']
+        subset: commentEntitySubset
       })
     )
   }
@@ -4116,7 +4137,7 @@ function element(node, index, parent, state) {
     state.schema = svg;
   }
 
-  const attrs = serializeAttributes(state, node.properties);
+  const attributes = serializeAttributes(state, node.properties);
 
   const content = state.all(
     schema.space === 'html' && node.tagName === 'template' ? node.content : node
@@ -4132,14 +4153,14 @@ function element(node, index, parent, state) {
   // longer void.
   if (content) selfClosing = false;
 
-  if (attrs || !omit || !opening(node, index, parent)) {
-    parts.push('<', node.tagName, attrs ? ' ' + attrs : '');
+  if (attributes || !omit || !opening(node, index, parent)) {
+    parts.push('<', node.tagName, attributes ? ' ' + attributes : '');
 
     if (
       selfClosing &&
       (schema.space === 'svg' || state.settings.closeSelfClosing)
     ) {
-      last = attrs.charAt(attrs.length - 1);
+      last = attributes.charAt(attributes.length - 1);
       if (
         !state.settings.tightSelfClosing ||
         last === '/' ||
@@ -4165,20 +4186,20 @@ function element(node, index, parent, state) {
 
 /**
  * @param {State} state
- * @param {Properties | null | undefined} props
+ * @param {Properties | null | undefined} properties
  * @returns {string}
  */
-function serializeAttributes(state, props) {
+function serializeAttributes(state, properties) {
   /** @type {Array<string>} */
   const values = [];
   let index = -1;
   /** @type {string} */
   let key;
 
-  if (props) {
-    for (key in props) {
-      if (props[key] !== null && props[key] !== undefined) {
-        const value = serializeAttribute(state, key, props[key]);
+  if (properties) {
+    for (key in properties) {
+      if (properties[key] !== null && properties[key] !== undefined) {
+        const value = serializeAttribute(state, key, properties[key]);
         if (value) values.push(value);
       }
     }
@@ -4317,6 +4338,9 @@ function serializeAttribute(state, key, value) {
  */
 
 
+// Declare array as variable so it can be cached by `stringifyEntities`
+const textEntitySubset = ['<', '&'];
+
 /**
  * Serialize a text node.
  *
@@ -4340,7 +4364,7 @@ function text(node, _, parent, state) {
     : stringifyEntities(
         node.value,
         Object.assign({}, state.settings.characterReferences, {
-          subset: ['<', '&']
+          subset: textEntitySubset
         })
       )
 }
@@ -5111,16 +5135,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));
     }
@@ -5132,18 +5160,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);
@@ -5166,13 +5213,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
@@ -5202,7 +5253,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;
@@ -5293,8 +5346,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.3",
+  "version": "1.3.0",
   "description": "Core of Shiki",
   "author": "Pine Wu <octref@gmail.com>; Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -60,7 +60,7 @@
     "dist"
   ],
   "devDependencies": {
-    "hast-util-to-html": "^9.0.0",
+    "hast-util-to-html": "^9.0.1",
     "vscode-oniguruma": "^1.7.0"
   },
   "scripts": {