@codingame/monaco-vscode-treesitter-service-override 17.2.1 → 18.0.0

package/index.js

@@ -1,14 +1,10 @@
 
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
-import { TreeSitterImporter } from './vscode/src/vs/editor/common/services/treeSitterParserService.js';
-import { ITreeSitterParserService, ITreeSitterImporter } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service';
-import { TreeSitterTextModelService } from './vscode/src/vs/editor/common/services/treeSitter/treeSitterParserService.js';
-import { ITreeSitterTokenizationFeature } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.service';
-import { TreeSitterTokenizationFeature } from './vscode/src/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.js';
 import { registerAssets } from '@codingame/monaco-vscode-api/assets';
-import { ITreeSitterTokenizationStoreService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/treeSitterTokenStoreService.service';
-import { TreeSitterTokenizationStoreService } from './vscode/src/vs/editor/common/model/treeSitterTokenStoreService.js';
-import './vscode/src/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.contribution.js';
+import { ITreeSitterThemeService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterThemeService.service';
+import { TreeSitterThemeService } from './vscode/src/vs/workbench/services/treeSitter/browser/treeSitterThemeService.js';
+import { ITreeSitterLibraryService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service';
+import { TreeSitterLibraryService } from './vscode/src/vs/workbench/services/treeSitter/browser/treeSitterLibraryService.js';
 
 registerAssets({
     'vs/../../node_modules/@vscode/tree-sitter-wasm/wasm/tree-sitter.wasm': new URL('@vscode/tree-sitter-wasm/wasm/tree-sitter.wasm', import.meta.url).href,
@@ -17,10 +13,8 @@ registerAssets({
 });
 function getServiceOverride() {
     return {
-        [ITreeSitterImporter.toString()]: new SyncDescriptor(TreeSitterImporter, [], false),
-        [ITreeSitterParserService.toString()]: new SyncDescriptor(TreeSitterTextModelService, [], false),
-        [ITreeSitterTokenizationFeature.toString()]: new SyncDescriptor(TreeSitterTokenizationFeature, [], false),
-        [ITreeSitterTokenizationStoreService.toString()]: new SyncDescriptor(TreeSitterTokenizationStoreService, [], false)
+        [ITreeSitterThemeService.toString()]: new SyncDescriptor(TreeSitterThemeService, [], false),
+        [ITreeSitterLibraryService.toString()]: new SyncDescriptor(TreeSitterLibraryService, [], false)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-treesitter-service-override",
-  "version": "17.2.1",
+  "version": "18.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - treesitter service-override",
   "keywords": [],
@@ -15,10 +15,9 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-7443a901-21f6-577a-9674-42893b997ee0-common": "17.2.1",
-    "@codingame/monaco-vscode-9d0168a3-519b-57f3-9bcc-89efc41f951a-common": "17.2.1",
-    "@codingame/monaco-vscode-api": "17.2.1",
-    "@vscode/tree-sitter-wasm": "0.1.4"
+    "@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common": "18.0.0",
+    "@codingame/monaco-vscode-9d0168a3-519b-57f3-9bcc-89efc41f951a-common": "18.0.0",
+    "@codingame/monaco-vscode-api": "18.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/amdX.d.ts

@@ -0,0 +1,3 @@
+export declare const canASAR = false;
+export declare function importAMDNodeModule<T>(nodeModuleName: string, pathInsideNodeModule: string, isBuilt?: boolean): Promise<T>;
+export declare function resolveAmdNodeModulePath(nodeModuleName: string, pathInsideNodeModule: string): string;

package/vscode/src/vs/amdX.js

@@ -0,0 +1,188 @@
+
+import { Schemas, VSCODE_AUTHORITY, nodeModulesPath, FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+
+class DefineCall {
+    constructor(id, dependencies, callback) {
+        this.id = id;
+        this.dependencies = dependencies;
+        this.callback = callback;
+    }
+}
+var AMDModuleImporterState;
+(function (AMDModuleImporterState) {
+    AMDModuleImporterState[AMDModuleImporterState["Uninitialized"] = 1] = "Uninitialized";
+    AMDModuleImporterState[AMDModuleImporterState["InitializedInternal"] = 2] = "InitializedInternal";
+    AMDModuleImporterState[AMDModuleImporterState["InitializedExternal"] = 3] = "InitializedExternal";
+})(AMDModuleImporterState || (AMDModuleImporterState = {}));
+class AMDModuleImporter {
+    static { this.INSTANCE = ( new AMDModuleImporter()); }
+    constructor() {
+        this._isWebWorker = (typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope');
+        this._isRenderer = typeof document === 'object';
+        this._defineCalls = [];
+        this._state = AMDModuleImporterState.Uninitialized;
+    }
+    _initialize() {
+        if (this._state === AMDModuleImporterState.Uninitialized) {
+            if (globalThis.define) {
+                this._state = AMDModuleImporterState.InitializedExternal;
+                return;
+            }
+        }
+        else {
+            return;
+        }
+        this._state = AMDModuleImporterState.InitializedInternal;
+        globalThis.define = (id, dependencies, callback) => {
+            if (typeof id !== 'string') {
+                callback = dependencies;
+                dependencies = id;
+                id = null;
+            }
+            if (typeof dependencies !== 'object' || !Array.isArray(dependencies)) {
+                callback = dependencies;
+                dependencies = null;
+            }
+            this._defineCalls.push(( new DefineCall(id, dependencies, callback)));
+        };
+        globalThis.define.amd = true;
+        if (this._isRenderer) {
+            this._amdPolicy = globalThis._VSCODE_WEB_PACKAGE_TTP ?? window.trustedTypes?.createPolicy('amdLoader', {
+                createScriptURL(value) {
+                    if (value.startsWith(window.location.origin)) {
+                        return value;
+                    }
+                    if (value.startsWith(`${Schemas.vscodeFileResource}://${VSCODE_AUTHORITY}`)) {
+                        return value;
+                    }
+                    throw ( new Error(`[trusted_script_src] Invalid script url: ${value}`));
+                }
+            });
+        }
+        else if (this._isWebWorker) {
+            this._amdPolicy = globalThis._VSCODE_WEB_PACKAGE_TTP ?? globalThis.trustedTypes?.createPolicy('amdLoader', {
+                createScriptURL(value) {
+                    return value;
+                }
+            });
+        }
+    }
+    async load(scriptSrc) {
+        this._initialize();
+        if (this._state === AMDModuleImporterState.InitializedExternal) {
+            return ( new Promise(resolve => {
+                const tmpModuleId = generateUuid();
+                globalThis.define(tmpModuleId, [scriptSrc], function (moduleResult) {
+                    resolve(moduleResult);
+                });
+            }));
+        }
+        const defineCall = await (this._isWebWorker ? this._workerLoadScript(scriptSrc) : this._isRenderer ? this._rendererLoadScript(scriptSrc) : this._nodeJSLoadScript(scriptSrc));
+        if (!defineCall) {
+            console.warn(`Did not receive a define call from script ${scriptSrc}`);
+            return undefined;
+        }
+        const exports = {};
+        const dependencyObjs = [];
+        const dependencyModules = [];
+        if (Array.isArray(defineCall.dependencies)) {
+            for (const mod of defineCall.dependencies) {
+                if (mod === 'exports') {
+                    dependencyObjs.push(exports);
+                }
+                else {
+                    dependencyModules.push(mod);
+                }
+            }
+        }
+        if (dependencyModules.length > 0) {
+            throw ( new Error(
+                `Cannot resolve dependencies for script ${scriptSrc}. The dependencies are: ${dependencyModules.join(', ')}`
+            ));
+        }
+        if (typeof defineCall.callback === 'function') {
+            return defineCall.callback(...dependencyObjs) ?? exports;
+        }
+        else {
+            return defineCall.callback;
+        }
+    }
+    _rendererLoadScript(scriptSrc) {
+        return ( new Promise((resolve, reject) => {
+            const scriptElement = document.createElement('script');
+            scriptElement.setAttribute('async', 'async');
+            scriptElement.setAttribute('type', 'text/javascript');
+            const unbind = () => {
+                scriptElement.removeEventListener('load', loadEventListener);
+                scriptElement.removeEventListener('error', errorEventListener);
+            };
+            const loadEventListener = (e) => {
+                unbind();
+                resolve(this._defineCalls.pop());
+            };
+            const errorEventListener = (e) => {
+                unbind();
+                reject(e);
+            };
+            scriptElement.addEventListener('load', loadEventListener);
+            scriptElement.addEventListener('error', errorEventListener);
+            if (this._amdPolicy) {
+                scriptSrc = this._amdPolicy.createScriptURL(scriptSrc);
+            }
+            scriptElement.setAttribute('src', scriptSrc);
+            window.document.getElementsByTagName('head')[0].appendChild(scriptElement);
+        }));
+    }
+    async _workerLoadScript(scriptSrc) {
+        if (this._amdPolicy) {
+            scriptSrc = this._amdPolicy.createScriptURL(scriptSrc);
+        }
+        await import(scriptSrc).then(module => module.default ?? module);
+        return this._defineCalls.pop();
+    }
+    async _nodeJSLoadScript(scriptSrc) {
+        try {
+            const fs = (await import(`${'fs'}`).then(module => module.default ?? module)).default;
+            const vm = (await import(`${'vm'}`).then(module => module.default ?? module)).default;
+            const module = (await import(`${'module'}`).then(module => module.default ?? module)).default;
+            const filePath = ( URI.parse(scriptSrc)).fsPath;
+            const content = ( fs.readFileSync(filePath).toString());
+            const scriptSource = module.wrap(content.replace(/^#!.*/, ''));
+            const script = new vm.Script(scriptSource);
+            const compileWrapper = script.runInThisContext();
+            compileWrapper.apply();
+            return this._defineCalls.pop();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+const cache = ( new Map());
+async function importAMDNodeModule(nodeModuleName, pathInsideNodeModule, isBuilt) {
+    if (isBuilt === undefined) {
+        const product = globalThis._VSCODE_PRODUCT_JSON;
+        isBuilt = Boolean((product ?? globalThis.vscode?.context?.configuration()?.product)?.commit);
+    }
+    const nodeModulePath = `${nodeModuleName}/${pathInsideNodeModule}` ;
+    if (( cache.has(nodeModulePath))) {
+        return cache.get(nodeModulePath);
+    }
+    let scriptSrc;
+    if (/^\w[\w\d+.-]*:\/\//.test(nodeModulePath)) {
+        scriptSrc = nodeModulePath;
+    }
+    else {
+        const actualNodeModulesPath = (nodeModulesPath);
+        const resourcePath = `${actualNodeModulesPath}/${nodeModulePath}`;
+        scriptSrc = ( ( FileAccess.asBrowserUri(resourcePath)).toString(true));
+    }
+    const result = AMDModuleImporter.INSTANCE.load(scriptSrc);
+    cache.set(nodeModulePath, result);
+    return result;
+}
+
+export { importAMDNodeModule };

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterLibraryService.d.ts

@@ -0,0 +1,28 @@
+import type { Parser, Language, Query } from "@vscode/tree-sitter-wasm";
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ITreeSitterLibraryService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { AppResourcePath } from "@codingame/monaco-vscode-api/vscode/vs/base/common/network";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+export declare const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = "editor.experimental.preferTreeSitter";
+export declare const TREESITTER_ALLOWED_SUPPORT: string[];
+export declare function getModuleLocation(environmentService: IEnvironmentService): AppResourcePath;
+export declare class TreeSitterLibraryService extends Disposable implements ITreeSitterLibraryService {
+    private readonly _configurationService;
+    private readonly _fileService;
+    private readonly _environmentService;
+    _serviceBrand: undefined;
+    isTest: boolean;
+    private readonly _treeSitterImport;
+    private readonly _supportsLanguage;
+    private readonly _languagesCache;
+    private readonly _injectionQueries;
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _environmentService: IEnvironmentService);
+    supportsLanguage(languageId: string, reader: IReader | undefined): boolean;
+    getParserClass(): Promise<typeof Parser>;
+    getLanguage(languageId: string, reader: IReader | undefined): Language | undefined;
+    getInjectionQueries(languageId: string, reader: IReader | undefined): Query | null | undefined;
+    getHighlightingQueries(languageId: string, reader: IReader | undefined): Query | null | undefined;
+}

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterLibraryService.js

@@ -0,0 +1,136 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { importAMDNodeModule } from '../../../../amdX.js';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { toFileOperationResult, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { CachedFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cache';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { nodeModulesPath, FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+
+const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = 'editor.experimental.preferTreeSitter';
+const MODULE_LOCATION_SUBPATH = `@vscode/tree-sitter-wasm/wasm`;
+const FILENAME_TREESITTER_WASM = `tree-sitter.wasm`;
+function getModuleLocation(environmentService) {
+    return `${nodeModulesPath}/${MODULE_LOCATION_SUBPATH}`;
+}
+let TreeSitterLibraryService = class TreeSitterLibraryService extends Disposable {
+    constructor(_configurationService, _fileService, _environmentService) {
+        super();
+        this._configurationService = _configurationService;
+        this._fileService = _fileService;
+        this._environmentService = _environmentService;
+        this.isTest = false;
+        this._treeSitterImport = ( new Lazy(async () => {
+            const TreeSitter = await importAMDNodeModule('@vscode/tree-sitter-wasm', 'wasm/tree-sitter.js');
+            const isTest = this.isTest;
+            await TreeSitter.Parser.init({
+                locateFile(_file, _folder) {
+                    const location = `${getModuleLocation()}/${FILENAME_TREESITTER_WASM}`;
+                    if (isTest) {
+                        return ( ( FileAccess.asFileUri(location)).toString(true));
+                    }
+                    else {
+                        return ( ( FileAccess.asBrowserUri(location)).toString(true));
+                    }
+                }
+            });
+            return TreeSitter;
+        }));
+        this._supportsLanguage = ( new CachedFunction((languageId) => {
+            return observableConfigValue(`${EDITOR_EXPERIMENTAL_PREFER_TREESITTER}.${languageId}`, false, this._configurationService);
+        }));
+        this._languagesCache = ( new CachedFunction((languageId) => {
+            return ObservablePromise.fromFn(async () => {
+                const languageLocation = getModuleLocation();
+                const grammarName = `tree-sitter-${languageId}`;
+                const wasmPath = `${languageLocation}/${grammarName}.wasm`;
+                const [treeSitter, languageFile] = await Promise.all([
+                    this._treeSitterImport.value,
+                    this._fileService.readFile(( FileAccess.asFileUri(wasmPath)))
+                ]);
+                const Language = treeSitter.Language;
+                const language = await Language.load(languageFile.value.buffer);
+                return language;
+            });
+        }));
+        this._injectionQueries = ( new CachedFunction({ getCacheKey: JSON.stringify }, (arg) => {
+            const loadQuerySource = async () => {
+                const injectionsQueriesLocation = `vs/editor/common/languages/${arg.kind}/${arg.languageId}.scm`;
+                const uri = ( FileAccess.asFileUri(injectionsQueriesLocation));
+                if (!this._fileService.hasProvider(uri)) {
+                    return undefined;
+                }
+                const query = await tryReadFile(this._fileService, uri);
+                if (query === undefined) {
+                    return undefined;
+                }
+                return ( query.value.toString());
+            };
+            return ObservablePromise.fromFn(async () => {
+                const [querySource, language, treeSitter] = await Promise.all([
+                    loadQuerySource(),
+                    this._languagesCache.get(arg.languageId).promise,
+                    this._treeSitterImport.value,
+                ]);
+                if (querySource === undefined) {
+                    return null;
+                }
+                const Query = treeSitter.Query;
+                return ( new Query(language, querySource));
+            }).resolvedValue;
+        }));
+    }
+    supportsLanguage(languageId, reader) {
+        return this._supportsLanguage.get(languageId).read(reader);
+    }
+    async getParserClass() {
+        const treeSitter = await this._treeSitterImport.value;
+        return treeSitter.Parser;
+    }
+    getLanguage(languageId, reader) {
+        if (!this.supportsLanguage(languageId, reader)) {
+            return undefined;
+        }
+        const lang = this._languagesCache.get(languageId).resolvedValue.read(reader);
+        return lang;
+    }
+    getInjectionQueries(languageId, reader) {
+        if (!this.supportsLanguage(languageId, reader)) {
+            return undefined;
+        }
+        const query = this._injectionQueries.get({ languageId, kind: 'injections' }).read(reader);
+        return query;
+    }
+    getHighlightingQueries(languageId, reader) {
+        if (!this.supportsLanguage(languageId, reader)) {
+            return undefined;
+        }
+        const query = this._injectionQueries.get({ languageId, kind: 'highlights' }).read(reader);
+        return query;
+    }
+};
+TreeSitterLibraryService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IEnvironmentService))
+], TreeSitterLibraryService));
+async function tryReadFile(fileService, uri) {
+    try {
+        const result = await fileService.readFile(uri);
+        return result;
+    }
+    catch (e) {
+        if (toFileOperationResult(e) === FileOperationResult.FILE_NOT_FOUND) {
+            return undefined;
+        }
+        throw e;
+    }
+}
+
+export { EDITOR_EXPERIMENTAL_PREFER_TREESITTER, TreeSitterLibraryService, getModuleLocation };

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterThemeService.d.ts

@@ -0,0 +1,11 @@
+import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ITreeSitterThemeService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterThemeService.service";
+import { IWorkbenchThemeService } from "@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common/vscode/vs/workbench/services/themes/common/workbenchThemeService.service";
+export declare class TreeSitterThemeService implements ITreeSitterThemeService {
+    private readonly _themeService;
+    _serviceBrand: undefined;
+    readonly onChange: IObservable<void>;
+    private readonly _colorTheme;
+    constructor(_themeService: IWorkbenchThemeService);
+    findMetadata(captureNames: string[], languageId: number, bracket: boolean, reader: IReader | undefined): number;
+}

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterThemeService.js

@@ -0,0 +1,26 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { findMetadata } from '@codingame/monaco-vscode-9d0168a3-519b-57f3-9bcc-89efc41f951a-common/vscode/vs/workbench/services/themes/common/colorThemeData';
+import { IWorkbenchThemeService } from '@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common/vscode/vs/workbench/services/themes/common/workbenchThemeService.service';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+let TreeSitterThemeService = class TreeSitterThemeService {
+    constructor(_themeService) {
+        this._themeService = _themeService;
+        this._colorTheme = observableFromEvent(this._themeService.onDidColorThemeChange, () => this._themeService.getColorTheme());
+        this.onChange = derived(this, (reader) => {
+            this._colorTheme.read(reader);
+            reader.reportChange(void 0);
+        });
+    }
+    findMetadata(captureNames, languageId, bracket, reader) {
+        return findMetadata(this._colorTheme.read(reader), captureNames, languageId, bracket);
+    }
+};
+TreeSitterThemeService = ( __decorate([
+    ( __param(0, IWorkbenchThemeService))
+], TreeSitterThemeService));
+
+export { TreeSitterThemeService };

package/vscode/src/vs/editor/common/model/tokenStore.d.ts

@@ -1,65 +0,0 @@
-import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-declare class ListNode implements IDisposable {
-    readonly height: number;
-    parent?: ListNode;
-    private readonly _children;
-    get children(): ReadonlyArray<Node>;
-    private _length;
-    get length(): number;
-    constructor(height: number);
-    static create(node1: Node, node2: Node): ListNode;
-    canAppendChild(): boolean;
-    appendChild(node: Node): void;
-    private _updateParentLength;
-    unappendChild(): Node;
-    prependChild(node: Node): void;
-    unprependChild(): Node;
-    lastChild(): Node;
-    dispose(): void;
-}
-export declare enum TokenQuality {
-    None = 0,
-    ViewportGuess = 1,
-    EditGuess = 2,
-    Accurate = 3
-}
-type Node = ListNode | LeafNode;
-interface LeafNode {
-    readonly length: number;
-    token: number;
-    tokenQuality: TokenQuality;
-    height: 0;
-}
-export interface TokenUpdate {
-    readonly startOffsetInclusive: number;
-    readonly length: number;
-    readonly token: number;
-}
-export declare class TokenStore implements IDisposable {
-    private readonly _textModel;
-    private _root;
-    get root(): Node;
-    constructor(_textModel: ITextModel);
-    private createEmptyRoot;
-    buildStore(tokens: TokenUpdate[], tokenQuality: TokenQuality): void;
-    private createFromUpdates;
-    update(length: number, tokens: TokenUpdate[], tokenQuality: TokenQuality): void;
-    delete(length: number, startOffset: number): void;
-    private replace;
-    private traverseInOrderInRange;
-    getTokenAt(offset: number): TokenUpdate | undefined;
-    getTokensInRange(startOffsetInclusive: number, endOffsetExclusive: number): TokenUpdate[];
-    markForRefresh(startOffsetInclusive: number, endOffsetExclusive: number): void;
-    rangeHasTokens(startOffsetInclusive: number, endOffsetExclusive: number, minimumTokenQuality: TokenQuality): boolean;
-    rangeNeedsRefresh(startOffsetInclusive: number, endOffsetExclusive: number): boolean;
-    getNeedsRefresh(): {
-        startOffset: number;
-        endOffset: number;
-    }[];
-    deepCopy(): TokenStore;
-    private _copyNodeIterative;
-    printTree(root?: Node): string;
-    dispose(): void;
-}
-export {};