@shikijs/core 1.7.0 → 1.9.0

package/dist/chunk-tokens.d.mts

@@ -1017,7 +1017,7 @@ interface BundledHighlighterOptions<L extends string, T extends string> {
      *
      * @default []
      */
-    themes: (ThemeInput | StringLiteralUnion<T>)[];
+    themes: (ThemeInput | StringLiteralUnion<T> | SpecialTheme)[];
     /**
      * Language registation
      *

package/dist/index.d.mts

@@ -10,17 +10,23 @@ export { W as WebAssemblyInstantiator, l as loadWasm } from './chunk-index.mjs';
  *
  * @see http://shiki.style/guide/install#fine-grained-bundle
  */
+declare function createHighlighterCore(options?: HighlighterCoreOptions): Promise<HighlighterCore>;
+declare function makeSingletonHighlighterCore(createHighlighter: typeof createHighlighterCore): (options?: Partial<HighlighterCoreOptions>) => Promise<HighlighterCore>;
+declare const getSingletonHighlighterCore: (options?: Partial<HighlighterCoreOptions>) => Promise<HighlighterCore>;
+/**
+ * @deprecated Use `createHighlighterCore` or `getSingletonHighlighterCore` instead.
+ */
 declare function getHighlighterCore(options?: HighlighterCoreOptions): Promise<HighlighterCore>;
 
-type GetHighlighterFactory<L extends string, T extends string> = (options: BundledHighlighterOptions<L, T>) => Promise<HighlighterGeneric<L, T>>;
+type CreateHighlighterFactory<L extends string, T extends string> = (options: BundledHighlighterOptions<L, T>) => Promise<HighlighterGeneric<L, T>>;
 /**
- * Create a `getHighlighter` function with bundled themes and languages.
+ * Create a `createHighlighter` function with bundled themes and languages.
  *
  * @param bundledLanguages
  * @param bundledThemes
  * @param loadWasm
  */
-declare function createdBundledHighlighter<BundledLangs extends string, BundledThemes extends string>(bundledLanguages: Record<BundledLangs, LanguageInput>, bundledThemes: Record<BundledThemes, ThemeInput>, loadWasm: HighlighterCoreOptions['loadWasm']): GetHighlighterFactory<BundledLangs, BundledThemes>;
+declare function createdBundledHighlighter<BundledLangs extends string, BundledThemes extends string>(bundledLanguages: Record<BundledLangs, LanguageInput>, bundledThemes: Record<BundledThemes, ThemeInput>, loadWasm: HighlighterCoreOptions['loadWasm']): CreateHighlighterFactory<BundledLangs, BundledThemes>;
 interface ShorthandsBundle<L extends string, T extends string> {
     /**
      * Shorthand for `codeToHtml` with auto-loaded theme and language.
@@ -59,12 +65,11 @@ interface ShorthandsBundle<L extends string, T extends string> {
     codeToTokensWithThemes: (code: string, options: RequireKeys<CodeToTokensWithThemesOptions<L, T>, 'themes' | 'lang'>) => Promise<ThemedTokenWithVariants[][]>;
     /**
      * Get internal singleton highlighter.
-     *
-     * @internal
      */
-    getSingletonHighlighter: () => Promise<HighlighterGeneric<L, T>>;
+    getSingletonHighlighter: (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
 }
-declare function createSingletonShorthands<L extends string, T extends string>(getHighlighter: GetHighlighterFactory<L, T>): ShorthandsBundle<L, T>;
+declare function makeSingletonHighlighter<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>): (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
+declare function createSingletonShorthands<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>): ShorthandsBundle<L, T>;
 
 declare function toArray<T>(x: MaybeArray<T>): T[];
 /**
@@ -135,6 +140,10 @@ declare function setDefaultWasmLoader(_loader: LoadWasmOptions): void;
 /**
  * Get the minimal shiki context for rendering.
  */
+declare function createShikiInternal(options?: HighlighterCoreOptions): Promise<ShikiInternal>;
+/**
+ * @deprecated Use `createShikiInternal` instead.
+ */
 declare function getShikiInternal(options?: HighlighterCoreOptions): Promise<ShikiInternal>;
 
 /**
@@ -401,4 +410,4 @@ declare class ShikiError extends Error {
     constructor(message: string);
 }
 
-export { BundledHighlighterOptions, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, type GetHighlighterFactory, IGrammar as Grammar, HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, LanguageInput, MaybeArray, PlainTextLanguage, Position, RequireKeys, ShikiError, ShikiInternal, ShikiTransformer, ShikiTransformerContextCommon, ShikiTransformerContextSource, type ShorthandsBundle, SpecialLanguage, SpecialTheme, ThemeInput, ThemeRegistrationAny, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokenStyles, TokenizeWithThemeOptions, TokensResult, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createPositionConverter, createSingletonShorthands, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+export { BundledHighlighterOptions, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, type CreateHighlighterFactory, IGrammar as Grammar, HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, LanguageInput, MaybeArray, PlainTextLanguage, Position, RequireKeys, ShikiError, ShikiInternal, ShikiTransformer, ShikiTransformerContextCommon, ShikiTransformerContextSource, type ShorthandsBundle, SpecialLanguage, SpecialTheme, ThemeInput, ThemeRegistrationAny, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokenStyles, TokenizeWithThemeOptions, TokensResult, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createPositionConverter, createShikiInternal, createSingletonShorthands, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };

package/dist/index.mjs

@@ -5199,9 +5199,9 @@ class Registry extends Registry$1 {
     _themes;
     _langs;
     _alias;
-    _resolvedThemes = {};
-    _resolvedGrammars = {};
-    _langMap = {};
+    _resolvedThemes = new Map();
+    _resolvedGrammars = new Map();
+    _langMap = new Map();
     _langGraph = new Map();
     _textmateThemeCache = new WeakMap();
     _loadedThemesCache = null;
@@ -5217,14 +5217,14 @@ class Registry extends Registry$1 {
     }
     getTheme(theme) {
         if (typeof theme === 'string')
-            return this._resolvedThemes[theme];
+            return this._resolvedThemes.get(theme);
         else
             return this.loadTheme(theme);
     }
     loadTheme(theme) {
         const _theme = normalizeTheme(theme);
         if (_theme.name) {
-            this._resolvedThemes[_theme.name] = _theme;
+            this._resolvedThemes.set(_theme.name, _theme);
             // Reset cache
             this._loadedThemesCache = null;
         }
@@ -5232,7 +5232,7 @@ class Registry extends Registry$1 {
     }
     getLoadedThemes() {
         if (!this._loadedThemesCache)
-            this._loadedThemesCache = Object.keys(this._resolvedThemes);
+            this._loadedThemesCache = [...this._resolvedThemes.keys()];
         return this._loadedThemesCache;
     }
     // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`
@@ -5259,12 +5259,13 @@ class Registry extends Registry$1 {
                 resolved.add(name);
             }
         }
-        return this._resolvedGrammars[name];
+        return this._resolvedGrammars.get(name);
     }
     async loadLanguage(lang) {
         if (this.getGrammar(lang.name))
             return;
-        const embeddedLazilyBy = new Set(Object.values(this._langMap).filter(i => i.embeddedLangsLazy?.includes(lang.name)));
+        const embeddedLazilyBy = new Set([...this._langMap.values()]
+            .filter(i => i.embeddedLangsLazy?.includes(lang.name)));
         this._resolver.addLanguage(lang);
         const grammarConfig = {
             balancedBracketSelectors: lang.balancedBracketSelectors || ['*'],
@@ -5273,7 +5274,7 @@ class Registry extends Registry$1 {
         // @ts-expect-error Private members, set this to override the previous grammar (that can be a stub)
         this._syncRegistry._rawGrammars.set(lang.scopeName, lang);
         const g = await this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
-        this._resolvedGrammars[lang.name] = g;
+        this._resolvedGrammars.set(lang.name, g);
         if (lang.aliases) {
             lang.aliases.forEach((alias) => {
                 this._alias[alias] = lang.name;
@@ -5284,14 +5285,14 @@ class Registry extends Registry$1 {
         // 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];
+                this._resolvedGrammars.delete(e.name);
                 // Reset cache
                 this._loadedLanguagesCache = null;
                 // @ts-expect-error clear cache
                 this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
                 // @ts-expect-error clear cache
                 this._syncRegistry?._grammars?.delete(e.scopeName);
-                await this.loadLanguage(this._langMap[e.name]);
+                await this.loadLanguage(this._langMap.get(e.name));
             }
         }
     }
@@ -5299,6 +5300,14 @@ class Registry extends Registry$1 {
         this._themes.map(t => this.loadTheme(t));
         await this.loadLanguages(this._langs);
     }
+    dispose() {
+        super.dispose();
+        this._resolvedThemes.clear();
+        this._resolvedGrammars.clear();
+        this._langMap.clear();
+        this._langGraph.clear();
+        this._loadedThemesCache = null;
+    }
     async loadLanguages(langs) {
         for (const lang of langs)
             this.resolveEmbeddedLanguages(lang);
@@ -5316,16 +5325,19 @@ class Registry extends Registry$1 {
             await this.loadLanguage(lang);
     }
     getLoadedLanguages() {
-        if (!this._loadedLanguagesCache)
-            this._loadedLanguagesCache = Object.keys({ ...this._resolvedGrammars, ...this._alias });
+        if (!this._loadedLanguagesCache) {
+            this._loadedLanguagesCache = [
+                ...new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)]),
+            ];
+        }
         return this._loadedLanguagesCache;
     }
     resolveEmbeddedLanguages(lang) {
-        this._langMap[lang.name] = lang;
+        this._langMap.set(lang.name, lang);
         this._langGraph.set(lang.name, lang);
         if (lang.embeddedLangs) {
             for (const embeddedLang of lang.embeddedLangs)
-                this._langGraph.set(embeddedLang, this._langMap[embeddedLang]);
+                this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));
         }
     }
 }
@@ -5387,10 +5399,11 @@ let instancesCount = 0;
 /**
  * Get the minimal shiki context for rendering.
  */
-async function getShikiInternal(options = {}) {
+async function createShikiInternal(options = {}) {
     instancesCount += 1;
     if (options.warnings !== false && instancesCount >= 10 && instancesCount % 10 === 0)
-        console.warn(`[Shiki] ${instancesCount} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance.`);
+        console.warn(`[Shiki] ${instancesCount} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \`highlighter.dispose()\` to release unused instances.`);
+    let isDisposed = false;
     async function normalizeGetter(p) {
         return Promise.resolve(typeof p === 'function' ? p() : p).then(r => r.default || r);
     }
@@ -5417,6 +5430,7 @@ async function getShikiInternal(options = {}) {
     await _registry.init();
     let _lastTheme;
     function getLanguage(name) {
+        ensureNotDisposed();
         const _lang = _registry.getGrammar(typeof name === 'string' ? name : name.name);
         if (!_lang)
             throw new ShikiError(`Language \`${name}\` not found, you may need to load it first`);
@@ -5425,12 +5439,14 @@ async function getShikiInternal(options = {}) {
     function getTheme(name) {
         if (name === 'none')
             return { bg: '', fg: '', name: 'none', settings: [], type: 'dark' };
+        ensureNotDisposed();
         const _theme = _registry.getTheme(name);
         if (!_theme)
             throw new ShikiError(`Theme \`${name}\` not found, you may need to load it first`);
         return _theme;
     }
     function setTheme(name) {
+        ensureNotDisposed();
         const theme = getTheme(name);
         if (_lastTheme !== name) {
             _registry.setTheme(theme);
@@ -5443,19 +5459,34 @@ async function getShikiInternal(options = {}) {
         };
     }
     function getLoadedThemes() {
+        ensureNotDisposed();
         return _registry.getLoadedThemes();
     }
     function getLoadedLanguages() {
+        ensureNotDisposed();
         return _registry.getLoadedLanguages();
     }
     async function loadLanguage(...langs) {
+        ensureNotDisposed();
         await _registry.loadLanguages(await resolveLangs(langs));
     }
     async function loadTheme(...themes) {
+        ensureNotDisposed();
         await Promise.all(themes.map(async (theme) => isSpecialTheme(theme)
             ? null
             : _registry.loadTheme(await normalizeGetter(theme))));
     }
+    function ensureNotDisposed() {
+        if (isDisposed)
+            throw new ShikiError('Shiki instance has been disposed');
+    }
+    function dispose() {
+        if (isDisposed)
+            return;
+        isDisposed = true;
+        _registry.dispose();
+        instancesCount -= 1;
+    }
     return {
         setTheme,
         getTheme,
@@ -5464,8 +5495,17 @@ async function getShikiInternal(options = {}) {
         getLoadedLanguages,
         loadLanguage,
         loadTheme,
+        dispose,
+        [Symbol.dispose]: dispose,
     };
 }
+/**
+ * @deprecated Use `createShikiInternal` instead.
+ */
+function getShikiInternal(options = {}) {
+    // TODO: next: console.warn('`getShikiInternal` is deprecated. Use `createShikiInternal` instead.')
+    return createShikiInternal(options);
+}
 
 /**
  * Create a Shiki core highlighter instance, with no languages or themes bundled.
@@ -5473,8 +5513,8 @@ async function getShikiInternal(options = {}) {
  *
  * @see http://shiki.style/guide/install#fine-grained-bundle
  */
-async function getHighlighterCore(options = {}) {
-    const internal = await getShikiInternal(options);
+async function createHighlighterCore(options = {}) {
+    const internal = await createShikiInternal(options);
     return {
         codeToTokensBase: (code, options) => codeToTokensBase(internal, code, options),
         codeToTokensWithThemes: (code, options) => codeToTokensWithThemes(internal, code, options),
@@ -5485,16 +5525,47 @@ async function getHighlighterCore(options = {}) {
         getInternalContext: () => internal,
     };
 }
+function makeSingletonHighlighterCore(createHighlighter) {
+    let _shiki;
+    async function getSingletonHighlighterCore(options = {}) {
+        if (!_shiki) {
+            _shiki = createHighlighter({
+                ...options,
+                themes: options.themes || [],
+                langs: options.langs || [],
+            });
+            return _shiki;
+        }
+        else {
+            const s = await _shiki;
+            await Promise.all([
+                s.loadTheme(...(options.themes || [])),
+                s.loadLanguage(...(options.langs || [])),
+            ]);
+            return s;
+        }
+    }
+    return getSingletonHighlighterCore;
+}
+const getSingletonHighlighterCore = /* @__PURE__ */ makeSingletonHighlighterCore(createHighlighterCore);
+/**
+ * @deprecated Use `createHighlighterCore` or `getSingletonHighlighterCore` instead.
+ */
+/* v8 ignore next 5 */
+function getHighlighterCore(options = {}) {
+    // TODO: next:  console.warn('`getHighlighterCore` is deprecated. Use `createHighlighterCore` or `getSingletonHighlighterCore` instead.')
+    return createHighlighterCore(options);
+}
 
 /**
- * Create a `getHighlighter` function with bundled themes and languages.
+ * Create a `createHighlighter` function with bundled themes and languages.
  *
  * @param bundledLanguages
  * @param bundledThemes
  * @param loadWasm
  */
 function createdBundledHighlighter(bundledLanguages, bundledThemes, loadWasm) {
-    async function getHighlighter(options) {
+    async function createHighlighter(options) {
         function resolveLang(lang) {
             if (typeof lang === 'string') {
                 if (isSpecialLang(lang))
@@ -5520,7 +5591,7 @@ function createdBundledHighlighter(bundledLanguages, bundledThemes, loadWasm) {
         const _themes = (options.themes ?? []).map(i => resolveTheme(i));
         const langs = (options.langs ?? [])
             .map(i => resolveLang(i));
-        const core = await getHighlighterCore({
+        const core = await createHighlighterCore({
             ...options,
             themes: _themes,
             langs,
@@ -5536,62 +5607,72 @@ function createdBundledHighlighter(bundledLanguages, bundledThemes, loadWasm) {
             },
         };
     }
-    return getHighlighter;
+    return createHighlighter;
 }
-function createSingletonShorthands(getHighlighter) {
+function makeSingletonHighlighter(createHighlighter) {
     let _shiki;
-    async function _getHighlighter(options = {}) {
+    async function getSingletonHighlighter(options = {}) {
         if (!_shiki) {
-            _shiki = getHighlighter({
-                themes: toArray(options.theme || []),
-                langs: toArray(options.lang || []),
+            _shiki = createHighlighter({
+                ...options,
+                themes: options.themes || [],
+                langs: options.langs || [],
             });
             return _shiki;
         }
         else {
             const s = await _shiki;
             await Promise.all([
-                s.loadTheme(...toArray(options.theme || [])),
-                s.loadLanguage(...toArray(options.lang || [])),
+                s.loadTheme(...(options.themes || [])),
+                s.loadLanguage(...(options.langs || [])),
             ]);
             return s;
         }
     }
+    return getSingletonHighlighter;
+}
+function createSingletonShorthands(createHighlighter) {
+    const getSingletonHighlighter = makeSingletonHighlighter(createHighlighter);
     return {
-        getSingletonHighlighter: () => _getHighlighter(),
+        getSingletonHighlighter(options) {
+            return getSingletonHighlighter(options);
+        },
         async codeToHtml(code, options) {
-            const shiki = await _getHighlighter({
-                lang: options.lang,
-                theme: ('theme' in options ? [options.theme] : Object.values(options.themes)),
+            const shiki = await getSingletonHighlighter({
+                langs: [options.lang],
+                themes: ('theme' in options ? [options.theme] : Object.values(options.themes)),
             });
             return shiki.codeToHtml(code, options);
         },
         async codeToHast(code, options) {
-            const shiki = await _getHighlighter({
-                lang: options.lang,
-                theme: ('theme' in options ? [options.theme] : Object.values(options.themes)),
+            const shiki = await getSingletonHighlighter({
+                langs: [options.lang],
+                themes: ('theme' in options ? [options.theme] : Object.values(options.themes)),
             });
             return shiki.codeToHast(code, options);
         },
         async codeToTokens(code, options) {
-            const shiki = await _getHighlighter({
-                lang: options.lang,
-                theme: ('theme' in options ? [options.theme] : Object.values(options.themes)),
+            const shiki = await getSingletonHighlighter({
+                langs: [options.lang],
+                themes: ('theme' in options ? [options.theme] : Object.values(options.themes)),
             });
             return shiki.codeToTokens(code, options);
         },
         async codeToTokensBase(code, options) {
-            const shiki = await _getHighlighter(options);
+            const shiki = await getSingletonHighlighter({
+                langs: [options.lang],
+                themes: [options.theme],
+            });
             return shiki.codeToTokensBase(code, options);
         },
         async codeToTokensWithThemes(code, options) {
-            const shiki = await _getHighlighter({
-                lang: options.lang,
-                theme: Object.values(options.themes).filter(Boolean),
+            const shiki = await getSingletonHighlighter({
+                langs: [options.lang],
+                themes: Object.values(options.themes).filter(Boolean),
             });
             return shiki.codeToTokensWithThemes(code, options);
         },
     };
 }
 
-export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createPositionConverter, createSingletonShorthands, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createPositionConverter, createShikiInternal, createSingletonShorthands, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };

package/dist/types.d.mts

@@ -42,6 +42,14 @@ interface ShikiInternal<BundledLangKeys extends string = never, BundledThemeKeys
      * Special-handled themes like `none` are not included.
      */
     getLoadedThemes: () => string[];
+    /**
+     * Dispose the internal registry and release resources
+     */
+    dispose: () => void;
+    /**
+     * Dispose the internal registry and release resources
+     */
+    [Symbol.dispose]: () => void;
 }
 /**
  * Generic instance interface of Shiki

package/package.json

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