206 lines
8.7 KiB
TypeScript
206 lines
8.7 KiB
TypeScript
import { CodeToTokensBaseOptions, CodeToTokensWithThemesOptions, Grammar, GrammarState as GrammarState$1, GrammarStateMapKey, HighlighterCoreOptions, LanguageInput, LanguageRegistration, MaybeArray, MaybeGetter, PlainTextLanguage, RegexEngine, ShikiPrimitive, SpecialLanguage, SpecialTheme, ThemeInput, ThemeRegistrationAny, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokenizeWithThemeOptions } from "@shikijs/types";
|
|
import { IOnigLib, IRawTheme, Registry as Registry$1, RegistryOptions, StateStack } from "@shikijs/vscode-textmate";
|
|
import { Root } from "hast";
|
|
export * from "@shikijs/types";
|
|
|
|
//#region src/constructors/async.d.ts
|
|
/**
|
|
* Get the minimal shiki primitive instance.
|
|
*/
|
|
declare function createShikiPrimitiveAsync(options: HighlighterCoreOptions): Promise<ShikiPrimitive>;
|
|
/**
|
|
* @deprecated Use `createShikiPrimitiveAsync` instead.
|
|
*/
|
|
declare const createShikiInternal: typeof createShikiPrimitiveAsync;
|
|
//#endregion
|
|
//#region src/constructors/primitive.d.ts
|
|
/**
|
|
* Get the minimal shiki primitive instance.
|
|
*
|
|
* Requires to provide the engine and all themes and languages upfront.
|
|
*/
|
|
declare function createShikiPrimitive(options: HighlighterCoreOptions<true>): ShikiPrimitive;
|
|
/**
|
|
* @deprecated Use `createShikiPrimitive` instead.
|
|
*/
|
|
declare const createShikiInternalSync: typeof createShikiPrimitive;
|
|
//#endregion
|
|
//#region src/highlight/code-to-tokens-base.d.ts
|
|
/**
|
|
* Code to tokens, with a simple theme.
|
|
*/
|
|
declare function codeToTokensBase(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): ThemedToken[][];
|
|
declare function getLastGrammarState(primitive: ShikiPrimitive, element: ThemedToken[][] | Root): GrammarState$1 | undefined;
|
|
declare function getLastGrammarState(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): GrammarState$1;
|
|
declare function tokenizeWithTheme(code: string, grammar: Grammar, theme: ThemeRegistrationResolved, colorMap: string[], options: TokenizeWithThemeOptions): ThemedToken[][];
|
|
//#endregion
|
|
//#region src/highlight/code-to-tokens-themes.d.ts
|
|
/**
|
|
* Get tokens with multiple themes
|
|
*/
|
|
declare function codeToTokensWithThemes(primitive: ShikiPrimitive, code: string, options: CodeToTokensWithThemesOptions, codeToTokensBaseFn?: typeof codeToTokensBase): ThemedTokenWithVariants[][];
|
|
/**
|
|
* Break tokens from multiple themes into same tokenization.
|
|
*
|
|
* For example, given two themes that tokenize `console.log("hello")` as:
|
|
*
|
|
* - `console . log (" hello ")` (6 tokens)
|
|
* - `console .log ( "hello" )` (5 tokens)
|
|
*
|
|
* This function will return:
|
|
*
|
|
* - `console . log ( " hello " )` (8 tokens)
|
|
* - `console . log ( " hello " )` (8 tokens)
|
|
*/
|
|
declare function alignThemesTokenization(...themes: ThemedToken[][][]): ThemedToken[][][];
|
|
//#endregion
|
|
//#region src/textmate/getters-resolve.d.ts
|
|
/**
|
|
* Resolve
|
|
*/
|
|
declare function resolveLangs(langs: (LanguageInput | SpecialLanguage)[]): Promise<LanguageRegistration[]>;
|
|
declare function resolveThemes(themes: (ThemeInput | SpecialTheme)[]): Promise<ThemeRegistrationResolved[]>;
|
|
//#endregion
|
|
//#region src/textmate/grammar-state.d.ts
|
|
declare function setLastGrammarStateToMap(keys: GrammarStateMapKey, state: GrammarState$1): void;
|
|
declare function getLastGrammarStateFromMap(keys: GrammarStateMapKey): GrammarState$1 | undefined;
|
|
/**
|
|
* GrammarState is a special reference object that holds the state of a grammar.
|
|
*
|
|
* It's used to highlight code snippets that are part of the target language.
|
|
*/
|
|
declare class GrammarState implements GrammarState$1 {
|
|
/**
|
|
* Theme to Stack mapping
|
|
*/
|
|
private _stacks;
|
|
readonly lang: string;
|
|
get themes(): string[];
|
|
get theme(): string;
|
|
private get _stack();
|
|
/**
|
|
* Static method to create a initial grammar state.
|
|
*/
|
|
static initial(lang: string, themes: string | string[]): GrammarState;
|
|
constructor(stack: StateStack, lang: string, theme: string);
|
|
constructor(stacksMap: Record<string, StateStack>, lang: string);
|
|
/**
|
|
* Get the internal stack object.
|
|
* @internal
|
|
*/
|
|
getInternalStack(theme?: string): StateStack | undefined;
|
|
getScopes(theme?: string): string[];
|
|
toJSON(): {
|
|
lang: string;
|
|
theme: string;
|
|
themes: string[];
|
|
scopes: string[];
|
|
};
|
|
}
|
|
declare function getGrammarStack(state: GrammarState | GrammarState$1, theme?: string): StateStack | undefined;
|
|
//#endregion
|
|
//#region src/textmate/normalize-theme.d.ts
|
|
/**
|
|
* Normalize a textmate theme to shiki theme
|
|
*/
|
|
declare function normalizeTheme(rawTheme: ThemeRegistrationAny): ThemeRegistrationResolved;
|
|
//#endregion
|
|
//#region src/textmate/resolver.d.ts
|
|
declare class Resolver implements RegistryOptions {
|
|
private readonly _langs;
|
|
private readonly _scopeToLang;
|
|
private readonly _injections;
|
|
private readonly _onigLib;
|
|
constructor(engine: RegexEngine, langs: LanguageRegistration[]);
|
|
get onigLib(): IOnigLib;
|
|
getLangRegistration(langIdOrAlias: string): LanguageRegistration;
|
|
loadGrammar(scopeName: string): any;
|
|
addLanguage(l: LanguageRegistration): void;
|
|
getInjections(scopeName: string): string[] | undefined;
|
|
}
|
|
//#endregion
|
|
//#region src/textmate/registry.d.ts
|
|
declare class Registry extends Registry$1 {
|
|
private _resolver;
|
|
private _themes;
|
|
private _langs;
|
|
private _alias;
|
|
private _resolvedThemes;
|
|
private _resolvedGrammars;
|
|
private _langMap;
|
|
private _langGraph;
|
|
private _textmateThemeCache;
|
|
private _loadedThemesCache;
|
|
private _loadedLanguagesCache;
|
|
constructor(_resolver: Resolver, _themes: ThemeRegistrationResolved[], _langs: LanguageRegistration[], _alias?: Record<string, string>);
|
|
getTheme(theme: ThemeRegistrationAny | string): ThemeRegistrationResolved | undefined;
|
|
loadTheme(theme: ThemeRegistrationAny): ThemeRegistrationResolved;
|
|
getLoadedThemes(): string[];
|
|
setTheme(theme: IRawTheme): void;
|
|
getGrammar(name: string): Grammar | undefined;
|
|
loadLanguage(lang: LanguageRegistration): void;
|
|
dispose(): void;
|
|
loadLanguages(langs: LanguageRegistration[]): void;
|
|
getLoadedLanguages(): string[];
|
|
private resolveEmbeddedLanguages;
|
|
}
|
|
//#endregion
|
|
//#region src/utils/colors.d.ts
|
|
declare function resolveColorReplacements(theme: ThemeRegistrationAny | string, options?: TokenizeWithThemeOptions): Record<string, string | undefined>;
|
|
declare function applyColorReplacements(color: string, replacements?: Record<string, string | undefined>): string;
|
|
declare function applyColorReplacements(color?: string | undefined, replacements?: Record<string, string | undefined>): string | undefined;
|
|
//#endregion
|
|
//#region src/utils/general.d.ts
|
|
declare function toArray<T>(x: MaybeArray<T>): T[];
|
|
/**
|
|
* Normalize a getter to a promise.
|
|
*/
|
|
declare function normalizeGetter<T>(p: MaybeGetter<T>): Promise<T>;
|
|
/**
|
|
* 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;
|
|
//#endregion
|
|
//#region src/utils/strings.d.ts
|
|
/**
|
|
* Split a string into lines, each line preserves the line ending.
|
|
*
|
|
* @param code - The code string to split into lines
|
|
* @param preserveEnding - Whether to preserve line endings in the result
|
|
* @returns Array of tuples containing [line content, offset index]
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* splitLines('hello\nworld', false)
|
|
* // => [['hello', 0], ['world', 6]]
|
|
*
|
|
* splitLines('hello\nworld', true)
|
|
* // => [['hello\n', 0], ['world', 6]]
|
|
* ```
|
|
*/
|
|
declare function splitLines(code: string, preserveEnding?: boolean): [string, number][];
|
|
//#endregion
|
|
//#region src/utils/alias.d.ts
|
|
declare function resolveLangAlias(name: string, alias?: Record<string, string>): string;
|
|
//#endregion
|
|
export { GrammarState, Registry, Resolver, alignThemesTokenization, applyColorReplacements, codeToTokensBase, codeToTokensWithThemes, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, getGrammarStack, getLastGrammarState, getLastGrammarStateFromMap, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, resolveLangAlias, resolveLangs, resolveThemes, setLastGrammarStateToMap, splitLines, toArray, tokenizeWithTheme }; |