css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,23 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, EventEmitter, CodeLensProvider, CodeLens as VCodeLens } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, CodeLensOptions, CodeLensRegistrationOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideCodeLensesSignature {
-    (this: void, document: TextDocument, token: CancellationToken): ProviderResult<VCodeLens[]>;
-}
-export interface ResolveCodeLensSignature {
-    (this: void, codeLens: VCodeLens, token: CancellationToken): ProviderResult<VCodeLens>;
-}
-export interface CodeLensMiddleware {
-    provideCodeLenses?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideCodeLensesSignature) => ProviderResult<VCodeLens[]>;
-    resolveCodeLens?: (this: void, codeLens: VCodeLens, token: CancellationToken, next: ResolveCodeLensSignature) => ProviderResult<VCodeLens>;
-}
-export type CodeLensProviderShape = {
-    provider?: CodeLensProvider;
-    onDidChangeCodeLensEmitter: EventEmitter<void>;
-};
-export declare class CodeLensFeature extends TextDocumentLanguageFeature<CodeLensOptions, CodeLensRegistrationOptions, CodeLensProviderShape, CodeLensMiddleware> {
-    constructor(client: FeatureClient<CodeLensMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: CodeLensRegistrationOptions): [Disposable, CodeLensProviderShape];
-}

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

@@ -1,78 +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.CodeLensFeature = 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");
-class CodeLensFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.CodeLensRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'codeLens').dynamicRegistration = true;
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'codeLens').refreshSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const client = this._client;
-        client.onRequest(vscode_languageserver_protocol_1.CodeLensRefreshRequest.type, async () => {
-            for (const provider of this.getAllProviders()) {
-                provider.onDidChangeCodeLensEmitter.fire();
-            }
-        });
-        const options = this.getRegistrationOptions(documentSelector, capabilities.codeLensProvider);
-        if (!options) {
-            return;
-        }
-        this.register({ id: UUID.generateUuid(), registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const eventEmitter = new vscode_1.EventEmitter();
-        const provider = {
-            onDidChangeCodeLenses: eventEmitter.event,
-            provideCodeLenses: (document, token) => {
-                const client = this._client;
-                const provideCodeLenses = (document, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, client.code2ProtocolConverter.asCodeLensParams(document), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asCodeLenses(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideCodeLenses
-                    ? middleware.provideCodeLenses(document, token, provideCodeLenses)
-                    : provideCodeLenses(document, token);
-            },
-            resolveCodeLens: (options.resolveProvider)
-                ? (codeLens, token) => {
-                    const client = this._client;
-                    const resolveCodeLens = (codeLens, token) => {
-                        return client.sendRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, client.code2ProtocolConverter.asCodeLens(codeLens), token).then((result) => {
-                            if (token.isCancellationRequested) {
-                                return codeLens;
-                            }
-                            return client.protocol2CodeConverter.asCodeLens(result);
-                        }, (error) => {
-                            return client.handleFailedRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, token, error, codeLens);
-                        });
-                    };
-                    const middleware = client.middleware;
-                    return middleware.resolveCodeLens
-                        ? middleware.resolveCodeLens(codeLens, token, resolveCodeLens)
-                        : resolveCodeLens(codeLens, token);
-                }
-                : undefined
-        };
-        return [vscode_1.languages.registerCodeLensProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), { provider, onDidChangeCodeLensEmitter: eventEmitter }];
-    }
-}
-exports.CodeLensFeature = CodeLensFeature;

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

@@ -1,25 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Range as VRange, Color as VColor, ColorPresentation as VColorPresentation, ColorInformation as VColorInformation, DocumentColorProvider } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, DocumentColorRegistrationOptions, DocumentColorOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideDocumentColorsSignature {
-    (document: TextDocument, token: CancellationToken): ProviderResult<VColorInformation[]>;
-}
-export interface ProvideColorPresentationSignature {
-    (color: VColor, context: {
-        document: TextDocument;
-        range: VRange;
-    }, token: CancellationToken): ProviderResult<VColorPresentation[]>;
-}
-export interface ColorProviderMiddleware {
-    provideDocumentColors?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideDocumentColorsSignature) => ProviderResult<VColorInformation[]>;
-    provideColorPresentations?: (this: void, color: VColor, context: {
-        document: TextDocument;
-        range: VRange;
-    }, token: CancellationToken, next: ProvideColorPresentationSignature) => ProviderResult<VColorPresentation[]>;
-}
-export declare class ColorProviderFeature extends TextDocumentLanguageFeature<boolean | DocumentColorOptions, DocumentColorRegistrationOptions, DocumentColorProvider, ColorProviderMiddleware> {
-    constructor(client: FeatureClient<ColorProviderMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: DocumentColorRegistrationOptions): [Disposable, DocumentColorProvider];
-}

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

@@ -1,74 +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.ColorProviderFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class ColorProviderFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.DocumentColorRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'colorProvider').dynamicRegistration = true;
-    }
-    initialize(capabilities, documentSelector) {
-        let [id, options] = this.getRegistration(documentSelector, capabilities.colorProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideColorPresentations: (color, context, token) => {
-                const client = this._client;
-                const provideColorPresentations = (color, context, token) => {
-                    const requestParams = {
-                        color,
-                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(context.document),
-                        range: client.code2ProtocolConverter.asRange(context.range)
-                    };
-                    return client.sendRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, requestParams, token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return this._client.protocol2CodeConverter.asColorPresentations(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideColorPresentations
-                    ? middleware.provideColorPresentations(color, context, token, provideColorPresentations)
-                    : provideColorPresentations(color, context, token);
-            },
-            provideDocumentColors: (document, token) => {
-                const client = this._client;
-                const provideDocumentColors = (document, token) => {
-                    const requestParams = {
-                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
-                    };
-                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, requestParams, token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return this._client.protocol2CodeConverter.asColorInformations(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideDocumentColors
-                    ? middleware.provideDocumentColors(document, token, provideDocumentColors)
-                    : provideDocumentColors(document, token);
-            }
-        };
-        return [vscode_1.languages.registerColorProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
-    }
-}
-exports.ColorProviderFeature = ColorProviderFeature;

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

@@ -1,20 +0,0 @@
-import { TextDocument, Disposable, Position as VPosition, CompletionContext as VCompletionContext, CancellationToken, ProviderResult, CompletionItem as VCompletionItem, CompletionList as VCompletionList, CompletionItemProvider } from 'vscode';
-import { ClientCapabilities, CompletionOptions, CompletionRegistrationOptions, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol';
-import { FeatureClient, TextDocumentLanguageFeature } from './features';
-export interface ProvideCompletionItemsSignature {
-    (this: void, document: TextDocument, position: VPosition, context: VCompletionContext, token: CancellationToken): ProviderResult<VCompletionItem[] | VCompletionList>;
-}
-export interface ResolveCompletionItemSignature {
-    (this: void, item: VCompletionItem, token: CancellationToken): ProviderResult<VCompletionItem>;
-}
-export interface CompletionMiddleware {
-    provideCompletionItem?: (this: void, document: TextDocument, position: VPosition, context: VCompletionContext, token: CancellationToken, next: ProvideCompletionItemsSignature) => ProviderResult<VCompletionItem[] | VCompletionList>;
-    resolveCompletionItem?: (this: void, item: VCompletionItem, token: CancellationToken, next: ResolveCompletionItemSignature) => ProviderResult<VCompletionItem>;
-}
-export declare class CompletionItemFeature extends TextDocumentLanguageFeature<CompletionOptions, CompletionRegistrationOptions, CompletionItemProvider, CompletionMiddleware> {
-    private labelDetailsSupport;
-    constructor(client: FeatureClient<CompletionMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: CompletionRegistrationOptions, id: string): [Disposable, CompletionItemProvider];
-}

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

@@ -1,126 +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.CompletionItemFeature = 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");
-const SupportedCompletionItemKinds = [
-    vscode_languageserver_protocol_1.CompletionItemKind.Text,
-    vscode_languageserver_protocol_1.CompletionItemKind.Method,
-    vscode_languageserver_protocol_1.CompletionItemKind.Function,
-    vscode_languageserver_protocol_1.CompletionItemKind.Constructor,
-    vscode_languageserver_protocol_1.CompletionItemKind.Field,
-    vscode_languageserver_protocol_1.CompletionItemKind.Variable,
-    vscode_languageserver_protocol_1.CompletionItemKind.Class,
-    vscode_languageserver_protocol_1.CompletionItemKind.Interface,
-    vscode_languageserver_protocol_1.CompletionItemKind.Module,
-    vscode_languageserver_protocol_1.CompletionItemKind.Property,
-    vscode_languageserver_protocol_1.CompletionItemKind.Unit,
-    vscode_languageserver_protocol_1.CompletionItemKind.Value,
-    vscode_languageserver_protocol_1.CompletionItemKind.Enum,
-    vscode_languageserver_protocol_1.CompletionItemKind.Keyword,
-    vscode_languageserver_protocol_1.CompletionItemKind.Snippet,
-    vscode_languageserver_protocol_1.CompletionItemKind.Color,
-    vscode_languageserver_protocol_1.CompletionItemKind.File,
-    vscode_languageserver_protocol_1.CompletionItemKind.Reference,
-    vscode_languageserver_protocol_1.CompletionItemKind.Folder,
-    vscode_languageserver_protocol_1.CompletionItemKind.EnumMember,
-    vscode_languageserver_protocol_1.CompletionItemKind.Constant,
-    vscode_languageserver_protocol_1.CompletionItemKind.Struct,
-    vscode_languageserver_protocol_1.CompletionItemKind.Event,
-    vscode_languageserver_protocol_1.CompletionItemKind.Operator,
-    vscode_languageserver_protocol_1.CompletionItemKind.TypeParameter
-];
-class CompletionItemFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.CompletionRequest.type);
-        this.labelDetailsSupport = new Map();
-    }
-    fillClientCapabilities(capabilities) {
-        let completion = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'completion');
-        completion.dynamicRegistration = true;
-        completion.contextSupport = true;
-        completion.completionItem = {
-            snippetSupport: true,
-            commitCharactersSupport: true,
-            documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText],
-            deprecatedSupport: true,
-            preselectSupport: true,
-            tagSupport: { valueSet: [vscode_languageserver_protocol_1.CompletionItemTag.Deprecated] },
-            insertReplaceSupport: true,
-            resolveSupport: {
-                properties: ['documentation', 'detail', 'additionalTextEdits']
-            },
-            insertTextModeSupport: { valueSet: [vscode_languageserver_protocol_1.InsertTextMode.asIs, vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation] },
-            labelDetailsSupport: true
-        };
-        completion.insertTextMode = vscode_languageserver_protocol_1.InsertTextMode.adjustIndentation;
-        completion.completionItemKind = { valueSet: SupportedCompletionItemKinds };
-        completion.completionList = {
-            itemDefaults: [
-                'commitCharacters', 'editRange', 'insertTextFormat', 'insertTextMode', 'data'
-            ]
-        };
-    }
-    initialize(capabilities, documentSelector) {
-        const options = this.getRegistrationOptions(documentSelector, capabilities.completionProvider);
-        if (!options) {
-            return;
-        }
-        this.register({
-            id: UUID.generateUuid(),
-            registerOptions: options
-        });
-    }
-    registerLanguageProvider(options, id) {
-        this.labelDetailsSupport.set(id, !!options.completionItem?.labelDetailsSupport);
-        const triggerCharacters = options.triggerCharacters ?? [];
-        const defaultCommitCharacters = options.allCommitCharacters;
-        const selector = options.documentSelector;
-        const provider = {
-            provideCompletionItems: (document, position, token, context) => {
-                const client = this._client;
-                const middleware = this._client.middleware;
-                const provideCompletionItems = (document, position, context, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.CompletionRequest.type, client.code2ProtocolConverter.asCompletionParams(document, position, context), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asCompletionResult(result, defaultCommitCharacters, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.CompletionRequest.type, token, error, null);
-                    });
-                };
-                return middleware.provideCompletionItem
-                    ? middleware.provideCompletionItem(document, position, context, token, provideCompletionItems)
-                    : provideCompletionItems(document, position, context, token);
-            },
-            resolveCompletionItem: options.resolveProvider
-                ? (item, token) => {
-                    const client = this._client;
-                    const middleware = this._client.middleware;
-                    const resolveCompletionItem = (item, token) => {
-                        return client.sendRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, client.code2ProtocolConverter.asCompletionItem(item, !!this.labelDetailsSupport.get(id)), token).then((result) => {
-                            if (token.isCancellationRequested) {
-                                return null;
-                            }
-                            return client.protocol2CodeConverter.asCompletionItem(result);
-                        }, (error) => {
-                            return client.handleFailedRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, token, error, item);
-                        });
-                    };
-                    return middleware.resolveCompletionItem
-                        ? middleware.resolveCompletionItem(item, token, resolveCompletionItem)
-                        : resolveCompletionItem(item, token);
-                }
-                : undefined
-        };
-        return [vscode_1.languages.registerCompletionItemProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, ...triggerCharacters), provider];
-    }
-}
-exports.CompletionItemFeature = CompletionItemFeature;

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

@@ -1,69 +0,0 @@
-import { FileSystemWatcher as VFileSystemWatcher, WorkspaceFolder as VWorkspaceFolder } from 'vscode';
-import { ClientCapabilities, ConfigurationRequest, DidChangeConfigurationRegistrationOptions, RegistrationType } from 'vscode-languageserver-protocol';
-import { StaticFeature, FeatureClient, FeatureState, DynamicFeature, RegistrationData } from './features';
-export interface ConfigurationMiddleware {
-    configuration?: ConfigurationRequest.MiddlewareSignature;
-}
-interface ConfigurationWorkspaceMiddleware {
-    workspace?: ConfigurationMiddleware;
-}
-/**
- * Configuration pull model. From server to client.
- */
-export declare class ConfigurationFeature implements StaticFeature {
-    private readonly _client;
-    constructor(client: FeatureClient<ConfigurationWorkspaceMiddleware>);
-    getState(): FeatureState;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(): void;
-    private getConfiguration;
-    clear(): void;
-}
-export declare function toJSONObject(obj: any): any;
-export interface DidChangeConfigurationSignature {
-    (this: void, sections: string[] | undefined): Promise<void>;
-}
-export interface DidChangeConfigurationMiddleware {
-    didChangeConfiguration?: (this: void, sections: string[] | undefined, next: DidChangeConfigurationSignature) => Promise<void>;
-}
-interface DidChangeConfigurationWorkspaceMiddleware {
-    workspace?: DidChangeConfigurationMiddleware;
-}
-export type SynchronizeOptions = {
-    /**
-     * The configuration sections to synchronize. Pushing settings from the
-     * client to the server is deprecated in favour of the new pull model
-     * that allows servers to query settings scoped on resources. In this
-     * model the client can only deliver an empty change event since the
-     * actually setting value can vary on the provided resource scope.
-     *
-     * @deprecated Use the new pull model (`workspace/configuration` request)
-     */
-    configurationSection?: string | string[];
-    /**
-     * Asks the client to send file change events to the server. Watchers
-     * operate on workspace folders. The LSP client doesn't support watching
-     * files outside a workspace folder.
-     */
-    fileEvents?: VFileSystemWatcher | VFileSystemWatcher[];
-};
-export type $ConfigurationOptions = {
-    synchronize?: SynchronizeOptions;
-    workspaceFolder?: VWorkspaceFolder;
-};
-export declare class SyncConfigurationFeature implements DynamicFeature<DidChangeConfigurationRegistrationOptions> {
-    private _client;
-    private isCleared;
-    private readonly _listeners;
-    constructor(_client: FeatureClient<DidChangeConfigurationWorkspaceMiddleware, $ConfigurationOptions>);
-    getState(): FeatureState;
-    get registrationType(): RegistrationType<DidChangeConfigurationRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(): void;
-    register(data: RegistrationData<DidChangeConfigurationRegistrationOptions>): void;
-    unregister(id: string): void;
-    clear(): void;
-    private onDidChangeConfiguration;
-    private extractSettingsInformation;
-}
-export {};

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

@@ -1,209 +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.SyncConfigurationFeature = exports.toJSONObject = exports.ConfigurationFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const Is = require("./utils/is");
-const UUID = require("./utils/uuid");
-const features_1 = require("./features");
-/**
- * Configuration pull model. From server to client.
- */
-class ConfigurationFeature {
-    constructor(client) {
-        this._client = client;
-    }
-    getState() {
-        return { kind: 'static' };
-    }
-    fillClientCapabilities(capabilities) {
-        capabilities.workspace = capabilities.workspace || {};
-        capabilities.workspace.configuration = true;
-    }
-    initialize() {
-        let client = this._client;
-        client.onRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, (params, token) => {
-            let configuration = (params) => {
-                let result = [];
-                for (let item of params.items) {
-                    let resource = item.scopeUri !== void 0 && item.scopeUri !== null ? this._client.protocol2CodeConverter.asUri(item.scopeUri) : undefined;
-                    result.push(this.getConfiguration(resource, item.section !== null ? item.section : undefined));
-                }
-                return result;
-            };
-            let middleware = client.middleware.workspace;
-            return middleware && middleware.configuration
-                ? middleware.configuration(params, token, configuration)
-                : configuration(params, token);
-        });
-    }
-    getConfiguration(resource, section) {
-        let result = null;
-        if (section) {
-            let index = section.lastIndexOf('.');
-            if (index === -1) {
-                result = toJSONObject(vscode_1.workspace.getConfiguration(undefined, resource).get(section));
-            }
-            else {
-                let config = vscode_1.workspace.getConfiguration(section.substr(0, index), resource);
-                if (config) {
-                    result = toJSONObject(config.get(section.substr(index + 1)));
-                }
-            }
-        }
-        else {
-            let config = vscode_1.workspace.getConfiguration(undefined, resource);
-            result = {};
-            for (let key of Object.keys(config)) {
-                if (config.has(key)) {
-                    result[key] = toJSONObject(config.get(key));
-                }
-            }
-        }
-        if (result === undefined) {
-            result = null;
-        }
-        return result;
-    }
-    clear() {
-    }
-}
-exports.ConfigurationFeature = ConfigurationFeature;
-function toJSONObject(obj) {
-    if (obj) {
-        if (Array.isArray(obj)) {
-            return obj.map(toJSONObject);
-        }
-        else if (typeof obj === 'object') {
-            const res = Object.create(null);
-            for (const key in obj) {
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    res[key] = toJSONObject(obj[key]);
-                }
-            }
-            return res;
-        }
-    }
-    return obj;
-}
-exports.toJSONObject = toJSONObject;
-class SyncConfigurationFeature {
-    constructor(_client) {
-        this._client = _client;
-        this.isCleared = false;
-        this._listeners = new Map();
-    }
-    getState() {
-        return { kind: 'workspace', id: this.registrationType.method, registrations: this._listeners.size > 0 };
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type;
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'didChangeConfiguration').dynamicRegistration = true;
-    }
-    initialize() {
-        this.isCleared = false;
-        let section = this._client.clientOptions.synchronize?.configurationSection;
-        if (section !== undefined) {
-            this.register({
-                id: UUID.generateUuid(),
-                registerOptions: {
-                    section: section
-                }
-            });
-        }
-    }
-    register(data) {
-        let disposable = vscode_1.workspace.onDidChangeConfiguration((event) => {
-            this.onDidChangeConfiguration(data.registerOptions.section, event);
-        });
-        this._listeners.set(data.id, disposable);
-        if (data.registerOptions.section !== undefined) {
-            this.onDidChangeConfiguration(data.registerOptions.section, undefined);
-        }
-    }
-    unregister(id) {
-        let disposable = this._listeners.get(id);
-        if (disposable) {
-            this._listeners.delete(id);
-            disposable.dispose();
-        }
-    }
-    clear() {
-        for (const disposable of this._listeners.values()) {
-            disposable.dispose();
-        }
-        this._listeners.clear();
-        this.isCleared = true;
-    }
-    onDidChangeConfiguration(configurationSection, event) {
-        if (this.isCleared) {
-            return;
-        }
-        let sections;
-        if (Is.string(configurationSection)) {
-            sections = [configurationSection];
-        }
-        else {
-            sections = configurationSection;
-        }
-        if (sections !== undefined && event !== undefined) {
-            let affected = sections.some((section) => event.affectsConfiguration(section));
-            if (!affected) {
-                return;
-            }
-        }
-        const didChangeConfiguration = async (sections) => {
-            if (sections === undefined) {
-                return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: null });
-            }
-            else {
-                return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: this.extractSettingsInformation(sections) });
-            }
-        };
-        let middleware = this._client.middleware.workspace?.didChangeConfiguration;
-        (middleware ? middleware(sections, didChangeConfiguration) : didChangeConfiguration(sections)).catch((error) => {
-            this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type.method} failed`, error);
-        });
-    }
-    extractSettingsInformation(keys) {
-        function ensurePath(config, path) {
-            let current = config;
-            for (let i = 0; i < path.length - 1; i++) {
-                let obj = current[path[i]];
-                if (!obj) {
-                    obj = Object.create(null);
-                    current[path[i]] = obj;
-                }
-                current = obj;
-            }
-            return current;
-        }
-        let resource = this._client.clientOptions.workspaceFolder
-            ? this._client.clientOptions.workspaceFolder.uri
-            : undefined;
-        let result = Object.create(null);
-        for (let i = 0; i < keys.length; i++) {
-            let key = keys[i];
-            let index = key.indexOf('.');
-            let config = null;
-            if (index >= 0) {
-                config = vscode_1.workspace.getConfiguration(key.substr(0, index), resource).get(key.substr(index + 1));
-            }
-            else {
-                config = vscode_1.workspace.getConfiguration(undefined, resource).get(key);
-            }
-            if (config) {
-                let path = keys[i].split('.');
-                ensurePath(result, path)[path[path.length - 1]] = toJSONObject(config);
-            }
-        }
-        return result;
-    }
-}
-exports.SyncConfigurationFeature = SyncConfigurationFeature;

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

@@ -1,16 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Position as VPosition, Declaration as VDeclaration, DeclarationProvider } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, DeclarationRegistrationOptions, DeclarationOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideDeclarationSignature {
-    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDeclaration>;
-}
-export interface DeclarationMiddleware {
-    provideDeclaration?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDeclarationSignature) => ProviderResult<VDeclaration>;
-}
-export declare class DeclarationFeature extends TextDocumentLanguageFeature<boolean | DeclarationOptions, DeclarationRegistrationOptions, DeclarationProvider, DeclarationMiddleware> {
-    constructor(client: FeatureClient<DeclarationMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: DeclarationRegistrationOptions): [Disposable, DeclarationProvider];
-    private registerProvider;
-}