naider 1.7.0

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

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

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

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

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

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

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

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

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

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