naider 1.7.0

package/vscode-naide/node_modules/vscode-languageclient/lib/common/utils/async.js

@@ -0,0 +1,276 @@
+"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.forEach = exports.mapAsync = exports.map = exports.clearTestMode = exports.setTestMode = exports.Semaphore = exports.Delayer = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+class Delayer {
+    constructor(defaultDelay) {
+        this.defaultDelay = defaultDelay;
+        this.timeout = undefined;
+        this.completionPromise = undefined;
+        this.onSuccess = undefined;
+        this.task = undefined;
+    }
+    trigger(task, delay = this.defaultDelay) {
+        this.task = task;
+        if (delay >= 0) {
+            this.cancelTimeout();
+        }
+        if (!this.completionPromise) {
+            this.completionPromise = new Promise((resolve) => {
+                this.onSuccess = resolve;
+            }).then(() => {
+                this.completionPromise = undefined;
+                this.onSuccess = undefined;
+                var result = this.task();
+                this.task = undefined;
+                return result;
+            });
+        }
+        if (delay >= 0 || this.timeout === void 0) {
+            this.timeout = (0, vscode_languageserver_protocol_1.RAL)().timer.setTimeout(() => {
+                this.timeout = undefined;
+                this.onSuccess(undefined);
+            }, delay >= 0 ? delay : this.defaultDelay);
+        }
+        return this.completionPromise;
+    }
+    forceDelivery() {
+        if (!this.completionPromise) {
+            return undefined;
+        }
+        this.cancelTimeout();
+        let result = this.task();
+        this.completionPromise = undefined;
+        this.onSuccess = undefined;
+        this.task = undefined;
+        return result;
+    }
+    isTriggered() {
+        return this.timeout !== undefined;
+    }
+    cancel() {
+        this.cancelTimeout();
+        this.completionPromise = undefined;
+    }
+    cancelTimeout() {
+        if (this.timeout !== undefined) {
+            this.timeout.dispose();
+            this.timeout = undefined;
+        }
+    }
+}
+exports.Delayer = Delayer;
+class Semaphore {
+    constructor(capacity = 1) {
+        if (capacity <= 0) {
+            throw new Error('Capacity must be greater than 0');
+        }
+        this._capacity = capacity;
+        this._active = 0;
+        this._waiting = [];
+    }
+    lock(thunk) {
+        return new Promise((resolve, reject) => {
+            this._waiting.push({ thunk, resolve, reject });
+            this.runNext();
+        });
+    }
+    get active() {
+        return this._active;
+    }
+    runNext() {
+        if (this._waiting.length === 0 || this._active === this._capacity) {
+            return;
+        }
+        (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => this.doRunNext());
+    }
+    doRunNext() {
+        if (this._waiting.length === 0 || this._active === this._capacity) {
+            return;
+        }
+        const next = this._waiting.shift();
+        this._active++;
+        if (this._active > this._capacity) {
+            throw new Error(`To many thunks active`);
+        }
+        try {
+            const result = next.thunk();
+            if (result instanceof Promise) {
+                result.then((value) => {
+                    this._active--;
+                    next.resolve(value);
+                    this.runNext();
+                }, (err) => {
+                    this._active--;
+                    next.reject(err);
+                    this.runNext();
+                });
+            }
+            else {
+                this._active--;
+                next.resolve(result);
+                this.runNext();
+            }
+        }
+        catch (err) {
+            this._active--;
+            next.reject(err);
+            this.runNext();
+        }
+    }
+}
+exports.Semaphore = Semaphore;
+let $test = false;
+function setTestMode() {
+    $test = true;
+}
+exports.setTestMode = setTestMode;
+function clearTestMode() {
+    $test = false;
+}
+exports.clearTestMode = clearTestMode;
+const defaultYieldTimeout = 15 /*ms*/;
+class Timer {
+    constructor(yieldAfter = defaultYieldTimeout) {
+        this.yieldAfter = $test === true ? Math.max(yieldAfter, 2) : Math.max(yieldAfter, defaultYieldTimeout);
+        this.startTime = Date.now();
+        this.counter = 0;
+        this.total = 0;
+        // start with a counter interval of 1.
+        this.counterInterval = 1;
+    }
+    start() {
+        this.counter = 0;
+        this.total = 0;
+        this.counterInterval = 1;
+        this.startTime = Date.now();
+    }
+    shouldYield() {
+        if (++this.counter >= this.counterInterval) {
+            const timeTaken = Date.now() - this.startTime;
+            const timeLeft = Math.max(0, this.yieldAfter - timeTaken);
+            this.total += this.counter;
+            this.counter = 0;
+            if (timeTaken >= this.yieldAfter || timeLeft <= 1) {
+                // Yield also if time left <= 1 since we compute the counter
+                // for max < 2 ms.
+                // Start with interval 1 again. We could do some calculation
+                // with using 80% of the last counter however other things (GC)
+                // affect the timing heavily since we have small timings (1 - 15ms).
+                this.counterInterval = 1;
+                this.total = 0;
+                return true;
+            }
+            else {
+                // Only increase the counter until we have spent <= 2 ms. Increasing
+                // the counter further is very fragile since timing is influenced
+                // by other things and can increase the counter too much. This will result
+                // that we yield in average after [14 - 16]ms.
+                switch (timeTaken) {
+                    case 0:
+                    case 1:
+                        this.counterInterval = this.total * 2;
+                        break;
+                }
+            }
+        }
+        return false;
+    }
+}
+async function map(items, func, token, options) {
+    if (items.length === 0) {
+        return [];
+    }
+    const result = new Array(items.length);
+    const timer = new Timer(options?.yieldAfter);
+    function convertBatch(start) {
+        timer.start();
+        for (let i = start; i < items.length; i++) {
+            result[i] = func(items[i]);
+            if (timer.shouldYield()) {
+                options?.yieldCallback && options.yieldCallback();
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+    // Convert the first batch sync on the same frame.
+    let index = convertBatch(0);
+    while (index !== -1) {
+        if (token !== undefined && token.isCancellationRequested) {
+            break;
+        }
+        index = await new Promise((resolve) => {
+            (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
+                resolve(convertBatch(index));
+            });
+        });
+    }
+    return result;
+}
+exports.map = map;
+async function mapAsync(items, func, token, options) {
+    if (items.length === 0) {
+        return [];
+    }
+    const result = new Array(items.length);
+    const timer = new Timer(options?.yieldAfter);
+    async function convertBatch(start) {
+        timer.start();
+        for (let i = start; i < items.length; i++) {
+            result[i] = await func(items[i], token);
+            if (timer.shouldYield()) {
+                options?.yieldCallback && options.yieldCallback();
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+    let index = await convertBatch(0);
+    while (index !== -1) {
+        if (token !== undefined && token.isCancellationRequested) {
+            break;
+        }
+        index = await new Promise((resolve) => {
+            (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
+                resolve(convertBatch(index));
+            });
+        });
+    }
+    return result;
+}
+exports.mapAsync = mapAsync;
+async function forEach(items, func, token, options) {
+    if (items.length === 0) {
+        return;
+    }
+    const timer = new Timer(options?.yieldAfter);
+    function runBatch(start) {
+        timer.start();
+        for (let i = start; i < items.length; i++) {
+            func(items[i]);
+            if (timer.shouldYield()) {
+                options?.yieldCallback && options.yieldCallback();
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+    // Convert the first batch sync on the same frame.
+    let index = runBatch(0);
+    while (index !== -1) {
+        if (token !== undefined && token.isCancellationRequested) {
+            break;
+        }
+        index = await new Promise((resolve) => {
+            (0, vscode_languageserver_protocol_1.RAL)().timer.setImmediate(() => {
+                resolve(runBatch(index));
+            });
+        });
+    }
+}
+exports.forEach = forEach;

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

@@ -0,0 +1,12 @@
+export declare function boolean(value: any): value is boolean;
+export declare function string(value: any): value is string;
+export declare function number(value: any): value is number;
+export declare function error(value: any): value is Error;
+export declare function func(value: any): value is Function;
+export declare function array<T>(value: any): value is T[];
+export declare function stringArray(value: any): value is string[];
+export declare function typedArray<T>(value: any, check: (value: any) => boolean): value is T[];
+export declare function thenable<T>(value: any): value is Thenable<T>;
+export declare function asPromise<T>(value: Promise<T>): Promise<T>;
+export declare function asPromise<T>(value: Thenable<T>): Promise<T>;
+export declare function asPromise<T>(value: T): Promise<T>;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/utils/is.js

@@ -0,0 +1,57 @@
+"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.asPromise = exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
+function boolean(value) {
+    return value === true || value === false;
+}
+exports.boolean = boolean;
+function string(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+exports.string = string;
+function number(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+exports.number = number;
+function error(value) {
+    return value instanceof Error;
+}
+exports.error = error;
+function func(value) {
+    return typeof value === 'function';
+}
+exports.func = func;
+function array(value) {
+    return Array.isArray(value);
+}
+exports.array = array;
+function stringArray(value) {
+    return array(value) && value.every(elem => string(elem));
+}
+exports.stringArray = stringArray;
+function typedArray(value, check) {
+    return Array.isArray(value) && value.every(check);
+}
+exports.typedArray = typedArray;
+function thenable(value) {
+    return value && func(value.then);
+}
+exports.thenable = thenable;
+function asPromise(value) {
+    if (value instanceof Promise) {
+        return value;
+    }
+    else if (thenable(value)) {
+        return new Promise((resolve, reject) => {
+            value.then((resolved) => resolve(resolved), (error) => reject(error));
+        });
+    }
+    else {
+        return Promise.resolve(value);
+    }
+}
+exports.asPromise = asPromise;

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

@@ -0,0 +1,22 @@
+/**
+ * Represents a UUID as defined by rfc4122.
+ */
+export interface UUID {
+    /**
+     * @returns the canonical representation in sets of hexadecimal numbers separated by dashes.
+     */
+    asHex(): string;
+    equals(other: UUID): boolean;
+}
+/**
+ * An empty UUID that contains only zeros.
+ */
+export declare const empty: UUID;
+export declare function v4(): UUID;
+export declare function isUUID(value: string): boolean;
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+export declare function parse(value: string): UUID;
+export declare function generateUuid(): string;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/utils/uuid.js

@@ -0,0 +1,97 @@
+"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.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0;
+class ValueUUID {
+    constructor(_value) {
+        this._value = _value;
+        // empty
+    }
+    asHex() {
+        return this._value;
+    }
+    equals(other) {
+        return this.asHex() === other.asHex();
+    }
+}
+class V4UUID extends ValueUUID {
+    static _oneOf(array) {
+        return array[Math.floor(array.length * Math.random())];
+    }
+    static _randomHex() {
+        return V4UUID._oneOf(V4UUID._chars);
+    }
+    constructor() {
+        super([
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            '4',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._oneOf(V4UUID._timeHighBits),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+        ].join(''));
+    }
+}
+V4UUID._chars = ['0', '1', '2', '3', '4', '5', '6', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+V4UUID._timeHighBits = ['8', '9', 'a', 'b'];
+/**
+ * An empty UUID that contains only zeros.
+ */
+exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000');
+function v4() {
+    return new V4UUID();
+}
+exports.v4 = v4;
+const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+    return _UUIDPattern.test(value);
+}
+exports.isUUID = isUUID;
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+function parse(value) {
+    if (!isUUID(value)) {
+        throw new Error('invalid uuid');
+    }
+    return new ValueUUID(value);
+}
+exports.parse = parse;
+function generateUuid() {
+    return v4().asHex();
+}
+exports.generateUuid = generateUuid;

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

@@ -0,0 +1,30 @@
+import { WorkspaceFolder as VWorkspaceFolder, WorkspaceFoldersChangeEvent as VWorkspaceFoldersChangeEvent } from 'vscode';
+import { DynamicFeature, RegistrationData, FeatureClient, NextSignature, FeatureState } from './features';
+import { ClientCapabilities, InitializeParams, ServerCapabilities, WorkspaceFoldersRequest, RegistrationType } from 'vscode-languageserver-protocol';
+export declare function arrayDiff<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): T[];
+export type WorkspaceFolderMiddleware = {
+    workspaceFolders?: WorkspaceFoldersRequest.MiddlewareSignature;
+    didChangeWorkspaceFolders?: NextSignature<VWorkspaceFoldersChangeEvent, Promise<void>>;
+};
+type WorkspaceFolderWorkspaceMiddleware = {
+    workspace?: WorkspaceFolderMiddleware;
+};
+export declare class WorkspaceFoldersFeature implements DynamicFeature<void> {
+    private readonly _client;
+    private readonly _listeners;
+    private _initialFolders;
+    constructor(client: FeatureClient<WorkspaceFolderWorkspaceMiddleware>);
+    getState(): FeatureState;
+    get registrationType(): RegistrationType<void>;
+    fillInitializeParams(params: InitializeParams): void;
+    protected initializeWithFolders(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities): void;
+    protected sendInitialEvent(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
+    private doSendEvent;
+    register(data: RegistrationData<undefined>): void;
+    unregister(id: string): void;
+    clear(): void;
+    private asProtocol;
+}
+export {};

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

@@ -0,0 +1,148 @@
+"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.WorkspaceFoldersFeature = exports.arrayDiff = void 0;
+const UUID = require("./utils/uuid");
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+function access(target, key) {
+    if (target === undefined || target === null) {
+        return undefined;
+    }
+    return target[key];
+}
+function arrayDiff(left, right) {
+    return left.filter(element => right.indexOf(element) < 0);
+}
+exports.arrayDiff = arrayDiff;
+class WorkspaceFoldersFeature {
+    constructor(client) {
+        this._client = client;
+        this._listeners = new Map();
+    }
+    getState() {
+        return { kind: 'workspace', id: this.registrationType.method, registrations: this._listeners.size > 0 };
+    }
+    get registrationType() {
+        return vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type;
+    }
+    fillInitializeParams(params) {
+        const folders = vscode_1.workspace.workspaceFolders;
+        this.initializeWithFolders(folders);
+        if (folders === void 0) {
+            params.workspaceFolders = null;
+        }
+        else {
+            params.workspaceFolders = folders.map(folder => this.asProtocol(folder));
+        }
+    }
+    initializeWithFolders(currentWorkspaceFolders) {
+        this._initialFolders = currentWorkspaceFolders;
+    }
+    fillClientCapabilities(capabilities) {
+        capabilities.workspace = capabilities.workspace || {};
+        capabilities.workspace.workspaceFolders = true;
+    }
+    initialize(capabilities) {
+        const client = this._client;
+        client.onRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type, (token) => {
+            const workspaceFolders = () => {
+                const folders = vscode_1.workspace.workspaceFolders;
+                if (folders === undefined) {
+                    return null;
+                }
+                const result = folders.map((folder) => {
+                    return this.asProtocol(folder);
+                });
+                return result;
+            };
+            const middleware = client.middleware.workspace;
+            return middleware && middleware.workspaceFolders
+                ? middleware.workspaceFolders(token, workspaceFolders)
+                : workspaceFolders(token);
+        });
+        const value = access(access(access(capabilities, 'workspace'), 'workspaceFolders'), 'changeNotifications');
+        let id;
+        if (typeof value === 'string') {
+            id = value;
+        }
+        else if (value === true) {
+            id = UUID.generateUuid();
+        }
+        if (id) {
+            this.register({ id: id, registerOptions: undefined });
+        }
+    }
+    sendInitialEvent(currentWorkspaceFolders) {
+        let promise;
+        if (this._initialFolders && currentWorkspaceFolders) {
+            const removed = arrayDiff(this._initialFolders, currentWorkspaceFolders);
+            const added = arrayDiff(currentWorkspaceFolders, this._initialFolders);
+            if (added.length > 0 || removed.length > 0) {
+                promise = this.doSendEvent(added, removed);
+            }
+        }
+        else if (this._initialFolders) {
+            promise = this.doSendEvent([], this._initialFolders);
+        }
+        else if (currentWorkspaceFolders) {
+            promise = this.doSendEvent(currentWorkspaceFolders, []);
+        }
+        if (promise !== undefined) {
+            promise.catch((error) => {
+                this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, error);
+            });
+        }
+    }
+    doSendEvent(addedFolders, removedFolders) {
+        let params = {
+            event: {
+                added: addedFolders.map(folder => this.asProtocol(folder)),
+                removed: removedFolders.map(folder => this.asProtocol(folder))
+            }
+        };
+        return this._client.sendNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, params);
+    }
+    register(data) {
+        let id = data.id;
+        let client = this._client;
+        let disposable = vscode_1.workspace.onDidChangeWorkspaceFolders((event) => {
+            let didChangeWorkspaceFolders = (event) => {
+                return this.doSendEvent(event.added, event.removed);
+            };
+            let middleware = client.middleware.workspace;
+            const promise = middleware && middleware.didChangeWorkspaceFolders
+                ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders)
+                : didChangeWorkspaceFolders(event);
+            promise.catch((error) => {
+                this._client.error(`Sending notification ${vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type.method} failed`, error);
+            });
+        });
+        this._listeners.set(id, disposable);
+        this.sendInitialEvent(vscode_1.workspace.workspaceFolders);
+    }
+    unregister(id) {
+        let disposable = this._listeners.get(id);
+        if (disposable === void 0) {
+            return;
+        }
+        this._listeners.delete(id);
+        disposable.dispose();
+    }
+    clear() {
+        for (let disposable of this._listeners.values()) {
+            disposable.dispose();
+        }
+        this._listeners.clear();
+    }
+    asProtocol(workspaceFolder) {
+        if (workspaceFolder === void 0) {
+            return null;
+        }
+        return { uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri), name: workspaceFolder.name };
+    }
+}
+exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;

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

@@ -0,0 +1,19 @@
+import { Disposable, CancellationToken, ProviderResult, SymbolInformation as VSymbolInformation, WorkspaceSymbolProvider } from 'vscode';
+import { ClientCapabilities, ServerCapabilities, WorkspaceSymbolRegistrationOptions } from 'vscode-languageserver-protocol';
+import { FeatureClient, WorkspaceFeature } from './features';
+export interface ProvideWorkspaceSymbolsSignature {
+    (this: void, query: string, token: CancellationToken): ProviderResult<VSymbolInformation[]>;
+}
+export interface ResolveWorkspaceSymbolSignature {
+    (this: void, item: VSymbolInformation, token: CancellationToken): ProviderResult<VSymbolInformation>;
+}
+export interface WorkspaceSymbolMiddleware {
+    provideWorkspaceSymbols?: (this: void, query: string, token: CancellationToken, next: ProvideWorkspaceSymbolsSignature) => ProviderResult<VSymbolInformation[]>;
+    resolveWorkspaceSymbol?: (this: void, item: VSymbolInformation, token: CancellationToken, next: ResolveWorkspaceSymbolSignature) => ProviderResult<VSymbolInformation>;
+}
+export declare class WorkspaceSymbolFeature extends WorkspaceFeature<WorkspaceSymbolRegistrationOptions, WorkspaceSymbolProvider, WorkspaceSymbolMiddleware> {
+    constructor(client: FeatureClient<WorkspaceSymbolMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities): void;
+    protected registerLanguageProvider(options: WorkspaceSymbolRegistrationOptions): [Disposable, WorkspaceSymbolProvider];
+}