naider 1.7.0

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+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>;