css-variable-lsp 1.0.0 → 1.0.2

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

@@ -1,182 +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.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/client/node_modules/vscode-languageclient/lib/common/hover.d.ts

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

@@ -1,58 +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.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/client/node_modules/vscode-languageclient/lib/common/implementation.d.ts

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

@@ -1,54 +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.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/client/node_modules/vscode-languageclient/lib/common/inlayHint.d.ts

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

@@ -1,92 +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.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/client/node_modules/vscode-languageclient/lib/common/inlineCompletion.d.ts

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

@@ -1,54 +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.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/client/node_modules/vscode-languageclient/lib/common/inlineValue.d.ts

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

@@ -1,65 +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.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/client/node_modules/vscode-languageclient/lib/common/linkedEditingRange.d.ts

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