naider 1.7.0

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

@@ -0,0 +1,18 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolDiagnostic.js

@@ -0,0 +1,25 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolDocumentLink.d.ts

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

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

@@ -0,0 +1,13 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolInlayHint.d.ts

@@ -0,0 +1,5 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolInlayHint.js

@@ -0,0 +1,13 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.d.ts

@@ -0,0 +1,6 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolTypeHierarchyItem.js

@@ -0,0 +1,16 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.d.ts

@@ -0,0 +1,7 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolWorkspaceSymbol.js

@@ -0,0 +1,18 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/reference.d.ts

@@ -0,0 +1,20 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/reference.js

@@ -0,0 +1,53 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/rename.d.ts

@@ -0,0 +1,27 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/rename.js

@@ -0,0 +1,113 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/selectionRange.d.ts

@@ -0,0 +1,16 @@
+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/vscode-naide/node_modules/vscode-languageclient/lib/common/selectionRange.js

@@ -0,0 +1,57 @@
+"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/vscode-naide/node_modules/vscode-languageclient/lib/common/semanticTokens.d.ts

@@ -0,0 +1,33 @@
+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];
+}