naider 1.7.0

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

@@ -0,0 +1,182 @@
+"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.DocumentOnTypeFormattingFeature = exports.DocumentRangeFormattingFeature = exports.DocumentFormattingFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const UUID = require("./utils/uuid");
+const features_1 = require("./features");
+var FileFormattingOptions;
+(function (FileFormattingOptions) {
+    function fromConfiguration(document) {
+        const filesConfig = vscode_1.workspace.getConfiguration('files', document);
+        return {
+            trimTrailingWhitespace: filesConfig.get('trimTrailingWhitespace'),
+            trimFinalNewlines: filesConfig.get('trimFinalNewlines'),
+            insertFinalNewline: filesConfig.get('insertFinalNewline'),
+        };
+    }
+    FileFormattingOptions.fromConfiguration = fromConfiguration;
+})(FileFormattingOptions || (FileFormattingOptions = {}));
+class DocumentFormattingFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentFormattingRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'formatting').dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.documentFormattingProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDocumentFormattingEdits: (document, options, token) => {
+                const client = this._client;
+                const provideDocumentFormattingEdits = (document, options, token) => {
+                    const params = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        options: client.code2ProtocolConverter.asFormattingOptions(options, FileFormattingOptions.fromConfiguration(document))
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, params, token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asTextEdits(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDocumentFormattingEdits
+                    ? middleware.provideDocumentFormattingEdits(document, options, token, provideDocumentFormattingEdits)
+                    : provideDocumentFormattingEdits(document, options, token);
+            }
+        };
+        return [vscode_1.languages.registerDocumentFormattingEditProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
+    }
+}
+exports.DocumentFormattingFeature = DocumentFormattingFeature;
+class DocumentRangeFormattingFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'rangeFormatting');
+        capability.dynamicRegistration = true;
+        capability.rangesSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.documentRangeFormattingProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDocumentRangeFormattingEdits: (document, range, options, token) => {
+                const client = this._client;
+                const provideDocumentRangeFormattingEdits = (document, range, options, token) => {
+                    const params = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        range: client.code2ProtocolConverter.asRange(range),
+                        options: client.code2ProtocolConverter.asFormattingOptions(options, FileFormattingOptions.fromConfiguration(document))
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, params, token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asTextEdits(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDocumentRangeFormattingEdits
+                    ? middleware.provideDocumentRangeFormattingEdits(document, range, options, token, provideDocumentRangeFormattingEdits)
+                    : provideDocumentRangeFormattingEdits(document, range, options, token);
+            }
+        };
+        if (options.rangesSupport) {
+            provider.provideDocumentRangesFormattingEdits = (document, ranges, options, token) => {
+                const client = this._client;
+                const provideDocumentRangesFormattingEdits = (document, ranges, options, token) => {
+                    const params = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        ranges: client.code2ProtocolConverter.asRanges(ranges),
+                        options: client.code2ProtocolConverter.asFormattingOptions(options, FileFormattingOptions.fromConfiguration(document))
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentRangesFormattingRequest.type, params, token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asTextEdits(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentRangesFormattingRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDocumentRangesFormattingEdits
+                    ? middleware.provideDocumentRangesFormattingEdits(document, ranges, options, token, provideDocumentRangesFormattingEdits)
+                    : provideDocumentRangesFormattingEdits(document, ranges, options, token);
+            };
+        }
+        return [vscode_1.languages.registerDocumentRangeFormattingEditProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
+    }
+}
+exports.DocumentRangeFormattingFeature = DocumentRangeFormattingFeature;
+class DocumentOnTypeFormattingFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'onTypeFormatting').dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.documentOnTypeFormattingProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideOnTypeFormattingEdits: (document, position, ch, options, token) => {
+                const client = this._client;
+                const provideOnTypeFormattingEdits = (document, position, ch, options, token) => {
+                    let params = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        position: client.code2ProtocolConverter.asPosition(position),
+                        ch: ch,
+                        options: client.code2ProtocolConverter.asFormattingOptions(options, FileFormattingOptions.fromConfiguration(document))
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, params, token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asTextEdits(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideOnTypeFormattingEdits
+                    ? middleware.provideOnTypeFormattingEdits(document, position, ch, options, token, provideOnTypeFormattingEdits)
+                    : provideOnTypeFormattingEdits(document, position, ch, options, token);
+            }
+        };
+        const moreTriggerCharacter = options.moreTriggerCharacter || [];
+        return [vscode_1.languages.registerOnTypeFormattingEditProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, options.firstTriggerCharacter, ...moreTriggerCharacter), provider];
+    }
+}
+exports.DocumentOnTypeFormattingFeature = DocumentOnTypeFormattingFeature;

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

@@ -0,0 +1,16 @@
+import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, HoverProvider, Hover as VHover } from 'vscode';
+import { ClientCapabilities, DocumentSelector, HoverOptions, HoverRegistrationOptions, ServerCapabilities } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature } from './features';
+export interface ProvideHoverSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VHover>;
+}
+export interface HoverMiddleware {
+    provideHover?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideHoverSignature) => ProviderResult<VHover>;
+}
+export declare class HoverFeature extends TextDocumentLanguageFeature<boolean | HoverOptions, HoverRegistrationOptions, HoverProvider, HoverMiddleware> {
+    constructor(client: FeatureClient<HoverMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: HoverRegistrationOptions): [Disposable, HoverProvider];
+    private registerProvider;
+}

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

@@ -0,0 +1,58 @@
+"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.HoverFeature = 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 HoverFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.HoverRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const hoverCapability = ((0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'hover'));
+        hoverCapability.dynamicRegistration = true;
+        hoverCapability.contentFormat = [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText];
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.hoverProvider);
+        if (!options) {
+            return;
+        }
+        this.register({
+            id: UUID.generateUuid(),
+            registerOptions: options
+        });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideHover: (document, position, token) => {
+                const client = this._client;
+                const provideHover = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.HoverRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asHover(result);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.HoverRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideHover
+                    ? middleware.provideHover(document, position, token, provideHover)
+                    : provideHover(document, position, token);
+            }
+        };
+        return [this.registerProvider(selector, provider), provider];
+    }
+    registerProvider(selector, provider) {
+        return vscode_1.languages.registerHoverProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.HoverFeature = HoverFeature;

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

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

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

@@ -0,0 +1,54 @@
+"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.ImplementationFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class ImplementationFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.ImplementationRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let implementationSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'implementation');
+        implementationSupport.dynamicRegistration = true;
+        implementationSupport.linkSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.implementationProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideImplementation: (document, position, token) => {
+                const client = this._client;
+                const provideImplementation = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.ImplementationRequest.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.ImplementationRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideImplementation
+                    ? middleware.provideImplementation(document, position, token, provideImplementation)
+                    : provideImplementation(document, position, token);
+            }
+        };
+        return [this.registerProvider(selector, provider), provider];
+    }
+    registerProvider(selector, provider) {
+        return vscode_1.languages.registerImplementationProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.ImplementationFeature = ImplementationFeature;

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

@@ -0,0 +1,20 @@
+import { Disposable, TextDocument, ProviderResult, Range as VRange, InlayHint as VInlayHint, InlayHintsProvider, EventEmitter } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, InlayHintOptions, InlayHintRegistrationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentLanguageFeature, FeatureClient } from './features';
+export type ProvideInlayHintsSignature = (this: void, document: TextDocument, viewPort: VRange, token: CancellationToken) => ProviderResult<VInlayHint[]>;
+export type ResolveInlayHintSignature = (this: void, item: VInlayHint, token: CancellationToken) => ProviderResult<VInlayHint>;
+export type InlayHintsMiddleware = {
+    provideInlayHints?: (this: void, document: TextDocument, viewPort: VRange, token: CancellationToken, next: ProvideInlayHintsSignature) => ProviderResult<VInlayHint[]>;
+    resolveInlayHint?: (this: void, item: VInlayHint, token: CancellationToken, next: ResolveInlayHintSignature) => ProviderResult<VInlayHint>;
+};
+export type InlayHintsProviderShape = {
+    provider: InlayHintsProvider;
+    onDidChangeInlayHints: EventEmitter<void>;
+};
+export declare class InlayHintsFeature extends TextDocumentLanguageFeature<boolean | InlayHintOptions, InlayHintRegistrationOptions, InlayHintsProviderShape, InlayHintsMiddleware> {
+    constructor(client: FeatureClient<InlayHintsMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: InlayHintRegistrationOptions): [Disposable, InlayHintsProviderShape];
+    private registerProvider;
+}

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

@@ -0,0 +1,92 @@
+"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.InlayHintsFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class InlayHintsFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.InlayHintRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const inlayHint = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'inlayHint');
+        inlayHint.dynamicRegistration = true;
+        inlayHint.resolveSupport = {
+            properties: ['tooltip', 'textEdits', 'label.tooltip', 'label.location', 'label.command']
+        };
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'inlayHint').refreshSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        this._client.onRequest(vscode_languageserver_protocol_1.InlayHintRefreshRequest.type, async () => {
+            for (const provider of this.getAllProviders()) {
+                provider.onDidChangeInlayHints.fire();
+            }
+        });
+        const [id, options] = this.getRegistration(documentSelector, capabilities.inlayHintProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const eventEmitter = new vscode_1.EventEmitter();
+        const provider = {
+            onDidChangeInlayHints: eventEmitter.event,
+            provideInlayHints: (document, viewPort, token) => {
+                const client = this._client;
+                const provideInlayHints = async (document, viewPort, token) => {
+                    const requestParams = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        range: client.code2ProtocolConverter.asRange(viewPort)
+                    };
+                    try {
+                        const values = await client.sendRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, requestParams, token);
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asInlayHints(values, token);
+                    }
+                    catch (error) {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, token, error, null);
+                    }
+                };
+                const middleware = client.middleware;
+                return middleware.provideInlayHints
+                    ? middleware.provideInlayHints(document, viewPort, token, provideInlayHints)
+                    : provideInlayHints(document, viewPort, token);
+            }
+        };
+        provider.resolveInlayHint = options.resolveProvider === true
+            ? (hint, token) => {
+                const client = this._client;
+                const resolveInlayHint = async (item, token) => {
+                    try {
+                        const value = await client.sendRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, client.code2ProtocolConverter.asInlayHint(item), token);
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        const result = client.protocol2CodeConverter.asInlayHint(value, token);
+                        return token.isCancellationRequested ? null : result;
+                    }
+                    catch (error) {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, token, error, null);
+                    }
+                };
+                const middleware = client.middleware;
+                return middleware.resolveInlayHint
+                    ? middleware.resolveInlayHint(hint, token, resolveInlayHint)
+                    : resolveInlayHint(hint, token);
+            }
+            : undefined;
+        return [this.registerProvider(selector, provider), { provider: provider, onDidChangeInlayHints: eventEmitter }];
+    }
+    registerProvider(selector, provider) {
+        return vscode_1.languages.registerInlayHintsProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.InlayHintsFeature = InlayHintsFeature;

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

@@ -0,0 +1,18 @@
+import { TextDocument, Disposable, Position as VPosition, InlineCompletionContext as VInlineCompletionContext, CancellationToken, ProviderResult, InlineCompletionItem as VInlineCompletionItem, InlineCompletionList as VInlineCompletionList, InlineCompletionItemProvider } from 'vscode';
+import { ClientCapabilities, InlineCompletionOptions, InlineCompletionRegistrationOptions, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature } from './features';
+export interface ProvideInlineCompletionItemsSignature {
+    (this: void, document: TextDocument, position: VPosition, context: VInlineCompletionContext, token: CancellationToken): ProviderResult<VInlineCompletionItem[] | VInlineCompletionList>;
+}
+export interface InlineCompletionMiddleware {
+    provideInlineCompletionItems?: (this: void, document: TextDocument, position: VPosition, context: VInlineCompletionContext, token: CancellationToken, next: ProvideInlineCompletionItemsSignature) => ProviderResult<VInlineCompletionItem[] | VInlineCompletionList>;
+}
+export type InlineCompletionProviderShape = {
+    provider: InlineCompletionItemProvider;
+};
+export declare class InlineCompletionItemFeature extends TextDocumentLanguageFeature<boolean | InlineCompletionOptions, InlineCompletionRegistrationOptions, InlineCompletionItemProvider, InlineCompletionMiddleware> {
+    constructor(client: FeatureClient<InlineCompletionMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: InlineCompletionRegistrationOptions): [Disposable, InlineCompletionItemProvider];
+}

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

@@ -0,0 +1,54 @@
+"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.InlineCompletionItemFeature = 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 InlineCompletionItemFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.InlineCompletionRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let inlineCompletion = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'inlineCompletion');
+        inlineCompletion.dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.inlineCompletionProvider);
+        if (!options) {
+            return;
+        }
+        this.register({
+            id: UUID.generateUuid(),
+            registerOptions: options
+        });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideInlineCompletionItems: (document, position, context, token) => {
+                const client = this._client;
+                const middleware = this._client.middleware;
+                const provideInlineCompletionItems = (document, position, context, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, client.code2ProtocolConverter.asInlineCompletionParams(document, position, context), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asInlineCompletionResult(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, token, error, null);
+                    });
+                };
+                return middleware.provideInlineCompletionItems
+                    ? middleware.provideInlineCompletionItems(document, position, context, token, provideInlineCompletionItems)
+                    : provideInlineCompletionItems(document, position, context, token);
+            }
+        };
+        return [vscode_1.languages.registerInlineCompletionItemProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
+    }
+}
+exports.InlineCompletionItemFeature = InlineCompletionItemFeature;

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

@@ -0,0 +1,18 @@
+import { Disposable, TextDocument, ProviderResult, Range as VRange, InlineValueContext as VInlineValueContext, InlineValue as VInlineValue, InlineValuesProvider, EventEmitter } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, InlineValueOptions, InlineValueRegistrationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentLanguageFeature, FeatureClient } from './features';
+export type ProvideInlineValuesSignature = (this: void, document: TextDocument, viewPort: VRange, context: VInlineValueContext, token: CancellationToken) => ProviderResult<VInlineValue[]>;
+export type InlineValueMiddleware = {
+    provideInlineValues?: (this: void, document: TextDocument, viewPort: VRange, context: VInlineValueContext, token: CancellationToken, next: ProvideInlineValuesSignature) => ProviderResult<VInlineValue[]>;
+};
+export type InlineValueProviderShape = {
+    provider: InlineValuesProvider;
+    onDidChangeInlineValues: EventEmitter<void>;
+};
+export declare class InlineValueFeature extends TextDocumentLanguageFeature<boolean | InlineValueOptions, InlineValueRegistrationOptions, InlineValueProviderShape, InlineValueMiddleware> {
+    constructor(client: FeatureClient<InlineValueMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: InlineValueRegistrationOptions): [Disposable, InlineValueProviderShape];
+    private registerProvider;
+}

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

@@ -0,0 +1,65 @@
+"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.InlineValueFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class InlineValueFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.InlineValueRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'inlineValue').dynamicRegistration = true;
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'inlineValue').refreshSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        this._client.onRequest(vscode_languageserver_protocol_1.InlineValueRefreshRequest.type, async () => {
+            for (const provider of this.getAllProviders()) {
+                provider.onDidChangeInlineValues.fire();
+            }
+        });
+        const [id, options] = this.getRegistration(documentSelector, capabilities.inlineValueProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const eventEmitter = new vscode_1.EventEmitter();
+        const provider = {
+            onDidChangeInlineValues: eventEmitter.event,
+            provideInlineValues: (document, viewPort, context, token) => {
+                const client = this._client;
+                const provideInlineValues = (document, viewPort, context, token) => {
+                    const requestParams = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                        range: client.code2ProtocolConverter.asRange(viewPort),
+                        context: client.code2ProtocolConverter.asInlineValueContext(context)
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, requestParams, token).then((values) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asInlineValues(values, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideInlineValues
+                    ? middleware.provideInlineValues(document, viewPort, context, token, provideInlineValues)
+                    : provideInlineValues(document, viewPort, context, token);
+            }
+        };
+        return [this.registerProvider(selector, provider), { provider: provider, onDidChangeInlineValues: eventEmitter }];
+    }
+    registerProvider(selector, provider) {
+        return vscode_1.languages.registerInlineValuesProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.InlineValueFeature = InlineValueFeature;

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

@@ -0,0 +1,21 @@
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+import { TextDocumentLanguageFeature, FeatureClient } from './features';
+export interface ProvideLinkedEditingRangeSignature {
+    (this: void, document: code.TextDocument, position: code.Position, token: code.CancellationToken): code.ProviderResult<code.LinkedEditingRanges>;
+}
+/**
+ * Linked editing middleware
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeMiddleware {
+    provideLinkedEditingRange?: (this: void, document: code.TextDocument, position: code.Position, token: code.CancellationToken, next: ProvideLinkedEditingRangeSignature) => code.ProviderResult<code.LinkedEditingRanges>;
+}
+export declare class LinkedEditingFeature extends TextDocumentLanguageFeature<boolean | proto.LinkedEditingRangeOptions, proto.LinkedEditingRangeRegistrationOptions, code.LinkedEditingRangeProvider, LinkedEditingRangeMiddleware> {
+    constructor(client: FeatureClient<LinkedEditingRangeMiddleware>);
+    fillClientCapabilities(capabilities: proto.ClientCapabilities): void;
+    initialize(capabilities: proto.ServerCapabilities, documentSelector: proto.DocumentSelector): void;
+    protected registerLanguageProvider(options: proto.LinkedEditingRangeRegistrationOptions): [code.Disposable, code.LinkedEditingRangeProvider];
+    private registerProvider;
+}