css-variable-lsp 1.0.0 → 1.0.1

package/client/node_modules/vscode-languageclient/lib/common/protocolDiagnostic.d.ts

@@ -1,18 +0,0 @@
-import * as vscode from 'vscode';
-import { LSPAny } from 'vscode-languageserver-protocol';
-/**
- * We keep this for a while to not break servers which adopted
- * proposed API.
- */
-export interface DiagnosticCode {
-    value: string | number;
-    target: string;
-}
-export declare namespace DiagnosticCode {
-    function is(value: any): value is DiagnosticCode;
-}
-export declare class ProtocolDiagnostic extends vscode.Diagnostic {
-    readonly data: LSPAny | undefined;
-    hasDiagnosticCode: boolean;
-    constructor(range: vscode.Range, message: string, severity: vscode.DiagnosticSeverity, data: LSPAny | undefined);
-}

package/client/node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js

@@ -1,25 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolDiagnostic = exports.DiagnosticCode = void 0;
-const vscode = require("vscode");
-const Is = require("./utils/is");
-var DiagnosticCode;
-(function (DiagnosticCode) {
-    function is(value) {
-        const candidate = value;
-        return candidate !== undefined && candidate !== null && (Is.number(candidate.value) || Is.string(candidate.value)) && Is.string(candidate.target);
-    }
-    DiagnosticCode.is = is;
-})(DiagnosticCode || (exports.DiagnosticCode = DiagnosticCode = {}));
-class ProtocolDiagnostic extends vscode.Diagnostic {
-    constructor(range, message, severity, data) {
-        super(range, message, severity);
-        this.data = data;
-        this.hasDiagnosticCode = false;
-    }
-}
-exports.ProtocolDiagnostic = ProtocolDiagnostic;

package/client/node_modules/vscode-languageclient/lib/common/protocolDocumentLink.d.ts

@@ -1,5 +0,0 @@
-import * as code from 'vscode';
-export default class ProtocolDocumentLink extends code.DocumentLink {
-    data: any;
-    constructor(range: code.Range, target?: code.Uri | undefined);
-}

package/client/node_modules/vscode-languageclient/lib/common/protocolDocumentLink.js

@@ -1,13 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-const code = require("vscode");
-class ProtocolDocumentLink extends code.DocumentLink {
-    constructor(range, target) {
-        super(range, target);
-    }
-}
-exports.default = ProtocolDocumentLink;

package/client/node_modules/vscode-languageclient/lib/common/protocolInlayHint.d.ts

@@ -1,5 +0,0 @@
-import * as code from 'vscode';
-export default class ProtocolInlayHint extends code.InlayHint {
-    data: any;
-    constructor(position: code.Position, label: string | code.InlayHintLabelPart[], kind?: code.InlayHintKind);
-}

package/client/node_modules/vscode-languageclient/lib/common/protocolInlayHint.js

@@ -1,13 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-const code = require("vscode");
-class ProtocolInlayHint extends code.InlayHint {
-    constructor(position, label, kind) {
-        super(position, label, kind);
-    }
-}
-exports.default = ProtocolInlayHint;

package/client/node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.d.ts

@@ -1,6 +0,0 @@
-import * as code from 'vscode';
-import { LSPAny } from 'vscode-languageserver-protocol';
-export default class ProtocolTypeHierarchyItem extends code.TypeHierarchyItem {
-    data?: LSPAny;
-    constructor(kind: code.SymbolKind, name: string, detail: string, uri: code.Uri, range: code.Range, selectionRange: code.Range, data?: LSPAny);
-}

package/client/node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.js

@@ -1,16 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-const code = require("vscode");
-class ProtocolTypeHierarchyItem extends code.TypeHierarchyItem {
-    constructor(kind, name, detail, uri, range, selectionRange, data) {
-        super(kind, name, detail, uri, range, selectionRange);
-        if (data !== undefined) {
-            this.data = data;
-        }
-    }
-}
-exports.default = ProtocolTypeHierarchyItem;

package/client/node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.d.ts

@@ -1,7 +0,0 @@
-import * as code from 'vscode';
-import { LSPAny } from 'vscode-languageserver-protocol';
-export default class WorkspaceSymbol extends code.SymbolInformation {
-    data?: LSPAny;
-    readonly hasRange: boolean;
-    constructor(name: string, kind: code.SymbolKind, containerName: string, locationOrUri: code.Location | code.Uri, data: LSPAny | undefined);
-}

package/client/node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.js

@@ -1,18 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-const code = require("vscode");
-class WorkspaceSymbol extends code.SymbolInformation {
-    constructor(name, kind, containerName, locationOrUri, data) {
-        const hasRange = !(locationOrUri instanceof code.Uri);
-        super(name, kind, containerName, hasRange ? locationOrUri : new code.Location(locationOrUri, new code.Range(0, 0, 0, 0)));
-        this.hasRange = hasRange;
-        if (data !== undefined) {
-            this.data = data;
-        }
-    }
-}
-exports.default = WorkspaceSymbol;

package/client/node_modules/vscode-languageclient/lib/common/reference.d.ts

@@ -1,20 +0,0 @@
-import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, ReferenceProvider, Location as VLocation } from 'vscode';
-import { ClientCapabilities, DocumentSelector, ReferenceOptions, ReferenceRegistrationOptions, ServerCapabilities, TextDocumentRegistrationOptions } from 'vscode-languageserver-protocol';
-import { FeatureClient, TextDocumentLanguageFeature } from './features';
-export interface ProvideReferencesSignature {
-    (this: void, document: TextDocument, position: VPosition, options: {
-        includeDeclaration: boolean;
-    }, token: CancellationToken): ProviderResult<VLocation[]>;
-}
-export interface ReferencesMiddleware {
-    provideReferences?: (this: void, document: TextDocument, position: VPosition, options: {
-        includeDeclaration: boolean;
-    }, token: CancellationToken, next: ProvideReferencesSignature) => ProviderResult<VLocation[]>;
-}
-export declare class ReferencesFeature extends TextDocumentLanguageFeature<boolean | ReferenceOptions, ReferenceRegistrationOptions, ReferenceProvider, ReferencesMiddleware> {
-    constructor(client: FeatureClient<ReferencesMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: TextDocumentRegistrationOptions): [Disposable, ReferenceProvider];
-    private registerProvider;
-}

package/client/node_modules/vscode-languageclient/lib/common/reference.js

@@ -1,53 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReferencesFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-const UUID = require("./utils/uuid");
-class ReferencesFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.ReferencesRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'references').dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const options = this.getRegistrationOptions(documentSelector, capabilities.referencesProvider);
-        if (!options) {
-            return;
-        }
-        this.register({ id: UUID.generateUuid(), registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideReferences: (document, position, options, token) => {
-                const client = this._client;
-                const _providerReferences = (document, position, options, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, client.code2ProtocolConverter.asReferenceParams(document, position, options), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asReferences(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideReferences
-                    ? middleware.provideReferences(document, position, options, token, _providerReferences)
-                    : _providerReferences(document, position, options, token);
-            }
-        };
-        return [this.registerProvider(selector, provider), provider];
-    }
-    registerProvider(selector, provider) {
-        return vscode_1.languages.registerReferenceProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
-    }
-}
-exports.ReferencesFeature = ReferencesFeature;

package/client/node_modules/vscode-languageclient/lib/common/rename.d.ts

@@ -1,27 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Range as VRange, Position as VPosition, WorkspaceEdit as VWorkspaceEdit, RenameProvider } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, RenameOptions, RenameRegistrationOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient, DocumentSelectorOptions } from './features';
-export interface ProvideRenameEditsSignature {
-    (this: void, document: TextDocument, position: VPosition, newName: string, token: CancellationToken): ProviderResult<VWorkspaceEdit>;
-}
-export interface PrepareRenameSignature {
-    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VRange | {
-        range: VRange;
-        placeholder: string;
-    }>;
-}
-export interface RenameMiddleware {
-    provideRenameEdits?: (this: void, document: TextDocument, position: VPosition, newName: string, token: CancellationToken, next: ProvideRenameEditsSignature) => ProviderResult<VWorkspaceEdit>;
-    prepareRename?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: PrepareRenameSignature) => ProviderResult<VRange | {
-        range: VRange;
-        placeholder: string;
-    }>;
-}
-export declare class RenameFeature extends TextDocumentLanguageFeature<boolean | RenameOptions, RenameRegistrationOptions, RenameProvider, RenameMiddleware> {
-    constructor(client: FeatureClient<RenameMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: RenameRegistrationOptions & DocumentSelectorOptions): [Disposable, RenameProvider];
-    private registerProvider;
-    private isDefaultBehavior;
-}

package/client/node_modules/vscode-languageclient/lib/common/rename.js

@@ -1,113 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenameFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const UUID = require("./utils/uuid");
-const Is = require("./utils/is");
-const features_1 = require("./features");
-class RenameFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.RenameRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        let rename = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'rename');
-        rename.dynamicRegistration = true;
-        rename.prepareSupport = true;
-        rename.prepareSupportDefaultBehavior = vscode_languageserver_protocol_1.PrepareSupportDefaultBehavior.Identifier;
-        rename.honorsChangeAnnotations = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const options = this.getRegistrationOptions(documentSelector, capabilities.renameProvider);
-        if (!options) {
-            return;
-        }
-        if (Is.boolean(capabilities.renameProvider)) {
-            options.prepareProvider = false;
-        }
-        this.register({ id: UUID.generateUuid(), registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideRenameEdits: (document, position, newName, token) => {
-                const client = this._client;
-                const provideRenameEdits = (document, position, newName, token) => {
-                    let params = {
-                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
-                        position: client.code2ProtocolConverter.asPosition(position),
-                        newName: newName
-                    };
-                    return client.sendRequest(vscode_languageserver_protocol_1.RenameRequest.type, params, token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asWorkspaceEdit(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.RenameRequest.type, token, error, null, false);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideRenameEdits
-                    ? middleware.provideRenameEdits(document, position, newName, token, provideRenameEdits)
-                    : provideRenameEdits(document, position, newName, token);
-            },
-            prepareRename: options.prepareProvider
-                ? (document, position, token) => {
-                    const client = this._client;
-                    const prepareRename = (document, position, token) => {
-                        let params = {
-                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
-                            position: client.code2ProtocolConverter.asPosition(position),
-                        };
-                        return client.sendRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, params, token).then((result) => {
-                            if (token.isCancellationRequested) {
-                                return null;
-                            }
-                            if (vscode_languageserver_protocol_1.Range.is(result)) {
-                                return client.protocol2CodeConverter.asRange(result);
-                            }
-                            else if (this.isDefaultBehavior(result)) {
-                                return result.defaultBehavior === true
-                                    ? null
-                                    : Promise.reject(new Error(`The element can't be renamed.`));
-                            }
-                            else if (result && vscode_languageserver_protocol_1.Range.is(result.range)) {
-                                return {
-                                    range: client.protocol2CodeConverter.asRange(result.range),
-                                    placeholder: result.placeholder
-                                };
-                            }
-                            // To cancel the rename vscode API expects a rejected promise.
-                            return Promise.reject(new Error(`The element can't be renamed.`));
-                        }, (error) => {
-                            if (typeof error.message === 'string') {
-                                throw new Error(error.message);
-                            }
-                            else {
-                                throw new Error(`The element can't be renamed.`);
-                            }
-                        });
-                    };
-                    const middleware = client.middleware;
-                    return middleware.prepareRename
-                        ? middleware.prepareRename(document, position, token, prepareRename)
-                        : prepareRename(document, position, token);
-                }
-                : undefined
-        };
-        return [this.registerProvider(selector, provider), provider];
-    }
-    registerProvider(selector, provider) {
-        return vscode_1.languages.registerRenameProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
-    }
-    isDefaultBehavior(value) {
-        const candidate = value;
-        return candidate && Is.boolean(candidate.defaultBehavior);
-    }
-}
-exports.RenameFeature = RenameFeature;

package/client/node_modules/vscode-languageclient/lib/common/selectionRange.d.ts

@@ -1,16 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Position as VPosition, SelectionRange as VSelectionRange, SelectionRangeProvider } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, SelectionRangeOptions, SelectionRangeRegistrationOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideSelectionRangeSignature {
-    (this: void, document: TextDocument, positions: readonly VPosition[], token: CancellationToken): ProviderResult<VSelectionRange[]>;
-}
-export interface SelectionRangeProviderMiddleware {
-    provideSelectionRanges?: (this: void, document: TextDocument, positions: readonly VPosition[], token: CancellationToken, next: ProvideSelectionRangeSignature) => ProviderResult<VSelectionRange[]>;
-}
-export declare class SelectionRangeFeature extends TextDocumentLanguageFeature<boolean | SelectionRangeOptions, SelectionRangeRegistrationOptions, SelectionRangeProvider, SelectionRangeProviderMiddleware> {
-    constructor(client: FeatureClient<SelectionRangeProviderMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: SelectionRangeRegistrationOptions): [Disposable, SelectionRangeProvider];
-    private registerProvider;
-}

package/client/node_modules/vscode-languageclient/lib/common/selectionRange.js

@@ -1,57 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectionRangeFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class SelectionRangeFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.SelectionRangeRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'selectionRange');
-        capability.dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const [id, options] = this.getRegistration(documentSelector, capabilities.selectionRangeProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideSelectionRanges: (document, positions, token) => {
-                const client = this._client;
-                const provideSelectionRanges = async (document, positions, token) => {
-                    const requestParams = {
-                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
-                        positions: client.code2ProtocolConverter.asPositionsSync(positions, token)
-                    };
-                    return client.sendRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, requestParams, token).then((ranges) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asSelectionRanges(ranges, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideSelectionRanges
-                    ? middleware.provideSelectionRanges(document, positions, token, provideSelectionRanges)
-                    : provideSelectionRanges(document, positions, token);
-            }
-        };
-        return [this.registerProvider(selector, provider), provider];
-    }
-    registerProvider(selector, provider) {
-        return vscode_1.languages.registerSelectionRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
-    }
-}
-exports.SelectionRangeFeature = SelectionRangeFeature;

package/client/node_modules/vscode-languageclient/lib/common/semanticTokens.d.ts

@@ -1,33 +0,0 @@
-import * as vscode from 'vscode';
-import { ClientCapabilities, ServerCapabilities, DocumentSelector, SemanticTokensOptions, SemanticTokensRegistrationOptions } from 'vscode-languageserver-protocol';
-import { FeatureClient, TextDocumentLanguageFeature } from './features';
-export interface DocumentSemanticsTokensSignature {
-    (this: void, document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SemanticTokens>;
-}
-export interface DocumentSemanticsTokensEditsSignature {
-    (this: void, document: vscode.TextDocument, previousResultId: string, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens>;
-}
-export interface DocumentRangeSemanticTokensSignature {
-    (this: void, document: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SemanticTokens>;
-}
-/**
- * The semantic token middleware
- *
- * @since 3.16.0
- */
-export interface SemanticTokensMiddleware {
-    provideDocumentSemanticTokens?: (this: void, document: vscode.TextDocument, token: vscode.CancellationToken, next: DocumentSemanticsTokensSignature) => vscode.ProviderResult<vscode.SemanticTokens>;
-    provideDocumentSemanticTokensEdits?: (this: void, document: vscode.TextDocument, previousResultId: string, token: vscode.CancellationToken, next: DocumentSemanticsTokensEditsSignature) => vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens>;
-    provideDocumentRangeSemanticTokens?: (this: void, document: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken, next: DocumentRangeSemanticTokensSignature) => vscode.ProviderResult<vscode.SemanticTokens>;
-}
-export interface SemanticTokensProviderShape {
-    range?: vscode.DocumentRangeSemanticTokensProvider;
-    full?: vscode.DocumentSemanticTokensProvider;
-    onDidChangeSemanticTokensEmitter: vscode.EventEmitter<void>;
-}
-export declare class SemanticTokensFeature extends TextDocumentLanguageFeature<boolean | SemanticTokensOptions, SemanticTokensRegistrationOptions, SemanticTokensProviderShape, SemanticTokensMiddleware> {
-    constructor(client: FeatureClient<SemanticTokensMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: SemanticTokensRegistrationOptions): [vscode.Disposable, SemanticTokensProviderShape];
-}