@shikijs/core 1.0.0-beta.5 → 1.0.0-rc.0

package/dist/chunk-tokens.d.mts

@@ -814,59 +814,40 @@ interface ShikiTransformer {
     /**
      * Transform the raw input code before passing to the highlighter.
      */
-    preprocess?(this: ShikiTransformerContextCommon, code: string, options: CodeToHastOptions): string | void;
+    preprocess?: (this: ShikiTransformerContextCommon, code: string, options: CodeToHastOptions) => string | void;
     /**
      * Transform the full tokens list before converting to HAST.
      * Return a new tokens list will replace the original one.
      */
-    tokens?(this: ShikiTransformerContextSource, tokens: ThemedToken[][]): ThemedToken[][] | void;
+    tokens?: (this: ShikiTransformerContextSource, tokens: ThemedToken[][]) => ThemedToken[][] | void;
     /**
      * Transform the entire generated HAST tree. Return a new Node will replace the original one.
      */
-    root?(this: ShikiTransformerContext, hast: Root): Root | void;
+    root?: (this: ShikiTransformerContext, hast: Root) => Root | void;
     /**
      * Transform the `<pre>` element. Return a new Node will replace the original one.
      */
-    pre?(this: ShikiTransformerContext, hast: Element): Element | void;
+    pre?: (this: ShikiTransformerContext, hast: Element) => Element | void;
     /**
      * Transform the `<code>` element. Return a new Node will replace the original one.
      */
-    code?(this: ShikiTransformerContext, hast: Element): Element | void;
+    code?: (this: ShikiTransformerContext, hast: Element) => Element | void;
     /**
      * Transform each line `<span class="line">` element.
      *
      * @param hast
      * @param line 1-based line number
      */
-    line?(this: ShikiTransformerContext, hast: Element, line: number): Element | void;
+    line?: (this: ShikiTransformerContext, hast: Element, line: number) => Element | void;
     /**
      * Transform each token `<span>` element.
      */
-    span?(this: ShikiTransformerContext, hast: Element, line: number, col: number, lineElement: Element): Element | void;
+    span?: (this: ShikiTransformerContext, hast: Element, line: number, col: number, lineElement: Element) => Element | void;
     /**
      * Transform the generated HTML string before returning.
      * This hook will only be called with `codeToHtml`.
      */
-    postprocess?(this: ShikiTransformerContextCommon, html: string, options: CodeToHastOptions): string | void;
-    /**
-     * @deprecated Use `span` instead
-     */
-    token?(this: ShikiTransformerContext, hast: Element, line: number, col: number, lineElement: Element): Element | void;
-}
-/**
- * @deprecated Rnamed to `ShikiTransformer`
- */
-interface ShikijiTransformer extends ShikiTransformer {
-}
-/**
- * @deprecated Rnamed to `ShikiTransformerContext`
- */
-interface ShikijiTransformerContext extends ShikiTransformerContext {
-}
-/**
- * @deprecated Rnamed to `ShikiTransformerContextCommon`
- */
-interface ShikijiTransformerContextCommon extends ShikiTransformerContextCommon {
+    postprocess?: (this: ShikiTransformerContextCommon, html: string, options: CodeToHastOptions) => string | void;
 }
 
 interface DecorationOptions {
@@ -1235,4 +1216,4 @@ declare enum FontStyle {
     Underline = 4
 }
 
-export { type DynamicImportThemeRegistration as $, type AnsiLanguage as A, type BundledHighlighterOptions as B, type CodeToHastOptions as C, type SpecialLanguage 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 Position 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 ShikijiTransformer as a7, type ShikijiTransformerContext as a8, type ShikijiTransformerContextCommon as a9, type Awaitable as aa, type MaybeGetter as ab, type MaybeModule as ac, type StringLiteralUnion as ad, type DecorationOptions as ae, type DecorationItem as af, type ResolvedDecorationItem as ag, type DecorationTransformType as ah, type Offset as ai, type OffsetOrPosition as aj, type ResolvedPosition as ak, 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 SpecialTheme as p, type TokenStyles as q, type ThemeRegistrationResolved as r, type TokenizeWithThemeOptions as s, type ShikiTransformerContextCommon as t, type CodeToHastRenderOptions as u, type ShikiTransformerContextSource as v, type RootContent as w, type ThemeRegistrationAny as x, type ShikiTransformer as y, type PlainTextLanguage as z };
+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 };

package/dist/index.d.mts

@@ -1,10 +1,9 @@
-import { 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 SpecialTheme, E as Element, q as TokenStyles, P as Position, c as IGrammar, r as ThemeRegistrationResolved, s as TokenizeWithThemeOptions, t as ShikiTransformerContextCommon, u as CodeToHastRenderOptions, v as ShikiTransformerContextSource, N as Nodes$1, w as RootContent$1, x as ThemeRegistrationAny, y as ShikiTransformer } from './chunk-tokens.mjs';
-export { A as AnsiLanguage, aa 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, af as DecorationItem, ae as DecorationOptions, ah as DecorationTransformType, O as DynamicImportLanguageRegistration, $ as DynamicImportThemeRegistration, F as FontStyle, b as IRawGrammar, J as LanguageRegistration, ab as MaybeGetter, ac as MaybeModule, ai as Offset, aj as OffsetOrPosition, z as PlainTextLanguage, b as RawGrammar, a as RawTheme, g as RawThemeSetting, G as ResolveBundleKey, ag as ResolvedDecorationItem, ak as ResolvedPosition, a6 as ShikiTransformerContext, a5 as ShikiTransformerContextMeta, a7 as ShikijiTransformer, a8 as ShikijiTransformerContext, a9 as ShikijiTransformerContextCommon, D as SpecialLanguage, ad as StringLiteralUnion, _ as ThemeRegistration, Z as ThemeRegistrationRaw, a2 as ThemedTokenExplanation, a1 as ThemedTokenScopeExplanation, a3 as TokenBase, a4 as TransformerOptions } from './chunk-tokens.mjs';
+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 { L as LoadWasmOptions } from './chunk-index.mjs';
 export { l as loadWasm } from './chunk-index.mjs';
 
-type HighlighterCore = HighlighterGeneric<never, never>;
 /**
  * Create a Shiki core highlighter instance, with no languages or themes bundled.
  * Wasm and each language and theme must be loaded manually.
@@ -29,45 +28,41 @@ interface ShorthandsBundle<L extends string, T extends string> {
      *
      * Differences from `highlighter.codeToHtml()`, this function is async.
      */
-    codeToHtml(code: string, options: CodeToHastOptions<L, T>): Promise<string>;
+    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>;
+    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>;
+    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[][]>;
+    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[][]>;
+    codeToTokensWithThemes: (code: string, options: RequireKeys<CodeToTokensWithThemesOptions<L, T>, 'themes' | 'lang'>) => Promise<ThemedTokenWithVariants[][]>;
     /**
      * Get internal singleton highlighter.
      *
      * @internal
      */
-    getSingletonHighlighter(): Promise<HighlighterGeneric<L, T>>;
-    /**
-     * @deprecated Use `codeToTokensBase` instead.
-     */
-    codeToThemedTokens(code: string, options: RequireKeys<CodeToTokensBaseOptions<L, T>, 'theme' | 'lang'>): Promise<ThemedToken[][]>;
+    getSingletonHighlighter: () => Promise<HighlighterGeneric<L, T>>;
 }
 declare function createSingletonShorthands<L extends string, T extends string>(getHighlighter: GetHighlighterFactory<L, T>): ShorthandsBundle<L, T>;
 
@@ -75,19 +70,19 @@ declare function toArray<T>(x: MaybeArray<T>): T[];
 /**
  * Slipt a string into lines, each line preserves the line ending.
  */
-declare function splitLines(str: string): [code: string, offset: number][];
+declare function splitLines(code: string, preserveEnding?: boolean): [string, number][];
 /**
  * Check if the language is plaintext that is ignored by Shiki.
  *
  * Hard-coded plain text languages: `plaintext`, `txt`, `text`, `plain`.
  */
-declare function isPlainLang(lang: string | null | undefined): boolean;
+declare function isPlainLang(lang: string | null | undefined): lang is PlainTextLanguage;
 /**
  * Check if the language is specially handled or bypassed by Shiki.
  *
  * Hard-coded languages: `ansi` and plaintexts like `plaintext`, `txt`, `text`, `plain`.
  */
-declare function isSpecialLang(lang: string): boolean;
+declare function isSpecialLang(lang: any): lang is SpecialLanguage;
 /**
  * Check if the theme is specially handled or bypassed by Shiki.
  *
@@ -117,10 +112,6 @@ 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;
-/**
- * @deprecated Use `isPlainLang` instead.
- */
-declare const isPlaintext: typeof isPlainLang;
 declare function getTokenStyleObject(token: TokenStyles): Record<string, string>;
 declare function stringifyTokenStyle(token: Record<string, string>): string;
 /**
@@ -406,4 +397,4 @@ declare class ShikiError extends Error {
     constructor(message: string);
 }
 
-export { BundledHighlighterOptions, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, type GetHighlighterFactory, IGrammar as Grammar, type HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, IGrammar, LanguageInput, MaybeArray, Position, RequireKeys, ShikiError, ShikiInternal, ShikiTransformer, ShikiTransformerContextCommon, ShikiTransformerContextSource, type ShorthandsBundle, 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, isPlaintext, isSpecialLang, isSpecialTheme, normalizeTheme, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+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, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };

package/dist/index.mjs

@@ -7,8 +7,19 @@ function toArray(x) {
 /**
  * Slipt a string into lines, each line preserves the line ending.
  */
-function splitLines(str) {
-    return Array.from(str.matchAll(/^.*$/mg)).map(x => [x[0], x.index]);
+function splitLines(code, preserveEnding = false) {
+    const parts = code.split(/(\r?\n)/g);
+    let index = 0;
+    const lines = [];
+    for (let i = 0; i < parts.length; i += 2) {
+        const line = preserveEnding
+            ? parts[i] + (parts[i + 1] || '')
+            : parts[i];
+        lines.push([line, index]);
+        index += parts[i].length;
+        index += parts[i + 1]?.length || 0;
+    }
+    return lines;
 }
 /**
  * Check if the language is plaintext that is ignored by Shiki.
@@ -113,10 +124,6 @@ function splitTokens(tokens, breakpoints) {
 function applyColorReplacements(color, replacements) {
     return replacements?.[color.toLowerCase()] || color;
 }
-/**
- * @deprecated Use `isPlainLang` instead.
- */
-const isPlaintext = isPlainLang;
 function getTokenStyleObject(token) {
     const styles = {};
     if (token.color)
@@ -140,7 +147,7 @@ function stringifyTokenStyle(token) {
  * Creates a converter between index and position in a code block.
  */
 function createPositionConverter(code) {
-    const lines = Array.from(code.matchAll(/.*?($|\n)/g)).map(match => match[0]);
+    const lines = splitLines(code, true).map(([line]) => line);
     function indexToPos(index) {
         let character = index;
         let line = 0;
@@ -509,7 +516,7 @@ function codeToTokensBase(internal, code, options = {}) {
     const { theme, colorMap } = internal.setTheme(themeName);
     if (lang === 'ansi')
         return tokenizeAnsiWithTheme(theme, code, options);
-    const _grammar = internal.getLangGrammar(lang);
+    const _grammar = internal.getLanguage(lang);
     return tokenizeWithTheme(code, _grammar, theme, colorMap, options);
 }
 function tokenizeWithTheme(code, grammar, theme, colorMap, options) {
@@ -871,8 +878,8 @@ function transformerDecorations() {
                 return;
             const ctx = getContext(this);
             const lines = Array.from(codeEl.children).filter(i => i.type === 'element' && i.tagName === 'span');
-            // if (lines.length !== ctx.converter.lines.length)
-            //   throw new ShikiError(`Number of lines in code element (${lines.length}) does not match the number of lines in the source (${ctx.converter.lines.length}). Failed to apply decorations.`)
+            if (lines.length !== ctx.converter.lines.length)
+                throw new ShikiError(`Number of lines in code element (${lines.length}) does not match the number of lines in the source (${ctx.converter.lines.length}). Failed to apply decorations.`);
             function applyLineSection(line, start, end, decoration) {
                 const lineEl = lines[line];
                 let text = '';
@@ -1075,7 +1082,7 @@ function tokensToHast(tokens, options, transformerContext) {
             if (style)
                 tokenNode.properties.style = style;
             for (const transformer of transformers)
-                tokenNode = (transformer?.span || transformer?.token)?.call(context, tokenNode, idx + 1, col, lineNode) || tokenNode;
+                tokenNode = transformer?.span?.call(context, tokenNode, idx + 1, col, lineNode) || tokenNode;
             lineNode.children.push(tokenNode);
             col += token.content.length;
         }
@@ -5249,7 +5256,9 @@ async function getShikiInternal(options = {}) {
         return Promise.resolve(typeof p === 'function' ? p() : p).then(r => r.default || r);
     }
     async function resolveLangs(langs) {
-        return Array.from(new Set((await Promise.all(langs.map(async (lang) => await normalizeGetter(lang).then(r => Array.isArray(r) ? r : [r])))).flat()));
+        return Array.from(new Set((await Promise.all(langs
+            .filter(l => !isSpecialLang(l))
+            .map(async (lang) => await normalizeGetter(lang).then(r => Array.isArray(r) ? r : [r])))).flat()));
     }
     const wasmLoader = options.loadWasm || _defaultWasmLoader;
     const [themes, langs,] = await Promise.all([
@@ -5269,8 +5278,8 @@ async function getShikiInternal(options = {}) {
     Object.assign(_registry.alias, options.langAlias);
     await _registry.init();
     let _lastTheme;
-    function getLangGrammar(name) {
-        const _lang = _registry.getGrammar(name);
+    function getLanguage(name) {
+        const _lang = _registry.getGrammar(typeof name === 'string' ? name : name.name);
         if (!_lang)
             throw new ShikiError(`Language \`${name}\` not found, you may need to load it first`);
         return _lang;
@@ -5309,20 +5318,12 @@ async function getShikiInternal(options = {}) {
             ? null
             : _registry.loadTheme(await normalizeGetter(theme))));
     }
-    function updateAlias(alias) {
-        Object.assign(_registry.alias, alias);
-    }
-    function getAlias() {
-        return _registry.alias;
-    }
     return {
         setTheme,
         getTheme,
-        getLangGrammar,
+        getLanguage,
         getLoadedThemes,
         getLoadedLanguages,
-        getAlias,
-        updateAlias,
         loadLanguage,
         loadTheme,
     };
@@ -5342,16 +5343,8 @@ async function getHighlighterCore(options = {}) {
         codeToTokens: (code, options) => codeToTokens(internal, code, options),
         codeToHast: (code, options) => codeToHast(internal, code, options),
         codeToHtml: (code, options) => codeToHtml(internal, code, options),
-        loadLanguage: internal.loadLanguage,
-        loadTheme: internal.loadTheme,
-        getTheme: internal.getTheme,
-        getLangGrammar: internal.getLangGrammar,
-        setTheme: internal.setTheme,
-        getLoadedThemes: internal.getLoadedThemes,
-        getLoadedLanguages: internal.getLoadedLanguages,
+        ...internal,
         getInternalContext: () => internal,
-        /** @deprecated */
-        codeToThemedTokens: (code, options) => codeToTokensBase(internal, code, options),
     };
 }
 
@@ -5453,13 +5446,6 @@ function createSingletonShorthands(getHighlighter) {
             const shiki = await _getHighlighter(options);
             return shiki.codeToTokensBase(code, options);
         },
-        /**
-         * @deprecated Use `codeToTokensBase` instead.
-         */
-        async codeToThemedTokens(code, options) {
-            const shiki = await _getHighlighter(options);
-            return shiki.codeToThemedTokens(code, options);
-        },
         async codeToTokensWithThemes(code, options) {
             const shiki = await _getHighlighter({
                 lang: options.lang,
@@ -5470,4 +5456,4 @@ function createSingletonShorthands(getHighlighter) {
     };
 }
 
-export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createPositionConverter, createSingletonShorthands, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isPlaintext, isSpecialLang, isSpecialTheme, loadWasm, normalizeTheme, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+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, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };

package/dist/types.d.mts

@@ -1,94 +1,88 @@
-import { x as ThemeRegistrationAny, r as ThemeRegistrationResolved, c as IGrammar, L as LanguageInput, T as ThemeInput, 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, p as SpecialTheme, D as SpecialLanguage, J as LanguageRegistration } from './chunk-tokens.mjs';
-export { A as AnsiLanguage, aa 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, u as CodeToHastRenderOptions, Y as CodeToHastRenderOptionsCommon, af as DecorationItem, ae as DecorationOptions, ah as DecorationTransformType, O as DynamicImportLanguageRegistration, $ as DynamicImportThemeRegistration, F as FontStyle, H as HighlighterCoreOptions, b as IRawGrammar, M as MaybeArray, ab as MaybeGetter, ac as MaybeModule, ai as Offset, aj as OffsetOrPosition, z as PlainTextLanguage, P as Position, b as RawGrammar, a as RawTheme, g as RawThemeSetting, k as RequireKeys, ag as ResolvedDecorationItem, ak as ResolvedPosition, y as ShikiTransformer, a6 as ShikiTransformerContext, t as ShikiTransformerContextCommon, a5 as ShikiTransformerContextMeta, v as ShikiTransformerContextSource, a7 as ShikijiTransformer, a8 as ShikijiTransformerContext, a9 as ShikijiTransformerContextCommon, ad as StringLiteralUnion, _ as ThemeRegistration, Z as ThemeRegistrationRaw, a2 as ThemedTokenExplanation, a1 as ThemedTokenScopeExplanation, a3 as TokenBase, q as TokenStyles, s as TokenizeWithThemeOptions, a4 as TransformerOptions } from './chunk-tokens.mjs';
+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 './chunk-index.mjs';
 
-interface ShikiInternal {
-    setTheme(name: string | ThemeRegistrationAny): {
-        theme: ThemeRegistrationResolved;
-        colorMap: string[];
-    };
-    getTheme(name: string | ThemeRegistrationAny): ThemeRegistrationResolved;
-    getLangGrammar(name: string): IGrammar;
-    getLoadedThemes(): string[];
-    getLoadedLanguages(): string[];
-    loadLanguage(...langs: LanguageInput[]): Promise<void>;
-    loadTheme(...themes: ThemeInput[]): Promise<void>;
-    getAlias(): Record<string, string>;
-    updateAlias(alias: Record<string, string>): void;
-}
 /**
- * Generic instance interface of Shiki
+ * Internal context of Shiki, core textmate logic
  */
-interface HighlighterGeneric<BundledLangKeys extends string, BundledThemeKeys extends string> {
-    /**
-     * Get highlighted code in HTML string
-     */
-    codeToHtml(code: string, options: CodeToHastOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>): string;
-    /**
-     * Get highlighted code in HAST.
-     * @see https://github.com/syntax-tree/hast
-     */
-    codeToHast(code: string, options: CodeToHastOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>): Root;
-    /**
-     * Get highlighted code in tokens. Uses `codeToTokensWithThemes` or `codeToTokensBase` based on the options.
-     */
-    codeToTokens(code: string, options: CodeToTokensOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>): TokensResult;
-    /**
-     * Get highlighted code in tokens with a single theme.
-     * @returns A 2D array of tokens, first dimension is lines, second dimension is tokens in a line.
-     */
-    codeToTokensBase(code: string, options: CodeToTokensBaseOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>): ThemedToken[][];
-    /**
-     * Get highlighted code in tokens with multiple themes.
-     *
-     * Different from `codeToTokensBase`, each token will have a `variants` property consisting of an object of color name to token styles.
-     *
-     * @returns A 2D array of tokens, first dimension is lines, second dimension is tokens in a line.
-     */
-    codeToTokensWithThemes(code: string, options: CodeToTokensWithThemesOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>): ThemedTokenWithVariants[][];
-    /**
-     * @deprecated Renamed to `codeToTokensBase`, or use high-level `codeToTokens` directly.
-     */
-    codeToThemedTokens(code: string, options: CodeToTokensBaseOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>): ThemedToken[][];
+interface ShikiInternal<BundledLangKeys extends string = never, BundledThemeKeys extends string = never> {
     /**
      * Load a theme to the highlighter, so later it can be used synchronously.
      */
-    loadTheme(...themes: (ThemeInput | BundledThemeKeys | SpecialTheme)[]): Promise<void>;
+    loadTheme: (...themes: (ThemeInput | BundledThemeKeys | SpecialTheme)[]) => Promise<void>;
     /**
      * Load a language to the highlighter, so later it can be used synchronously.
      */
-    loadLanguage(...langs: (LanguageInput | BundledLangKeys | SpecialLanguage)[]): Promise<void>;
+    loadLanguage: (...langs: (LanguageInput | BundledLangKeys | SpecialLanguage)[]) => Promise<void>;
     /**
      * Get the registered theme object
      */
-    getTheme(name: string | ThemeRegistrationAny): ThemeRegistrationResolved;
+    getTheme: (name: string | ThemeRegistrationAny) => ThemeRegistrationResolved;
     /**
      * Get the registered language object
      */
-    getLangGrammar(name: string | LanguageRegistration): IGrammar;
+    getLanguage: (name: string | LanguageRegistration) => IGrammar;
     /**
      * Set the current theme and get the resolved theme object and color map.
      * @internal
      */
-    setTheme: ShikiInternal['setTheme'];
+    setTheme: (themeName: string | ThemeRegistrationAny) => {
+        theme: ThemeRegistrationResolved;
+        colorMap: string[];
+    };
     /**
      * Get the names of loaded languages
      *
      * Special-handled languages like `text`, `plain` and `ansi` are not included.
      */
-    getLoadedLanguages(): string[];
+    getLoadedLanguages: () => string[];
     /**
      * Get the names of loaded themes
      *
      * Special-handled themes like `none` are not included.
      */
-    getLoadedThemes(): string[];
+    getLoadedThemes: () => string[];
+}
+/**
+ * Generic instance interface of Shiki
+ */
+interface HighlighterGeneric<BundledLangKeys extends string, BundledThemeKeys extends string> extends ShikiInternal<BundledLangKeys, BundledThemeKeys> {
+    /**
+     * Get highlighted code in HTML string
+     */
+    codeToHtml: (code: string, options: CodeToHastOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>) => string;
+    /**
+     * Get highlighted code in HAST.
+     * @see https://github.com/syntax-tree/hast
+     */
+    codeToHast: (code: string, options: CodeToHastOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>) => Root;
+    /**
+     * Get highlighted code in tokens. Uses `codeToTokensWithThemes` or `codeToTokensBase` based on the options.
+     */
+    codeToTokens: (code: string, options: CodeToTokensOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>) => TokensResult;
+    /**
+     * Get highlighted code in tokens with a single theme.
+     * @returns A 2D array of tokens, first dimension is lines, second dimension is tokens in a line.
+     */
+    codeToTokensBase: (code: string, options: CodeToTokensBaseOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>) => ThemedToken[][];
+    /**
+     * Get highlighted code in tokens with multiple themes.
+     *
+     * Different from `codeToTokensBase`, each token will have a `variants` property consisting of an object of color name to token styles.
+     *
+     * @returns A 2D array of tokens, first dimension is lines, second dimension is tokens in a line.
+     */
+    codeToTokensWithThemes: (code: string, options: CodeToTokensWithThemesOptions<ResolveBundleKey<BundledLangKeys>, ResolveBundleKey<BundledThemeKeys>>) => ThemedTokenWithVariants[][];
     /**
      * Get internal context object
      * @internal
      * @deprecated
      */
-    getInternalContext(): ShikiInternal;
+    getInternalContext: () => ShikiInternal;
 }
+/**
+ * The fine-grained core Shiki highlighter instance.
+ */
+type HighlighterCore = HighlighterGeneric<never, never>;
 
-export { CodeToHastOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, IGrammar as Grammar, type HighlighterGeneric, IGrammar, LanguageInput, LanguageRegistration, ResolveBundleKey, type ShikiInternal, SpecialLanguage, SpecialTheme, ThemeInput, ThemeRegistrationAny, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokensResult };
+export { CodeToHastOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, IGrammar as Grammar, type HighlighterCore, type HighlighterGeneric, LanguageInput, LanguageRegistration, ResolveBundleKey, type ShikiInternal, SpecialLanguage, SpecialTheme, ThemeInput, ThemeRegistrationAny, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokensResult };

package/package.json

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