@shikijs/core 1.15.2 → 1.16.0

package/dist/chunk-engines.d.mts

@@ -1,4 +1,226 @@
+interface IOnigCaptureIndex {
+    start: number;
+    end: number;
+    length: number;
+}
+interface IOnigMatch {
+    index: number;
+    captureIndices: IOnigCaptureIndex[];
+}
+declare const enum FindOption {
+    None = 0,
+    /**
+     * equivalent of ONIG_OPTION_NOT_BEGIN_STRING: (str) isn't considered as begin of string (* fail \A)
+     */
+    NotBeginString = 1,
+    /**
+     * equivalent of ONIG_OPTION_NOT_END_STRING: (end) isn't considered as end of string (* fail \z, \Z)
+     */
+    NotEndString = 2,
+    /**
+     * equivalent of ONIG_OPTION_NOT_BEGIN_POSITION: (start) isn't considered as start position of search (* fail \G)
+     */
+    NotBeginPosition = 4,
+    /**
+     * used for debugging purposes.
+     */
+    DebugCall = 8
+}
+interface OnigScanner {
+    findNextMatchSync(string: string | OnigString, startPosition: number, options: OrMask<FindOption>): IOnigMatch | null;
+    dispose?(): void;
+}
+interface OnigString {
+    readonly content: string;
+    dispose?(): void;
+}
+
+/**
+ * A union of given const enum values.
+*/
+type OrMask<T extends number> = number;
+/**
+ * Identifiers with a binary dot operator.
+ * Examples: `baz` or `foo.bar`
+*/
+type ScopeName = string;
+/**
+ * An expression language of ScopePathStr with a binary comma (to indicate alternatives) operator.
+ * Examples: `foo.bar boo.baz,quick quack`
+*/
+type ScopePattern = string;
+/**
+ * A TextMate theme.
+ */
+interface IRawTheme {
+    readonly name?: string;
+    readonly settings: IRawThemeSetting[];
+}
+/**
+ * A single theme setting.
+ */
+interface IRawThemeSetting {
+    readonly name?: string;
+    readonly scope?: ScopePattern | ScopePattern[];
+    readonly settings: {
+        readonly fontStyle?: string;
+        readonly foreground?: string;
+        readonly background?: string;
+    };
+}
+
+declare const ruleIdSymbol: unique symbol;
+type RuleId = {
+    __brand: typeof ruleIdSymbol;
+};
+
+interface IRawGrammar extends ILocatable {
+    repository: IRawRepository;
+    readonly scopeName: ScopeName;
+    readonly patterns: IRawRule[];
+    readonly injections?: {
+        [expression: string]: IRawRule;
+    };
+    readonly injectionSelector?: string;
+    readonly fileTypes?: string[];
+    readonly name?: string;
+    readonly firstLineMatch?: string;
+}
+/**
+ * Allowed values:
+ * * Scope Name, e.g. `source.ts`
+ * * Top level scope reference, e.g. `source.ts#entity.name.class`
+ * * Relative scope reference, e.g. `#entity.name.class`
+ * * self, e.g. `$self`
+ * * base, e.g. `$base`
+ */
+type IncludeString = string;
+type RegExpString = string;
+interface IRawRepositoryMap {
+    [name: string]: IRawRule;
+    $self: IRawRule;
+    $base: IRawRule;
+}
+type IRawRepository = IRawRepositoryMap & ILocatable;
+interface IRawRule extends ILocatable {
+    id?: RuleId;
+    readonly include?: IncludeString;
+    readonly name?: ScopeName;
+    readonly contentName?: ScopeName;
+    readonly match?: RegExpString;
+    readonly captures?: IRawCaptures;
+    readonly begin?: RegExpString;
+    readonly beginCaptures?: IRawCaptures;
+    readonly end?: RegExpString;
+    readonly endCaptures?: IRawCaptures;
+    readonly while?: RegExpString;
+    readonly whileCaptures?: IRawCaptures;
+    readonly patterns?: IRawRule[];
+    readonly repository?: IRawRepository;
+    readonly applyEndPatternLast?: boolean;
+}
+type IRawCaptures = IRawCapturesMap & ILocatable;
+interface IRawCapturesMap {
+    [captureId: string]: IRawRule;
+}
+interface ILocation {
+    readonly filename: string;
+    readonly line: number;
+    readonly char: number;
+}
+interface ILocatable {
+    readonly $vscodeTextmateLocation?: ILocation;
+}
+/**
+ * A grammar
+ */
+interface IGrammar {
+    /**
+     * Tokenize `lineText` using previous line state `prevState`.
+     */
+    tokenizeLine(lineText: string, prevState: StateStack | null, timeLimit?: number): ITokenizeLineResult;
+    /**
+     * Tokenize `lineText` using previous line state `prevState`.
+     * The result contains the tokens in binary format, resolved with the following information:
+     *  - language
+     *  - token type (regex, string, comment, other)
+     *  - font style
+     *  - foreground color
+     *  - background color
+     * e.g. for getting the languageId: `(metadata & MetadataConsts.LANGUAGEID_MASK) >>> MetadataConsts.LANGUAGEID_OFFSET`
+     */
+    tokenizeLine2(lineText: string, prevState: StateStack | null, timeLimit?: number): ITokenizeLineResult2;
+}
+interface ITokenizeLineResult {
+    readonly tokens: IToken[];
+    /**
+     * The `prevState` to be passed on to the next line tokenization.
+     */
+    readonly ruleStack: StateStack;
+    /**
+     * Did tokenization stop early due to reaching the time limit.
+     */
+    readonly stoppedEarly: boolean;
+}
+interface ITokenizeLineResult2 {
+    /**
+     * The tokens in binary format. Each token occupies two array indices. For token i:
+     *  - at offset 2*i => startIndex
+     *  - at offset 2*i + 1 => metadata
+     *
+     */
+    readonly tokens: Uint32Array;
+    /**
+     * The `prevState` to be passed on to the next line tokenization.
+     */
+    readonly ruleStack: StateStack;
+    /**
+     * Did tokenization stop early due to reaching the time limit.
+     */
+    readonly stoppedEarly: boolean;
+}
+interface IToken {
+    startIndex: number;
+    readonly endIndex: number;
+    readonly scopes: string[];
+}
+/**
+ * **IMPORTANT** - Immutable!
+ */
+interface StateStack {
+    _stackElementBrand: void;
+    readonly depth: number;
+    clone(): StateStack;
+    equals(other: StateStack): boolean;
+}
+
 type Awaitable<T> = T | Promise<T>;
+type MaybeGetter<T> = Awaitable<MaybeModule<T>> | (() => Awaitable<MaybeModule<T>>);
+type MaybeModule<T> = T | {
+    default: T;
+};
+type MaybeArray<T> = T | T[];
+type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+interface Nothing {
+}
+/**
+ * type StringLiteralUnion<'foo'> = 'foo' | string
+ * This has auto completion whereas `'foo' | string` doesn't
+ * Adapted from https://github.com/microsoft/TypeScript/issues/29729
+ */
+type StringLiteralUnion<T extends U, U = string> = T | (U & Nothing);
+
+interface PatternScanner extends OnigScanner {
+}
+interface RegexEngineString extends OnigString {
+}
+/**
+ * Engine for RegExp matching and scanning.
+ */
+interface RegexEngine {
+    createScanner: (patterns: string[]) => PatternScanner;
+    createString: (s: string) => RegexEngineString;
+}
 interface WebAssemblyInstantiator {
     (importObject: Record<string, Record<string, WebAssembly.ImportValue>> | undefined): Promise<WebAssemblyInstance>;
 }
@@ -23,4 +245,4 @@ interface JavaScriptRegexEngineOptions {
     cache?: Map<string, RegExp | Error>;
 }
 
-export type { JavaScriptRegexEngineOptions as J, LoadWasmOptions as L, WebAssemblyInstantiator as W, WebAssemblyInstance as a };
+export type { Awaitable as A, IGrammar as I, JavaScriptRegexEngineOptions as J, LoadWasmOptions as L, MaybeArray as M, OnigurumaLoadOptions as O, PatternScanner as P, RequireKeys as R, StringLiteralUnion as S, WebAssemblyInstantiator as W, RegexEngine as a, MaybeGetter as b, IRawGrammar as c, IRawTheme as d, IRawThemeSetting as e, MaybeModule as f, RegexEngineString as g, WebAssemblyInstance as h, LoadWasmOptionsPlain as i, StateStack as j };

package/dist/index.d.mts

@@ -1,18 +1,25 @@
-import { HighlighterCore, HighlighterGeneric, ShikiInternal } from './types.mjs';
-export { Grammar } from './types.mjs';
-import { H as HighlighterCoreOptions, B as BundledHighlighterOptions, L as LanguageInput, T as ThemeInput, C as CodeToHastOptions, a as CodeToTokensOptions, b as TokensResult, R as RequireKeys, c as CodeToTokensBaseOptions, d as ThemedToken, e as CodeToTokensWithThemesOptions, f as ThemedTokenWithVariants, G as GrammarState, M as MaybeArray, P as PlainTextLanguage, S as SpecialLanguage, g as SpecialTheme, h as ThemeRegistrationAny, i as TokenizeWithThemeOptions, j as TokenStyles, k as Position, l as RegexEngine, I as IGrammar, m as ThemeRegistrationResolved, n as ShikiTransformerContextCommon, o as CodeToHastRenderOptions, p as ShikiTransformerContextSource, q as ShikiTransformer } from './chunk-tokens.mjs';
-export { A as AnsiLanguage, $ as Awaitable, t as BundledLanguageInfo, Q as BundledThemeInfo, y as CodeOptionsMeta, v as CodeOptionsMultipleThemes, u as CodeOptionsSingleTheme, w as CodeOptionsThemes, x as CodeToHastOptionsCommon, z as CodeToHastRenderOptionsCommon, a4 as DecorationItem, a3 as DecorationOptions, a6 as DecorationTransformType, D as DynamicImportLanguageRegistration, O as DynamicImportThemeRegistration, X as FontStyle, s as LanguageRegistration, a0 as MaybeGetter, a1 as MaybeModule, a7 as Offset, a8 as OffsetOrPosition, E as RawGrammar, F as RawTheme, J as RawThemeSetting, r as ResolveBundleKey, a5 as ResolvedDecorationItem, a9 as ResolvedPosition, _ as ShikiTransformerContext, Z as ShikiTransformerContextMeta, a2 as StringLiteralUnion, N as ThemeRegistration, K as ThemeRegistrationRaw, V as ThemedTokenExplanation, U as ThemedTokenScopeExplanation, W as TokenBase, Y as TransformerOptions } from './chunk-tokens.mjs';
-import { Root, Element, RootContent, Nodes } from 'hast';
-import { L as LoadWasmOptions, J as JavaScriptRegexEngineOptions } from './chunk-engines.mjs';
-export { a as WebAssemblyInstance, W as WebAssemblyInstantiator } from './chunk-engines.mjs';
+import { HighlighterCoreOptions, HighlighterCore, BundledHighlighterOptions, HighlighterGeneric, CreatedBundledHighlighterOptions, LanguageInput, ThemeInput, CodeToHastOptions, CodeToTokensOptions, TokensResult, CodeToTokensBaseOptions, ThemedToken, CodeToTokensWithThemesOptions, ThemedTokenWithVariants, GrammarState, ShikiInternal, FontStyle, ThemeRegistrationAny, ThemeRegistrationResolved, TokenizeWithThemeOptions, ShikiTransformerContextCommon, CodeToHastRenderOptions, ShikiTransformerContextSource, PlainTextLanguage, SpecialLanguage, SpecialTheme, TokenStyles, Position, ShikiTransformer } from './types.mjs';
+export { AnsiLanguage, BundledLanguageInfo, BundledThemeInfo, CodeOptionsMeta, CodeOptionsMultipleThemes, CodeOptionsSingleTheme, CodeOptionsThemes, CodeToHastOptionsCommon, CodeToHastRenderOptionsCommon, DecorationItem, DecorationOptions, DecorationTransformType, DynamicImportLanguageRegistration, DynamicImportThemeRegistration, Grammar, LanguageRegistration, Offset, OffsetOrPosition, ResolveBundleKey, ResolvedDecorationItem, ResolvedPosition, ShikiTransformerContext, ShikiTransformerContextMeta, ThemeRegistration, ThemeRegistrationRaw, ThemedTokenExplanation, ThemedTokenScopeExplanation, TokenBase, TransformerOptions } from './types.mjs';
+import { R as RequireKeys, L as LoadWasmOptions, a as RegexEngine, J as JavaScriptRegexEngineOptions, I as IGrammar, M as MaybeArray, b as MaybeGetter } from './chunk-engines.mjs';
+export { A as Awaitable, i as LoadWasmOptionsPlain, f as MaybeModule, O as OnigurumaLoadOptions, P as PatternScanner, c as RawGrammar, d as RawTheme, e as RawThemeSetting, g as RegexEngineString, S as StringLiteralUnion, h as WebAssemblyInstance, W as WebAssemblyInstantiator } from './chunk-engines.mjs';
+import { Root, RootContent, Nodes, Element } from 'hast';
 
 /**
  * Create a Shiki core highlighter instance, with no languages or themes bundled.
  * Wasm and each language and theme must be loaded manually.
  *
- * @see http://shiki.style/guide/install#fine-grained-bundle
+ * @see http://shiki.style/guide/bundles#fine-grained-bundle
  */
 declare function createHighlighterCore(options?: HighlighterCoreOptions): Promise<HighlighterCore>;
+/**
+ * Create a Shiki core highlighter instance, with no languages or themes bundled.
+ * Wasm and each language and theme must be loaded manually.
+ *
+ * Synchronous version of `createHighlighterCore`, which requires to provide the engine and all themes and languages upfront.
+ *
+ * @see http://shiki.style/guide/bundles#fine-grained-bundle
+ */
+declare function createHighlighterCoreSync(options?: HighlighterCoreOptions<true>): HighlighterCore;
 declare function makeSingletonHighlighterCore(createHighlighter: typeof createHighlighterCore): (options?: Partial<HighlighterCoreOptions>) => Promise<HighlighterCore>;
 declare const getSingletonHighlighterCore: (options?: Partial<HighlighterCoreOptions>) => Promise<HighlighterCore>;
 /**
@@ -21,12 +28,31 @@ declare const getSingletonHighlighterCore: (options?: Partial<HighlighterCoreOpt
 declare function getHighlighterCore(options?: HighlighterCoreOptions): Promise<HighlighterCore>;
 
 type CreateHighlighterFactory<L extends string, T extends string> = (options: BundledHighlighterOptions<L, T>) => Promise<HighlighterGeneric<L, T>>;
+/**
+ * Create a `createHighlighter` function with bundled themes, languages, and engine.
+ *
+ * @example
+ * ```ts
+ * const createHighlighter = createdBundledHighlighter({
+ *   langs: {
+ *     typescript: () => import('shiki/langs/typescript.mjs'),
+ *     // ...
+ *   },
+ *   themes: {
+ *     nord: () => import('shiki/themes/nord.mjs'),
+ *     // ...
+ *   },
+ *   engine: () => createWasmOnigEngine(), // or createJavaScriptRegexEngine()
+ * })
+ * ```
+ *
+ * @param options
+ */
+declare function createdBundledHighlighter<BundledLangs extends string, BundledThemes extends string>(options: CreatedBundledHighlighterOptions<BundledLangs, BundledThemes>): CreateHighlighterFactory<BundledLangs, BundledThemes>;
 /**
  * Create a `createHighlighter` function with bundled themes and languages.
  *
- * @param bundledLanguages
- * @param bundledThemes
- * @param loadWasm
+ * @deprecated Use `createdBundledHighlighter({ langs, themes, engine })` signature instead.
  */
 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> {
@@ -78,68 +104,26 @@ interface ShorthandsBundle<L extends string, T extends string> {
 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[];
-/**
- * Split a string into lines, each line preserves the line ending.
- */
-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): 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: any): lang is SpecialLanguage;
-/**
- * Check if the theme is specially handled or bypassed by Shiki.
- *
- * Hard-coded themes: `none`.
- */
-declare function isNoneTheme(theme: string | ThemeInput | null | undefined): theme is 'none';
-/**
- * Check if the theme is specially handled or bypassed by Shiki.
- *
- * Hard-coded themes: `none`.
- */
-declare function isSpecialTheme(theme: string | ThemeInput | null | undefined): theme is SpecialTheme;
 /**
- * Utility to append class to a hast node
+ * Get the minimal shiki context for rendering.
  *
- * If the `property.class` is a string, it will be splitted by space and converted to an array.
+ * Synchronous version of `createShikiInternal`, which requires to provide the engine and all themes and languages upfront.
  */
-declare function addClassToHast(node: Element, className: string | string[]): Element;
+declare function createShikiInternalSync(options: HighlighterCoreOptions<true>): ShikiInternal;
+
 /**
- * Split a token into multiple tokens by given offsets.
- *
- * The offsets are relative to the token, and should be sorted.
+ * Set the default wasm loader for `loadWasm`.
+ * @internal
  */
-declare function splitToken<T extends Pick<ThemedToken, 'content' | 'offset'>>(token: T, offsets: number[]): T[];
+declare function setDefaultWasmLoader(_loader: LoadWasmOptions): void;
 /**
- * Split 2D tokens array by given breakpoints.
+ * Get the minimal shiki context for rendering.
  */
-declare function splitTokens<T extends Pick<ThemedToken, 'content' | 'offset'>>(tokens: T[][], breakpoints: number[] | Set<number>): T[][];
-declare function resolveColorReplacements(theme: ThemeRegistrationAny | string, options?: TokenizeWithThemeOptions): {
-    [x: string]: string;
-};
-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;
+declare function createShikiInternal(options?: HighlighterCoreOptions): Promise<ShikiInternal>;
 /**
- * Creates a converter between index and position in a code block.
- *
- * Overflow/underflow are unchecked.
+ * @deprecated Use `createShikiInternal` instead.
  */
-declare function createPositionConverter(code: string): {
-    lines: string[];
-    indexToPos: (index: number) => Position;
-    posToIndex: (line: number, character: number) => number;
-};
+declare function getShikiInternal(options?: HighlighterCoreOptions): Promise<ShikiInternal>;
 
 declare function loadWasm(options: LoadWasmOptions): Promise<void>;
 
@@ -156,19 +140,28 @@ declare function createWasmOnigEngine(options?: LoadWasmOptions | null): Promise
  */
 declare function createJavaScriptRegexEngine(options?: JavaScriptRegexEngineOptions): RegexEngine;
 
+declare const enum TemporaryStandardTokenType {
+    Other = 0,
+    Comment = 1,
+    String = 2,
+    RegEx = 4,
+    MetaEmbedded = 8
+}
+declare class StackElementMetadata {
+    static toBinaryStr(metadata: number): string;
+    static getLanguageId(metadata: number): number;
+    static getTokenType(metadata: number): number;
+    static getFontStyle(metadata: number): number;
+    static getForeground(metadata: number): number;
+    static getBackground(metadata: number): number;
+    static containsBalancedBrackets(metadata: number): boolean;
+    static set(metadata: number, languageId: number, tokenType: TemporaryStandardTokenType, fontStyle: FontStyle, foreground: number, background: number): number;
+}
+
 /**
- * Set the default wasm loader for `loadWasm`.
- * @internal
- */
-declare function setDefaultWasmLoader(_loader: LoadWasmOptions): void;
-/**
- * Get the minimal shiki context for rendering.
- */
-declare function createShikiInternal(options?: HighlighterCoreOptions): Promise<ShikiInternal>;
-/**
- * @deprecated Use `createShikiInternal` instead.
+ * Normalize a textmate theme to shiki theme
  */
-declare function getShikiInternal(options?: HighlighterCoreOptions): Promise<ShikiInternal>;
+declare function normalizeTheme(rawTheme: ThemeRegistrationAny): ThemeRegistrationResolved;
 
 /**
  * Code to tokens, with a simple theme.
@@ -417,10 +410,72 @@ declare function codeToHtml(internal: ShikiInternal, code: string, options: Code
  */
 declare function codeToTokensWithThemes(internal: ShikiInternal, code: string, options: CodeToTokensWithThemesOptions): ThemedTokenWithVariants[][];
 
+declare function toArray<T>(x: MaybeArray<T>): T[];
 /**
- * Normalize a textmate theme to shiki theme
+ * Split a string into lines, each line preserves the line ending.
  */
-declare function normalizeTheme(rawTheme: ThemeRegistrationAny): ThemeRegistrationResolved;
+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): 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: any): lang is SpecialLanguage;
+/**
+ * Check if the theme is specially handled or bypassed by Shiki.
+ *
+ * Hard-coded themes: `none`.
+ */
+declare function isNoneTheme(theme: string | ThemeInput | null | undefined): theme is 'none';
+/**
+ * Check if the theme is specially handled or bypassed by Shiki.
+ *
+ * Hard-coded themes: `none`.
+ */
+declare function isSpecialTheme(theme: string | ThemeInput | null | undefined): theme is SpecialTheme;
+/**
+ * Utility to append class to a hast node
+ *
+ * If the `property.class` is a string, it will be splitted by space and converted to an array.
+ */
+declare function addClassToHast(node: Element, className: string | string[]): Element;
+/**
+ * Split a token into multiple tokens by given offsets.
+ *
+ * The offsets are relative to the token, and should be sorted.
+ */
+declare function splitToken<T extends Pick<ThemedToken, 'content' | 'offset'>>(token: T, offsets: number[]): T[];
+/**
+ * Split 2D tokens array by given breakpoints.
+ */
+declare function splitTokens<T extends Pick<ThemedToken, 'content' | 'offset'>>(tokens: T[][], breakpoints: number[] | Set<number>): T[][];
+/**
+ * Normalize a getter to a promise.
+ */
+declare function normalizeGetter<T>(p: MaybeGetter<T>): Promise<T>;
+declare function resolveColorReplacements(theme: ThemeRegistrationAny | string, options?: TokenizeWithThemeOptions): {
+    [x: string]: string;
+};
+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;
+/**
+ * Creates a converter between index and position in a code block.
+ *
+ * Overflow/underflow are unchecked.
+ */
+declare function createPositionConverter(code: string): {
+    lines: string[];
+    indexToPos: (index: number) => Position;
+    posToIndex: (line: number, character: number) => number;
+};
 
 /**
  * A built-in transformer to add decorations to the highlighted code.
@@ -431,4 +486,4 @@ declare class ShikiError extends Error {
     constructor(message: string);
 }
 
-export { BundledHighlighterOptions, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, type CreateHighlighterFactory, GrammarState, HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, LanguageInput, LoadWasmOptions, 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, createJavaScriptRegexEngine, createPositionConverter, createShikiInternal, createSingletonShorthands, createWasmOnigEngine, 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 };
+export { BundledHighlighterOptions, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, type CreateHighlighterFactory, CreatedBundledHighlighterOptions, FontStyle, GrammarState, HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, JavaScriptRegexEngineOptions, LanguageInput, LoadWasmOptions, MaybeArray, MaybeGetter, PlainTextLanguage, Position, RegexEngine, RequireKeys, ShikiError, ShikiInternal, ShikiTransformer, ShikiTransformerContextCommon, ShikiTransformerContextSource, type ShorthandsBundle, SpecialLanguage, SpecialTheme, StackElementMetadata, ThemeInput, ThemeRegistrationAny, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokenStyles, TokenizeWithThemeOptions, TokensResult, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createHighlighterCoreSync, createJavaScriptRegexEngine, createPositionConverter, createShikiInternal, createShikiInternalSync, createSingletonShorthands, createWasmOnigEngine, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };