Files
site/node_modules/@shikijs/vscode-textmate/dist/index.d.ts
T
site-admin 3ac81d5a52
deploy / build-and-publish (push) Successful in 1m37s
the editable site (validation-lab)
2026-11-21 08:03:55 +01:00

713 lines
26 KiB
TypeScript

declare const ruleIdSymbol: unique symbol;
type RuleId = {
__brand: typeof ruleIdSymbol;
};
declare const endRuleId = -1;
interface IRuleRegistry {
getRule(ruleId: RuleId): Rule;
registerRule<T extends Rule>(factory: (id: RuleId) => T): T;
}
interface IGrammarRegistry {
getExternalGrammar(scopeName: string, repository: IRawRepository): IRawGrammar | null | undefined;
}
interface IRuleFactoryHelper extends IRuleRegistry, IGrammarRegistry {
}
declare abstract class Rule {
readonly $location: ILocation | undefined;
readonly id: RuleId;
private readonly _nameIsCapturing;
private readonly _name;
private readonly _contentNameIsCapturing;
private readonly _contentName;
constructor($location: ILocation | undefined, id: RuleId, name: string | null | undefined, contentName: string | null | undefined);
abstract dispose(): void;
get debugName(): string;
getName(lineText: string | null, captureIndices: IOnigCaptureIndex[] | null): string | null;
getContentName(lineText: string, captureIndices: IOnigCaptureIndex[]): string | null;
abstract collectPatterns(grammar: IRuleRegistry, out: RegExpSourceList): void;
abstract compile(grammar: IRuleRegistry & IOnigLib, endRegexSource: RegExpString | null): CompiledRule;
abstract compileAG(grammar: IRuleRegistry & IOnigLib, endRegexSource: RegExpString | null, allowA: boolean, allowG: boolean): CompiledRule;
}
declare class RegExpSource<TRuleId = RuleId | typeof endRuleId> {
source: RegExpString;
readonly ruleId: TRuleId;
hasAnchor: boolean;
readonly hasBackReferences: boolean;
private _anchorCache;
constructor(regExpSource: RegExpString, ruleId: TRuleId);
clone(): RegExpSource<TRuleId>;
setSource(newSource: RegExpString): void;
resolveBackReferences(lineText: string, captureIndices: IOnigCaptureIndex[]): string;
private _buildAnchorCache;
resolveAnchors(allowA: boolean, allowG: boolean): RegExpString;
}
declare class RegExpSourceList<TRuleId = RuleId | typeof endRuleId> {
private readonly _items;
private _hasAnchors;
private _cached;
private _anchorCache;
constructor();
dispose(): void;
private _disposeCaches;
push(item: RegExpSource<TRuleId>): void;
unshift(item: RegExpSource<TRuleId>): void;
length(): number;
setSource(index: number, newSource: RegExpString): void;
compile(onigLib: IOnigLib): CompiledRule<TRuleId>;
compileAG(onigLib: IOnigLib, allowA: boolean, allowG: boolean): CompiledRule<TRuleId>;
private _resolveAnchors;
}
declare class CompiledRule<TRuleId = RuleId | typeof endRuleId> {
private readonly regExps;
private readonly rules;
private readonly scanner;
constructor(onigLib: IOnigLib, regExps: RegExpString[], rules: TRuleId[]);
dispose(): void;
toString(): string;
findNextMatchSync(string: string | OnigString, startPosition: number, options: OrMask<FindOption>): IFindNextMatchResult<TRuleId> | null;
}
interface IFindNextMatchResult<TRuleId = RuleId | typeof endRuleId> {
ruleId: TRuleId;
captureIndices: IOnigCaptureIndex[];
}
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 | RegExp;
interface IRawRepositoryMap {
[name: string]: 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;
}
interface IOnigLib {
createOnigScanner(sources: RegExpString[]): OnigScanner;
createOnigString(str: string): OnigString;
}
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;
}
declare function disposeOnigString(str: OnigString): void;
/**
* A union of given const enum values.
*/
type OrMask<T extends number> = number;
declare class Theme {
private readonly _colorMap;
private readonly _defaults;
private readonly _root;
static createFromRawTheme(source: IRawTheme | undefined, colorMap?: string[]): Theme;
static createFromParsedTheme(source: ParsedThemeRule[], colorMap?: string[]): Theme;
private readonly _cachedMatchRoot;
constructor(_colorMap: ColorMap, _defaults: StyleAttributes, _root: ThemeTrieElement);
getColorMap(): string[];
getDefaults(): StyleAttributes;
match(scopePath: ScopeStack | null): StyleAttributes | null;
}
/**
* Identifiers with a binary dot operator.
* Examples: `baz` or `foo.bar`
*/
type ScopeName = string;
/**
* An expression language of ScopeNames with a binary space (to indicate nesting) operator.
* Examples: `foo.bar boo.baz`
*/
type ScopePath = 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 class ScopeStack {
readonly parent: ScopeStack | null;
readonly scopeName: ScopeName;
static push(path: ScopeStack | null, scopeNames: ScopeName[]): ScopeStack | null;
static from(first: ScopeName, ...segments: ScopeName[]): ScopeStack;
static from(...segments: ScopeName[]): ScopeStack | null;
constructor(parent: ScopeStack | null, scopeName: ScopeName);
push(scopeName: ScopeName): ScopeStack;
getSegments(): ScopeName[];
toString(): string;
extends(other: ScopeStack): boolean;
getExtensionIfDefined(base: ScopeStack | null): string[] | undefined;
}
declare class StyleAttributes {
readonly fontStyle: OrMask<FontStyle>;
readonly foregroundId: number;
readonly backgroundId: number;
constructor(fontStyle: OrMask<FontStyle>, foregroundId: number, backgroundId: number);
}
declare class ParsedThemeRule {
readonly scope: ScopeName;
readonly parentScopes: ScopeName[] | null;
readonly index: number;
readonly fontStyle: OrMask<FontStyle>;
readonly foreground: string | null;
readonly background: string | null;
constructor(scope: ScopeName, parentScopes: ScopeName[] | null, index: number, fontStyle: OrMask<FontStyle>, foreground: string | null, background: string | null);
}
declare const enum FontStyle {
NotSet = -1,
None = 0,
Italic = 1,
Bold = 2,
Underline = 4,
Strikethrough = 8
}
declare class ColorMap {
private readonly _isFrozen;
private _lastColorId;
private _id2color;
private _color2id;
constructor(_colorMap?: string[]);
getId(color: string | null): number;
getColorMap(): string[];
}
declare class ThemeTrieElementRule {
scopeDepth: number;
parentScopes: readonly ScopeName[];
fontStyle: number;
foreground: number;
background: number;
constructor(scopeDepth: number, parentScopes: readonly ScopeName[] | null, fontStyle: number, foreground: number, background: number);
clone(): ThemeTrieElementRule;
static cloneArr(arr: ThemeTrieElementRule[]): ThemeTrieElementRule[];
acceptOverwrite(scopeDepth: number, fontStyle: number, foreground: number, background: number): void;
}
interface ITrieChildrenMap {
[segment: string]: ThemeTrieElement;
}
declare class ThemeTrieElement {
private readonly _mainRule;
private readonly _children;
private readonly _rulesWithParentScopes;
constructor(_mainRule: ThemeTrieElementRule, rulesWithParentScopes?: ThemeTrieElementRule[], _children?: ITrieChildrenMap);
private static _cmpBySpecificity;
match(scope: ScopeName): ThemeTrieElementRule[];
insert(scopeDepth: number, scope: ScopeName, parentScopes: ScopeName[] | null, fontStyle: number, foreground: number, background: number): void;
private _doInsertHere;
}
type EncodedTokenAttributes = number;
declare class EncodedTokenMetadata {
static toBinaryStr(encodedTokenAttributes: EncodedTokenAttributes): string;
static print(encodedTokenAttributes: EncodedTokenAttributes): void;
static getLanguageId(encodedTokenAttributes: EncodedTokenAttributes): number;
static getTokenType(encodedTokenAttributes: EncodedTokenAttributes): StandardTokenType;
static containsBalancedBrackets(encodedTokenAttributes: EncodedTokenAttributes): boolean;
static getFontStyle(encodedTokenAttributes: EncodedTokenAttributes): number;
static getForeground(encodedTokenAttributes: EncodedTokenAttributes): number;
static getBackground(encodedTokenAttributes: EncodedTokenAttributes): number;
/**
* Updates the fields in `metadata`.
* A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.
*/
static set(encodedTokenAttributes: EncodedTokenAttributes, languageId: number | 0, tokenType: OptionalStandardTokenType | OptionalStandardTokenType.NotSet, containsBalancedBrackets: boolean | null, fontStyle: FontStyle | FontStyle.NotSet, foreground: number | 0, background: number | 0): number;
}
declare const enum StandardTokenType {
Other = 0,
Comment = 1,
String = 2,
RegEx = 3
}
declare const enum OptionalStandardTokenType {
Other = 0,
Comment = 1,
String = 2,
RegEx = 3,
NotSet = 8
}
interface Matcher<T> {
(matcherInput: T): boolean;
}
declare class BasicScopeAttributes {
readonly languageId: number;
readonly tokenType: OptionalStandardTokenType;
constructor(languageId: number, tokenType: OptionalStandardTokenType);
}
interface IThemeProvider {
themeMatch(scopePath: ScopeStack): StyleAttributes | null;
getDefaults(): StyleAttributes;
}
interface IGrammarRepository {
lookup(scopeName: ScopeName): IRawGrammar | undefined;
injections(scopeName: ScopeName): ScopeName[];
}
interface Injection {
readonly debugSelector: string;
readonly matcher: Matcher<string[]>;
readonly priority: -1 | 0 | 1;
readonly ruleId: RuleId;
readonly grammar: IRawGrammar;
}
declare class Grammar implements IGrammar, IRuleFactoryHelper, IOnigLib {
private readonly _rootScopeName;
private readonly balancedBracketSelectors;
private readonly _onigLib;
private _rootId;
private _lastRuleId;
private readonly _ruleId2desc;
private readonly _includedGrammars;
private readonly _grammarRepository;
private readonly _grammar;
private _injections;
private readonly _basicScopeAttributesProvider;
private readonly _tokenTypeMatchers;
get themeProvider(): IThemeProvider;
constructor(_rootScopeName: ScopeName, grammar: IRawGrammar, initialLanguage: number, embeddedLanguages: IEmbeddedLanguagesMap | null, tokenTypes: ITokenTypeMap | null, balancedBracketSelectors: BalancedBracketSelectors | null, grammarRepository: IGrammarRepository & IThemeProvider, _onigLib: IOnigLib);
dispose(): void;
createOnigScanner(sources: RegExpString[]): OnigScanner;
createOnigString(sources: string): OnigString;
getMetadataForScope(scope: string): BasicScopeAttributes;
private _collectInjections;
getInjections(): Injection[];
registerRule<T extends Rule>(factory: (id: RuleId) => T): T;
getRule(ruleId: RuleId): Rule;
getExternalGrammar(scopeName: string, repository?: IRawRepository): IRawGrammar | undefined;
tokenizeLine(lineText: string, prevState: StateStackImpl | null, timeLimit?: number): ITokenizeLineResult;
tokenizeLine2(lineText: string, prevState: StateStackImpl | null, timeLimit?: number): ITokenizeLineResult2;
private _tokenize;
}
declare class AttributedScopeStack {
readonly parent: AttributedScopeStack | null;
readonly scopePath: ScopeStack;
readonly tokenAttributes: EncodedTokenAttributes;
static fromExtension(namesScopeList: AttributedScopeStack | null, contentNameScopesList: AttributedScopeStackFrame[]): AttributedScopeStack | null;
static createRoot(scopeName: ScopeName, tokenAttributes: EncodedTokenAttributes): AttributedScopeStack;
static createRootAndLookUpScopeName(scopeName: ScopeName, tokenAttributes: EncodedTokenAttributes, grammar: Grammar): AttributedScopeStack;
get scopeName(): ScopeName;
/**
* Invariant:
* ```
* if (parent && !scopePath.extends(parent.scopePath)) {
* throw new Error();
* }
* ```
*/
private constructor();
toString(): string;
equals(other: AttributedScopeStack): boolean;
static equals(a: AttributedScopeStack | null, b: AttributedScopeStack | null): boolean;
private static mergeAttributes;
pushAttributed(scopePath: ScopePath | null, grammar: Grammar): AttributedScopeStack;
private static _pushAttributed;
getScopeNames(): string[];
getExtensionIfDefined(base: AttributedScopeStack | null): AttributedScopeStackFrame[] | undefined;
}
interface AttributedScopeStackFrame {
encodedTokenAttributes: number;
scopeNames: string[];
}
/**
* Represents a "pushed" state on the stack (as a linked list element).
*/
declare class StateStackImpl implements StateStack {
/**
* The previous state on the stack (or null for the root state).
*/
readonly parent: StateStackImpl | null;
/**
* The state (rule) that this element represents.
*/
private readonly ruleId;
/**
* The state has entered and captured \n. This means that the next line should have an anchorPosition of 0.
*/
readonly beginRuleCapturedEOL: boolean;
/**
* The "pop" (end) condition for this state in case that it was dynamically generated through captured text.
*/
readonly endRule: string | null;
/**
* The list of scopes containing the "name" for this state.
*/
readonly nameScopesList: AttributedScopeStack | null;
/**
* The list of scopes containing the "contentName" (besides "name") for this state.
* This list **must** contain as an element `scopeName`.
*/
readonly contentNameScopesList: AttributedScopeStack | null;
_stackElementBrand: void;
static NULL: StateStackImpl;
/**
* The position on the current line where this state was pushed.
* This is relevant only while tokenizing a line, to detect endless loops.
* Its value is meaningless across lines.
*/
private _enterPos;
/**
* The captured anchor position when this stack element was pushed.
* This is relevant only while tokenizing a line, to restore the anchor position when popping.
* Its value is meaningless across lines.
*/
private _anchorPos;
/**
* The depth of the stack.
*/
readonly depth: number;
/**
* Invariant:
* ```
* if (contentNameScopesList !== nameScopesList && contentNameScopesList?.parent !== nameScopesList) {
* throw new Error();
* }
* if (this.parent && !nameScopesList.extends(this.parent.contentNameScopesList)) {
* throw new Error();
* }
* ```
*/
constructor(
/**
* The previous state on the stack (or null for the root state).
*/
parent: StateStackImpl | null,
/**
* The state (rule) that this element represents.
*/
ruleId: RuleId, enterPos: number, anchorPos: number,
/**
* The state has entered and captured \n. This means that the next line should have an anchorPosition of 0.
*/
beginRuleCapturedEOL: boolean,
/**
* The "pop" (end) condition for this state in case that it was dynamically generated through captured text.
*/
endRule: string | null,
/**
* The list of scopes containing the "name" for this state.
*/
nameScopesList: AttributedScopeStack | null,
/**
* The list of scopes containing the "contentName" (besides "name") for this state.
* This list **must** contain as an element `scopeName`.
*/
contentNameScopesList: AttributedScopeStack | null);
equals(other: StateStackImpl): boolean;
private static _equals;
/**
* A structural equals check. Does not take into account `scopes`.
*/
private static _structuralEquals;
clone(): StateStackImpl;
private static _reset;
reset(): void;
pop(): StateStackImpl | null;
safePop(): StateStackImpl;
push(ruleId: RuleId, enterPos: number, anchorPos: number, beginRuleCapturedEOL: boolean, endRule: string | null, nameScopesList: AttributedScopeStack | null, contentNameScopesList: AttributedScopeStack | null): StateStackImpl;
getEnterPos(): number;
getAnchorPos(): number;
getRule(grammar: IRuleRegistry): Rule;
toString(): string;
private _writeString;
withContentNameScopesList(contentNameScopeStack: AttributedScopeStack): StateStackImpl;
withEndRule(endRule: string): StateStackImpl;
hasSameRuleAs(other: StateStackImpl): boolean;
toStateStackFrame(): StateStackFrame;
static pushFrame(self: StateStackImpl | null, frame: StateStackFrame): StateStackImpl;
}
interface StateStackFrame {
ruleId: number;
enterPos?: number;
anchorPos?: number;
beginRuleCapturedEOL: boolean;
endRule: string | null;
nameScopesList: AttributedScopeStackFrame[];
/**
* on top of nameScopesList
*/
contentNameScopesList: AttributedScopeStackFrame[];
}
declare class BalancedBracketSelectors {
private readonly balancedBracketScopes;
private readonly unbalancedBracketScopes;
private allowAny;
constructor(balancedBracketScopes: string[], unbalancedBracketScopes: string[]);
get matchesAlways(): boolean;
get matchesNever(): boolean;
match(scopes: string[]): boolean;
}
declare class SyncRegistry implements IGrammarRepository, IThemeProvider {
private readonly _onigLib;
readonly _grammars: Map<string, Grammar>;
readonly _rawGrammars: Map<string, IRawGrammar>;
readonly _injectionGrammars: Map<string, string[]>;
_theme: Theme;
constructor(theme: Theme, _onigLib: IOnigLib);
dispose(): void;
setTheme(theme: Theme): void;
getColorMap(): string[];
/**
* Add `grammar` to registry and return a list of referenced scope names
*/
addGrammar(grammar: IRawGrammar, injectionScopeNames?: ScopeName[]): void;
/**
* Lookup a raw grammar.
*/
lookup(scopeName: ScopeName): IRawGrammar | undefined;
/**
* Returns the injections for the given grammar
*/
injections(targetScope: ScopeName): ScopeName[];
/**
* Get the default theme settings
*/
getDefaults(): StyleAttributes;
/**
* Match a scope in the theme.
*/
themeMatch(scopePath: ScopeStack): StyleAttributes | null;
/**
* Lookup a grammar.
*/
grammarForScopeName(scopeName: ScopeName, initialLanguage: number, embeddedLanguages: IEmbeddedLanguagesMap | null, tokenTypes: ITokenTypeMap | null, balancedBracketSelectors: BalancedBracketSelectors | null): IGrammar | null;
}
interface StackDiff {
readonly pops: number;
readonly newFrames: StateStackFrame[];
}
/**
* A registry helper that can locate grammar file paths given scope names.
*/
interface RegistryOptions {
onigLib: IOnigLib;
theme?: IRawTheme;
colorMap?: string[];
loadGrammar(scopeName: ScopeName): IRawGrammar | undefined | null;
getInjections?(scopeName: ScopeName): ScopeName[] | undefined;
}
/**
* A map from scope name to a language id. Please do not use language id 0.
*/
interface IEmbeddedLanguagesMap {
[scopeName: string]: number;
}
/**
* A map from selectors to token types.
*/
interface ITokenTypeMap {
[selector: string]: StandardTokenType;
}
interface IGrammarConfiguration {
embeddedLanguages?: IEmbeddedLanguagesMap;
tokenTypes?: ITokenTypeMap;
balancedBracketSelectors?: string[];
unbalancedBracketSelectors?: string[];
}
/**
* The registry that will hold all grammars.
*/
declare class Registry {
readonly _options: RegistryOptions;
readonly _syncRegistry: SyncRegistry;
readonly _ensureGrammarCache: Map<string, boolean>;
constructor(options: RegistryOptions);
dispose(): void;
/**
* Change the theme. Once called, no previous `ruleStack` should be used anymore.
*/
setTheme(theme: IRawTheme, colorMap?: string[]): void;
/**
* Returns a lookup array for color ids.
*/
getColorMap(): string[];
/**
* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
* Please do not use language id 0.
*/
loadGrammarWithEmbeddedLanguages(initialScopeName: ScopeName, initialLanguage: number, embeddedLanguages: IEmbeddedLanguagesMap): IGrammar | null;
/**
* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
* Please do not use language id 0.
*/
loadGrammarWithConfiguration(initialScopeName: ScopeName, initialLanguage: number, configuration: IGrammarConfiguration): IGrammar | null;
/**
* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
*/
loadGrammar(initialScopeName: ScopeName): IGrammar | null;
private _loadGrammar;
private _loadSingleGrammar;
private _doLoadSingleGrammar;
/**
* Adds a rawGrammar.
*/
addGrammar(rawGrammar: IRawGrammar, injections?: string[], initialLanguage?: number, embeddedLanguages?: IEmbeddedLanguagesMap | null): IGrammar;
/**
* Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.
*/
private _grammarForScopeName;
}
/**
* 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;
}
declare const INITIAL: StateStack;
export { EncodedTokenMetadata, FindOption, FontStyle, INITIAL, Registry, StateStackImpl, Theme, disposeOnigString };
export type { IEmbeddedLanguagesMap, IGrammar, IGrammarConfiguration, IOnigCaptureIndex, IOnigLib, IOnigMatch, IRawGrammar, IRawTheme, IRawThemeSetting, IToken, ITokenTypeMap, ITokenizeLineResult, ITokenizeLineResult2, OnigScanner, OnigString, RegistryOptions, StackDiff, StateStack };