css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,402 +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.DidSaveTextDocumentFeature = exports.WillSaveWaitUntilFeature = exports.WillSaveFeature = exports.DidChangeTextDocumentFeature = exports.DidCloseTextDocumentFeature = exports.DidOpenTextDocumentFeature = 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 DidOpenTextDocumentFeature extends features_1.TextDocumentEventFeature {
-    constructor(client, syncedDocuments) {
-        super(client, vscode_1.workspace.onDidOpenTextDocument, vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, () => client.middleware.didOpen, (textDocument) => client.code2ProtocolConverter.asOpenTextDocumentParams(textDocument), (data) => data, features_1.TextDocumentEventFeature.textDocumentFilter);
-        this._syncedDocuments = syncedDocuments;
-    }
-    get openDocuments() {
-        return this._syncedDocuments.values();
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'synchronization').dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
-        if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.openClose) {
-            this.register({ id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector } });
-        }
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type;
-    }
-    register(data) {
-        super.register(data);
-        if (!data.registerOptions.documentSelector) {
-            return;
-        }
-        const documentSelector = this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector);
-        vscode_1.workspace.textDocuments.forEach((textDocument) => {
-            const uri = textDocument.uri.toString();
-            if (this._syncedDocuments.has(uri)) {
-                return;
-            }
-            if (vscode_1.languages.match(documentSelector, textDocument) > 0 && !this._client.hasDedicatedTextSynchronizationFeature(textDocument)) {
-                const middleware = this._client.middleware;
-                const didOpen = (textDocument) => {
-                    return this._client.sendNotification(this._type, this._createParams(textDocument));
-                };
-                (middleware.didOpen ? middleware.didOpen(textDocument, didOpen) : didOpen(textDocument)).catch((error) => {
-                    this._client.error(`Sending document notification ${this._type.method} failed`, error);
-                });
-                this._syncedDocuments.set(uri, textDocument);
-            }
-        });
-    }
-    getTextDocument(data) {
-        return data;
-    }
-    notificationSent(textDocument, type, params) {
-        this._syncedDocuments.set(textDocument.uri.toString(), textDocument);
-        super.notificationSent(textDocument, type, params);
-    }
-}
-exports.DidOpenTextDocumentFeature = DidOpenTextDocumentFeature;
-class DidCloseTextDocumentFeature extends features_1.TextDocumentEventFeature {
-    constructor(client, syncedDocuments, pendingTextDocumentChanges) {
-        super(client, vscode_1.workspace.onDidCloseTextDocument, vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, () => client.middleware.didClose, (textDocument) => client.code2ProtocolConverter.asCloseTextDocumentParams(textDocument), (data) => data, features_1.TextDocumentEventFeature.textDocumentFilter);
-        this._syncedDocuments = syncedDocuments;
-        this._pendingTextDocumentChanges = pendingTextDocumentChanges;
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type;
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'synchronization').dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
-        if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.openClose) {
-            this.register({ id: UUID.generateUuid(), registerOptions: { documentSelector: documentSelector } });
-        }
-    }
-    async callback(data) {
-        await super.callback(data);
-        this._pendingTextDocumentChanges.delete(data.uri.toString());
-    }
-    getTextDocument(data) {
-        return data;
-    }
-    notificationSent(textDocument, type, params) {
-        this._syncedDocuments.delete(textDocument.uri.toString());
-        super.notificationSent(textDocument, type, params);
-    }
-    unregister(id) {
-        const selector = this._selectors.get(id);
-        // The super call removed the selector from the map
-        // of selectors.
-        super.unregister(id);
-        const selectors = this._selectors.values();
-        this._syncedDocuments.forEach((textDocument) => {
-            if (vscode_1.languages.match(selector, textDocument) > 0 && !this._selectorFilter(selectors, textDocument) && !this._client.hasDedicatedTextSynchronizationFeature(textDocument)) {
-                let middleware = this._client.middleware;
-                let didClose = (textDocument) => {
-                    return this._client.sendNotification(this._type, this._createParams(textDocument));
-                };
-                this._syncedDocuments.delete(textDocument.uri.toString());
-                (middleware.didClose ? middleware.didClose(textDocument, didClose) : didClose(textDocument)).catch((error) => {
-                    this._client.error(`Sending document notification ${this._type.method} failed`, error);
-                });
-            }
-        });
-    }
-}
-exports.DidCloseTextDocumentFeature = DidCloseTextDocumentFeature;
-class DidChangeTextDocumentFeature extends features_1.DynamicDocumentFeature {
-    constructor(client, pendingTextDocumentChanges) {
-        super(client);
-        this._changeData = new Map();
-        this._onNotificationSent = new vscode_1.EventEmitter();
-        this._onPendingChangeAdded = new vscode_1.EventEmitter();
-        this._pendingTextDocumentChanges = pendingTextDocumentChanges;
-        this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
-    }
-    get onNotificationSent() {
-        return this._onNotificationSent.event;
-    }
-    get onPendingChangeAdded() {
-        return this._onPendingChangeAdded.event;
-    }
-    get syncKind() {
-        return this._syncKind;
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type;
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'synchronization').dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
-        if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.change !== undefined && textDocumentSyncOptions.change !== vscode_languageserver_protocol_1.TextDocumentSyncKind.None) {
-            this.register({
-                id: UUID.generateUuid(),
-                registerOptions: Object.assign({}, { documentSelector: documentSelector }, { syncKind: textDocumentSyncOptions.change })
-            });
-        }
-    }
-    register(data) {
-        if (!data.registerOptions.documentSelector) {
-            return;
-        }
-        if (!this._listener) {
-            this._listener = vscode_1.workspace.onDidChangeTextDocument(this.callback, this);
-        }
-        this._changeData.set(data.id, {
-            syncKind: data.registerOptions.syncKind,
-            documentSelector: this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector),
-        });
-        this.updateSyncKind(data.registerOptions.syncKind);
-    }
-    *getDocumentSelectors() {
-        for (const data of this._changeData.values()) {
-            yield data.documentSelector;
-        }
-    }
-    async callback(event) {
-        // Text document changes are send for dirty changes as well. We don't
-        // have dirty / un-dirty events in the LSP so we ignore content changes
-        // with length zero.
-        if (event.contentChanges.length === 0) {
-            return;
-        }
-        // We need to capture the URI and version here since they might change on the text document
-        // until we reach did `didChange` call since the middleware support async execution.
-        const uri = event.document.uri;
-        const version = event.document.version;
-        const promises = [];
-        for (const changeData of this._changeData.values()) {
-            if (vscode_1.languages.match(changeData.documentSelector, event.document) > 0 && !this._client.hasDedicatedTextSynchronizationFeature(event.document)) {
-                const middleware = this._client.middleware;
-                if (changeData.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental) {
-                    const didChange = async (event) => {
-                        const params = this._client.code2ProtocolConverter.asChangeTextDocumentParams(event, uri, version);
-                        await this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params);
-                        this.notificationSent(event.document, vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, params);
-                    };
-                    promises.push(middleware.didChange ? middleware.didChange(event, event => didChange(event)) : didChange(event));
-                }
-                else if (changeData.syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
-                    const didChange = async (event) => {
-                        const eventUri = event.document.uri.toString();
-                        this._pendingTextDocumentChanges.set(eventUri, event.document);
-                        this._onPendingChangeAdded.fire();
-                    };
-                    promises.push(middleware.didChange ? middleware.didChange(event, event => didChange(event)) : didChange(event));
-                }
-            }
-        }
-        return Promise.all(promises).then(undefined, (error) => {
-            this._client.error(`Sending document notification ${vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type.method} failed`, error);
-            throw error;
-        });
-    }
-    notificationSent(textDocument, type, params) {
-        this._onNotificationSent.fire({ textDocument, type, params });
-    }
-    unregister(id) {
-        this._changeData.delete(id);
-        if (this._changeData.size === 0) {
-            if (this._listener) {
-                this._listener.dispose();
-                this._listener = undefined;
-            }
-            this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
-        }
-        else {
-            this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
-            for (const changeData of this._changeData.values()) {
-                this.updateSyncKind(changeData.syncKind);
-                if (this._syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
-                    break;
-                }
-            }
-        }
-    }
-    clear() {
-        this._pendingTextDocumentChanges.clear();
-        this._changeData.clear();
-        this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
-        if (this._listener) {
-            this._listener.dispose();
-            this._listener = undefined;
-        }
-    }
-    getPendingDocumentChanges(excludes) {
-        if (this._pendingTextDocumentChanges.size === 0) {
-            return [];
-        }
-        let result;
-        if (excludes.size === 0) {
-            result = Array.from(this._pendingTextDocumentChanges.values());
-            this._pendingTextDocumentChanges.clear();
-        }
-        else {
-            result = [];
-            for (const entry of this._pendingTextDocumentChanges) {
-                if (!excludes.has(entry[0])) {
-                    result.push(entry[1]);
-                    this._pendingTextDocumentChanges.delete(entry[0]);
-                }
-            }
-        }
-        return result;
-    }
-    getProvider(document) {
-        for (const changeData of this._changeData.values()) {
-            if (vscode_1.languages.match(changeData.documentSelector, document) > 0) {
-                return {
-                    send: (event) => {
-                        return this.callback(event);
-                    }
-                };
-            }
-        }
-        return undefined;
-    }
-    updateSyncKind(syncKind) {
-        if (this._syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.Full) {
-            return;
-        }
-        switch (syncKind) {
-            case vscode_languageserver_protocol_1.TextDocumentSyncKind.Full:
-                this._syncKind = syncKind;
-                break;
-            case vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental:
-                if (this._syncKind === vscode_languageserver_protocol_1.TextDocumentSyncKind.None) {
-                    this._syncKind = vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental;
-                }
-                break;
-        }
-    }
-}
-exports.DidChangeTextDocumentFeature = DidChangeTextDocumentFeature;
-class WillSaveFeature extends features_1.TextDocumentEventFeature {
-    constructor(client) {
-        super(client, vscode_1.workspace.onWillSaveTextDocument, vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, () => client.middleware.willSave, (willSaveEvent) => client.code2ProtocolConverter.asWillSaveTextDocumentParams(willSaveEvent), (event) => event.document, (selectors, willSaveEvent) => features_1.TextDocumentEventFeature.textDocumentFilter(selectors, willSaveEvent.document));
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type;
-    }
-    fillClientCapabilities(capabilities) {
-        let value = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'synchronization');
-        value.willSave = true;
-    }
-    initialize(capabilities, documentSelector) {
-        let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
-        if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.willSave) {
-            this.register({
-                id: UUID.generateUuid(),
-                registerOptions: { documentSelector: documentSelector }
-            });
-        }
-    }
-    getTextDocument(data) {
-        return data.document;
-    }
-}
-exports.WillSaveFeature = WillSaveFeature;
-class WillSaveWaitUntilFeature extends features_1.DynamicDocumentFeature {
-    constructor(client) {
-        super(client);
-        this._selectors = new Map();
-    }
-    getDocumentSelectors() {
-        return this._selectors.values();
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type;
-    }
-    fillClientCapabilities(capabilities) {
-        let value = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'synchronization');
-        value.willSaveWaitUntil = true;
-    }
-    initialize(capabilities, documentSelector) {
-        let textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
-        if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.willSaveWaitUntil) {
-            this.register({
-                id: UUID.generateUuid(),
-                registerOptions: { documentSelector: documentSelector }
-            });
-        }
-    }
-    register(data) {
-        if (!data.registerOptions.documentSelector) {
-            return;
-        }
-        if (!this._listener) {
-            this._listener = vscode_1.workspace.onWillSaveTextDocument(this.callback, this);
-        }
-        this._selectors.set(data.id, this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector));
-    }
-    callback(event) {
-        if (features_1.TextDocumentEventFeature.textDocumentFilter(this._selectors.values(), event.document) && !this._client.hasDedicatedTextSynchronizationFeature(event.document)) {
-            let middleware = this._client.middleware;
-            let willSaveWaitUntil = (event) => {
-                return this._client.sendRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, this._client.code2ProtocolConverter.asWillSaveTextDocumentParams(event)).then(async (edits) => {
-                    let vEdits = await this._client.protocol2CodeConverter.asTextEdits(edits);
-                    return vEdits === undefined ? [] : vEdits;
-                });
-            };
-            event.waitUntil(middleware.willSaveWaitUntil
-                ? middleware.willSaveWaitUntil(event, willSaveWaitUntil)
-                : willSaveWaitUntil(event));
-        }
-    }
-    unregister(id) {
-        this._selectors.delete(id);
-        if (this._selectors.size === 0 && this._listener) {
-            this._listener.dispose();
-            this._listener = undefined;
-        }
-    }
-    clear() {
-        this._selectors.clear();
-        if (this._listener) {
-            this._listener.dispose();
-            this._listener = undefined;
-        }
-    }
-}
-exports.WillSaveWaitUntilFeature = WillSaveWaitUntilFeature;
-class DidSaveTextDocumentFeature extends features_1.TextDocumentEventFeature {
-    constructor(client) {
-        super(client, vscode_1.workspace.onDidSaveTextDocument, vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, () => client.middleware.didSave, (textDocument) => client.code2ProtocolConverter.asSaveTextDocumentParams(textDocument, this._includeText), (data) => data, features_1.TextDocumentEventFeature.textDocumentFilter);
-        this._includeText = false;
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type;
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'synchronization').didSave = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const textDocumentSyncOptions = capabilities.resolvedTextDocumentSync;
-        if (documentSelector && textDocumentSyncOptions && textDocumentSyncOptions.save) {
-            const saveOptions = typeof textDocumentSyncOptions.save === 'boolean'
-                ? { includeText: false }
-                : { includeText: !!textDocumentSyncOptions.save.includeText };
-            this.register({
-                id: UUID.generateUuid(),
-                registerOptions: Object.assign({}, { documentSelector: documentSelector }, saveOptions)
-            });
-        }
-    }
-    register(data) {
-        this._includeText = !!data.registerOptions.includeText;
-        super.register(data);
-    }
-    getTextDocument(data) {
-        return data;
-    }
-}
-exports.DidSaveTextDocumentFeature = DidSaveTextDocumentFeature;

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

@@ -1,16 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Position as VPosition, Definition as VDefinition, DefinitionLink as VDefinitionLink, TypeDefinitionProvider } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, TypeDefinitionRegistrationOptions, TypeDefinitionOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideTypeDefinitionSignature {
-    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDefinition | VDefinitionLink[]>;
-}
-export interface TypeDefinitionMiddleware {
-    provideTypeDefinition?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideTypeDefinitionSignature) => ProviderResult<VDefinition | VDefinitionLink[]>;
-}
-export declare class TypeDefinitionFeature extends TextDocumentLanguageFeature<boolean | TypeDefinitionOptions, TypeDefinitionRegistrationOptions, TypeDefinitionProvider, TypeDefinitionMiddleware> {
-    constructor(client: FeatureClient<TypeDefinitionMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: TypeDefinitionRegistrationOptions): [Disposable, TypeDefinitionProvider];
-    private registerProvider;
-}

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

@@ -1,55 +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.TypeDefinitionFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class TypeDefinitionFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.TypeDefinitionRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'typeDefinition').dynamicRegistration = true;
-        let typeDefinitionSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'typeDefinition');
-        typeDefinitionSupport.dynamicRegistration = true;
-        typeDefinitionSupport.linkSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        let [id, options] = this.getRegistration(documentSelector, capabilities.typeDefinitionProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideTypeDefinition: (document, position, token) => {
-                const client = this._client;
-                const provideTypeDefinition = (document, position, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asDefinitionResult(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideTypeDefinition
-                    ? middleware.provideTypeDefinition(document, position, token, provideTypeDefinition)
-                    : provideTypeDefinition(document, position, token);
-            }
-        };
-        return [this.registerProvider(selector, provider), provider];
-    }
-    registerProvider(selector, provider) {
-        return vscode_1.languages.registerTypeDefinitionProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
-    }
-}
-exports.TypeDefinitionFeature = TypeDefinitionFeature;

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

@@ -1,31 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Position as VPosition, CancellationToken, TypeHierarchyProvider as VTypeHierarchyProvider, TypeHierarchyItem as VTypeHierarchyItem } from 'vscode';
-import { ClientCapabilities, DocumentSelector, ServerCapabilities, TypeHierarchyRegistrationOptions, TypeHierarchyOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export type PrepareTypeHierarchySignature = (this: void, document: TextDocument, position: VPosition, token: CancellationToken) => ProviderResult<VTypeHierarchyItem[]>;
-export type TypeHierarchySupertypesSignature = (this: void, item: VTypeHierarchyItem, token: CancellationToken) => ProviderResult<VTypeHierarchyItem[]>;
-export type TypeHierarchySubtypesSignature = (this: void, item: VTypeHierarchyItem, token: CancellationToken) => ProviderResult<VTypeHierarchyItem[]>;
-/**
- * Type hierarchy middleware
- *
- * @since 3.17.0
- */
-export type TypeHierarchyMiddleware = {
-    prepareTypeHierarchy?: (this: void, document: TextDocument, positions: VPosition, token: CancellationToken, next: PrepareTypeHierarchySignature) => ProviderResult<VTypeHierarchyItem[]>;
-    provideTypeHierarchySupertypes?: (this: void, item: VTypeHierarchyItem, token: CancellationToken, next: TypeHierarchySupertypesSignature) => ProviderResult<VTypeHierarchyItem[]>;
-    provideTypeHierarchySubtypes?: (this: void, item: VTypeHierarchyItem, token: CancellationToken, next: TypeHierarchySubtypesSignature) => ProviderResult<VTypeHierarchyItem[]>;
-};
-declare class TypeHierarchyProvider implements VTypeHierarchyProvider {
-    private client;
-    private middleware;
-    constructor(client: FeatureClient<TypeHierarchyMiddleware>);
-    prepareTypeHierarchy(document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VTypeHierarchyItem[]>;
-    provideTypeHierarchySupertypes(item: VTypeHierarchyItem, token: CancellationToken): ProviderResult<VTypeHierarchyItem[]>;
-    provideTypeHierarchySubtypes(item: VTypeHierarchyItem, token: CancellationToken): ProviderResult<VTypeHierarchyItem[]>;
-}
-export declare class TypeHierarchyFeature extends TextDocumentLanguageFeature<boolean | TypeHierarchyOptions, TypeHierarchyRegistrationOptions, TypeHierarchyProvider, TypeHierarchyMiddleware> {
-    constructor(client: FeatureClient<TypeHierarchyMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: TypeHierarchyRegistrationOptions): [Disposable, TypeHierarchyProvider];
-}
-export {};

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

@@ -1,96 +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.TypeHierarchyFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class TypeHierarchyProvider {
-    constructor(client) {
-        this.client = client;
-        this.middleware = client.middleware;
-    }
-    prepareTypeHierarchy(document, position, token) {
-        const client = this.client;
-        const middleware = this.middleware;
-        const prepareTypeHierarchy = (document, position, token) => {
-            const params = client.code2ProtocolConverter.asTextDocumentPositionParams(document, position);
-            return client.sendRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, params, token).then((result) => {
-                if (token.isCancellationRequested) {
-                    return null;
-                }
-                return client.protocol2CodeConverter.asTypeHierarchyItems(result, token);
-            }, (error) => {
-                return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, token, error, null);
-            });
-        };
-        return middleware.prepareTypeHierarchy
-            ? middleware.prepareTypeHierarchy(document, position, token, prepareTypeHierarchy)
-            : prepareTypeHierarchy(document, position, token);
-    }
-    provideTypeHierarchySupertypes(item, token) {
-        const client = this.client;
-        const middleware = this.middleware;
-        const provideTypeHierarchySupertypes = (item, token) => {
-            const params = {
-                item: client.code2ProtocolConverter.asTypeHierarchyItem(item)
-            };
-            return client.sendRequest(vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type, params, token).then((result) => {
-                if (token.isCancellationRequested) {
-                    return null;
-                }
-                return client.protocol2CodeConverter.asTypeHierarchyItems(result, token);
-            }, (error) => {
-                return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type, token, error, null);
-            });
-        };
-        return middleware.provideTypeHierarchySupertypes
-            ? middleware.provideTypeHierarchySupertypes(item, token, provideTypeHierarchySupertypes)
-            : provideTypeHierarchySupertypes(item, token);
-    }
-    provideTypeHierarchySubtypes(item, token) {
-        const client = this.client;
-        const middleware = this.middleware;
-        const provideTypeHierarchySubtypes = (item, token) => {
-            const params = {
-                item: client.code2ProtocolConverter.asTypeHierarchyItem(item)
-            };
-            return client.sendRequest(vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type, params, token).then((result) => {
-                if (token.isCancellationRequested) {
-                    return null;
-                }
-                return client.protocol2CodeConverter.asTypeHierarchyItems(result, token);
-            }, (error) => {
-                return client.handleFailedRequest(vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type, token, error, null);
-            });
-        };
-        return middleware.provideTypeHierarchySubtypes
-            ? middleware.provideTypeHierarchySubtypes(item, token, provideTypeHierarchySubtypes)
-            : provideTypeHierarchySubtypes(item, token);
-    }
-}
-class TypeHierarchyFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'typeHierarchy');
-        capability.dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const [id, options] = this.getRegistration(documentSelector, capabilities.typeHierarchyProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const client = this._client;
-        const provider = new TypeHierarchyProvider(client);
-        return [vscode_1.languages.registerTypeHierarchyProvider(client.protocol2CodeConverter.asDocumentSelector(options.documentSelector), provider), provider];
-    }
-}
-exports.TypeHierarchyFeature = TypeHierarchyFeature;

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

@@ -1,41 +0,0 @@
-import { CancellationToken } from 'vscode';
-export type ITask<T> = () => T;
-export declare class Delayer<T> {
-    defaultDelay: number;
-    private timeout;
-    private completionPromise;
-    private onSuccess;
-    private task;
-    constructor(defaultDelay: number);
-    trigger(task: ITask<T>, delay?: number): Promise<T>;
-    forceDelivery(): T | undefined;
-    isTriggered(): boolean;
-    cancel(): void;
-    private cancelTimeout;
-}
-export declare class Semaphore<T = void> {
-    private _capacity;
-    private _active;
-    private _waiting;
-    constructor(capacity?: number);
-    lock(thunk: () => T | PromiseLike<T>): Promise<T>;
-    get active(): number;
-    private runNext;
-    private doRunNext;
-}
-export declare function setTestMode(): void;
-export declare function clearTestMode(): void;
-export type YieldOptions = {
-    /**
-     * The time in ms after which the function should yield.
-     * The minimum yield time is 15ms
-     */
-    yieldAfter?: number;
-    /**
-     * An optional callback that is invoke when the code yields.
-     */
-    yieldCallback?: () => void;
-};
-export declare function map<P, C>(items: ReadonlyArray<P>, func: (item: P) => C, token?: CancellationToken, options?: YieldOptions): Promise<C[]>;
-export declare function mapAsync<P, C>(items: ReadonlyArray<P>, func: (item: P, token?: CancellationToken) => Promise<C>, token?: CancellationToken, options?: YieldOptions): Promise<C[]>;
-export declare function forEach<P>(items: ReadonlyArray<P>, func: (item: P) => void, token?: CancellationToken, options?: YieldOptions): Promise<void>;