monaco-languageclient 1.0.0 → 2.0.0-dev.0

package/src/vscode-api.ts

@@ -1,1047 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) 2018-2022 TypeFox GmbH (http://www.typefox.io). All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-
-import type * as vscode from "vscode";
-import { URI } from "vscode-uri"
-import { Disposable } from "./disposable";
-import {
-    Services, Event, DiagnosticCollection, WorkspaceEdit,
-    MessageType, OutputChannel, CompletionTriggerKind, DocumentIdentifier,
-    SignatureHelpTriggerKind,
-    MessageActionItem
-} from "./services";
-import * as ServicesModule from "./services";
-import { CancellationTokenSource, DiagnosticSeverity, DocumentSelector, Diagnostic as ProtocolDiagnostics } from "vscode-languageserver-protocol";
-
-export function createVSCodeApi(servicesProvider: Services.Provider): typeof vscode {
-    const unsupported = () => { throw new Error('unsupported') };
-    const Uri: typeof vscode.Uri = class VSCodeUri extends URI {
-        static joinPath(uri: URI, ...pathFragment: string[]): URI {
-            return unsupported();
-        }
-    };
-    class CompletionItem implements vscode.CompletionItem {
-        constructor(public label: string, public kind?: vscode.CompletionItemKind) { }
-    }
-    class CodeLens implements vscode.CodeLens {
-        constructor(
-            public range: vscode.Range,
-            public command?: vscode.Command
-        ) { }
-
-        get isResolved(): boolean {
-            return !!this.command;
-        }
-    }
-    class DocumentLink implements vscode.DocumentLink {
-        constructor(public range: vscode.Range, public target?: vscode.Uri) { }
-    }
-    class CodeActionKind implements vscode.CodeActionKind {
-        private static readonly sep = '.';
-
-        static Empty = new CodeActionKind('');
-        static QuickFix = new CodeActionKind('quickfix');
-        static Refactor = new CodeActionKind('refactor');
-        static RefactorExtract = CodeActionKind.Refactor.append('extract');
-        static RefactorInline = CodeActionKind.Refactor.append('inline');
-        static RefactorRewrite = CodeActionKind.Refactor.append('rewrite');
-        static Source = new CodeActionKind('source');
-        static SourceOrganizeImports = CodeActionKind.Source.append('organizeImports');
-        static SourceFixAll = CodeActionKind.Source.append('fixAll');
-        private constructor(readonly value: string) { }
-        public append(parts: string): CodeActionKind {
-            return new CodeActionKind(this.value ? this.value + CodeActionKind.sep + parts : parts);
-        }
-        contains = unsupported
-        intersects = unsupported
-    }
-    class Diagnostic implements vscode.Diagnostic {
-        source?: string;
-        code?: string | number;
-        relatedInformation?: vscode.DiagnosticRelatedInformation[]
-        tags?: vscode.DiagnosticTag[]
-        constructor(readonly range: vscode.Range, readonly message: string, readonly severity: DiagnosticSeverity = DiagnosticSeverity.Error) { }
-    }
-    class CallHierarchyItem implements vscode.CallHierarchyItem {
-        _sessionId?: string;
-        _itemId?: string;
-        constructor(readonly kind: vscode.SymbolKind, readonly name: string, readonly detail: string, readonly uri: vscode.Uri, readonly range: vscode.Range, readonly selectionRange: vscode.Range) { }
-    }
-
-    class TypeHierarchyItem implements vscode.TypeHierarchyItem {
-        _sessionId?: string;
-        _itemId?: string;
-        constructor(readonly kind: vscode.SymbolKind, readonly name: string, readonly detail: string, readonly uri: URI, readonly range: vscode.Range, readonly selectionRange: vscode.Range) { }
-    }
-
-    class SymbolInformation implements vscode.SymbolInformation {
-        location: vscode.Location;
-        tags?: vscode.SymbolTag[];
-        readonly containerName: string
-        constructor(readonly name: string, readonly kind: vscode.SymbolKind, rangeOrContainer: string | undefined | vscode.Range, locationOrUri?: vscode.Location | vscode.Uri, containerName?: string) {
-            this.containerName = containerName!
-            if (typeof rangeOrContainer === 'string') {
-                this.containerName = rangeOrContainer;
-            }
-        }
-    }
-
-    class InlayHint implements vscode.InlayHint {
-        constructor(readonly position: vscode.Position, readonly label: string | vscode.InlayHintLabelPart[], readonly kind?: vscode.InlayHintKind) { }
-    }
-
-    class CancellationError extends Error {
-        constructor() {
-            super('Canceled');
-            this.name = this.message;
-        }
-    }
-
-    class CodeAction implements vscode.CodeAction {
-        edit?: vscode.WorkspaceEdit;
-        diagnostics?: Diagnostic[];
-        command?: vscode.Command;
-        isPreferred?: boolean;
-        disabled?: {
-            readonly reason: string;
-        };
-        constructor(readonly title: string, readonly kind?: CodeActionKind) { }
-    }
-    class SemanticTokens implements vscode.SemanticTokens {
-        constructor(public data: Uint32Array, public resultId: string) { }
-    }
-
-    class EmptyFileSystem implements vscode.FileSystem {
-        isWritableFileSystem(scheme: string): boolean | undefined {
-            return false;
-        }
-        stat(uri: vscode.Uri): Thenable<vscode.FileStat> {
-            throw new Error("Method not implemented.");
-        }
-        readDirectory(uri: vscode.Uri): Thenable<[string, vscode.FileType][]> {
-            return Promise.resolve([]);
-        }
-        createDirectory(uri: vscode.Uri): Thenable<void> {
-            return Promise.resolve();
-        }
-        readFile(uri: vscode.Uri): Thenable<Uint8Array> {
-            return Promise.resolve(new Uint8Array(0));
-        }
-        writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void> {
-            return Promise.resolve();
-        }
-        delete(uri: vscode.Uri,
-            options?: { recursive?: boolean | undefined; useTrash?: boolean | undefined; } | undefined): Thenable<void> {
-            return Promise.resolve();
-        }
-        rename(source: vscode.Uri,
-            target: vscode.Uri,
-            options?: { overwrite?: boolean | undefined; } | undefined): Thenable<void> {
-            return Promise.resolve();
-        }
-
-        copy(source: vscode.Uri,
-            target: vscode.Uri,
-            options?: { overwrite?: boolean | undefined; } | undefined): Thenable<void> {
-            return Promise.resolve();
-        }
-    }
-
-    enum TextDocumentChangeReason {
-        /** The text change is caused by an undo operation. */
-        Undo = 1,
-
-        /** The text change is caused by an redo operation. */
-        Redo = 2,
-    }
-
-    const workspace: typeof vscode.workspace = {
-        fs: new EmptyFileSystem(),
-        workspaceFile: undefined,
-        createFileSystemWatcher(globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents): vscode.FileSystemWatcher {
-            const services = servicesProvider();
-            if (typeof globPattern !== 'string') {
-                throw new Error('unsupported');
-            }
-            if (services.workspace.createFileSystemWatcher) {
-                const watcher = services.workspace.createFileSystemWatcher(globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
-                return Object.assign(watcher, {
-                    ignoreCreateEvents: !!ignoreCreateEvents,
-                    ignoreChangeEvents: !!ignoreChangeEvents,
-                    ignoreDeleteEvents: !!ignoreDeleteEvents,
-                });
-            }
-            return {
-                ignoreCreateEvents: !!ignoreCreateEvents,
-                ignoreChangeEvents: !!ignoreChangeEvents,
-                ignoreDeleteEvents: !!ignoreDeleteEvents,
-                onDidCreate: Event.None,
-                onDidChange: Event.None,
-                onDidDelete: Event.None,
-                dispose: () => { }
-            };
-        },
-        applyEdit: async (edit) => {
-            const services = servicesProvider();
-            if (WorkspaceEdit.is(edit)) {
-                return services.workspace.applyEdit(edit);
-            }
-            throw new Error('unsupported');
-        },
-        getConfiguration(section, resource): vscode.WorkspaceConfiguration {
-            const { workspace } = servicesProvider();
-            const configuration = workspace.configurations ?
-                workspace.configurations.getConfiguration(section, resource ? resource.toString() : undefined) :
-                undefined;
-            const result: vscode.WorkspaceConfiguration = {
-                get: (section: string, defaultValue?: any) => {
-                    return configuration ? configuration.get(section, defaultValue) : defaultValue;
-                },
-                has: (section: string) => {
-                    return configuration ? configuration.has(section) : false;
-                },
-                inspect: unsupported,
-                update: unsupported
-            };
-            return Object.assign(result, {
-                toJSON: () => configuration ? configuration.toJSON() : undefined
-            });
-        },
-        get onDidChangeConfiguration(): typeof vscode.workspace.onDidChangeConfiguration {
-            const services = servicesProvider();
-            if (services.workspace.configurations) {
-                return services.workspace.configurations.onDidChangeConfiguration;
-            }
-            return Event.None;
-        },
-        get workspaceFolders(): typeof vscode.workspace.workspaceFolders {
-            const services = servicesProvider();
-            if ('workspaceFolders' in services.workspace) {
-                return services.workspace.workspaceFolders;
-            }
-            const rootUri = services.workspace.rootUri;
-            if (!rootUri) {
-                return undefined;
-            }
-            const uri = Uri.parse(rootUri);
-            return [{
-                uri,
-                index: 0,
-                name: uri.toString()
-            }];
-        },
-        get onDidChangeWorkspaceFolders(): typeof vscode.workspace.onDidChangeWorkspaceFolders {
-            const services = servicesProvider();
-            return services.workspace.onDidChangeWorkspaceFolders || Event.None;
-        },
-        get textDocuments(): typeof vscode.workspace.textDocuments {
-            const services = servicesProvider();
-            return services.workspace.textDocuments as any;
-        },
-        get onDidOpenTextDocument(): typeof vscode.workspace.onDidOpenTextDocument {
-            const services = servicesProvider();
-            return services.workspace.onDidOpenTextDocument as any;
-        },
-        get onDidCloseTextDocument(): typeof vscode.workspace.onDidCloseTextDocument {
-            const services = servicesProvider();
-            return services.workspace.onDidCloseTextDocument as any;
-        },
-        get onDidChangeTextDocument(): typeof vscode.workspace.onDidChangeTextDocument {
-            const services = servicesProvider();
-            return (listener: (e: vscode.TextDocumentChangeEvent) => any, thisArgs?: any, disposables?: Disposable[]): Disposable => {
-                return services.workspace.onDidChangeTextDocument(({ textDocument, contentChanges, isRedoing, isUndoing }) => {
-                    const l: (e: vscode.TextDocumentChangeEvent) => any = listener.bind(thisArgs);
-                    l({
-                        document: <any>textDocument,
-                        contentChanges: <any>contentChanges,
-                        reason: isUndoing ? TextDocumentChangeReason.Undo : isRedoing ? TextDocumentChangeReason.Redo : undefined
-                    });
-                }, undefined, disposables);
-            };
-        },
-        get onWillSaveTextDocument(): typeof vscode.workspace.onWillSaveTextDocument {
-            const services = servicesProvider();
-            const onWillSaveTextDocument = services.workspace.onWillSaveTextDocument;
-            if (!onWillSaveTextDocument) {
-                return Event.None;
-            }
-            return (listener: (e: vscode.TextDocumentWillSaveEvent) => any, thisArgs?: any, disposables?: Disposable[]): Disposable => {
-                return onWillSaveTextDocument(({ textDocument, reason, waitUntil }) => {
-                    const l: (e: vscode.TextDocumentWillSaveEvent) => any = listener.bind(thisArgs);
-                    l({
-                        document: <any>textDocument,
-                        reason: reason,
-                        waitUntil: (edits: PromiseLike<vscode.TextEdit[]>) => {
-                            if (waitUntil) {
-                                waitUntil(edits);
-                            }
-                        }
-                    });
-                }, undefined, disposables);
-            };
-        },
-        get onDidSaveTextDocument(): typeof vscode.workspace.onDidSaveTextDocument {
-            const services = servicesProvider();
-            return (services.workspace.onDidSaveTextDocument as any) || Event.None;
-        },
-
-        get onWillCreateFiles(): vscode.Event<vscode.FileWillCreateEvent> {
-            return Event.None;
-        },
-
-        get onDidCreateFiles(): vscode.Event<vscode.FileCreateEvent> {
-            return Event.None;
-        },
-
-        get onWillDeleteFiles(): vscode.Event<vscode.FileWillDeleteEvent> {
-            return Event.None;
-        },
-
-        get onDidDeleteFiles(): vscode.Event<vscode.FileDeleteEvent> {
-            return Event.None;
-        },
-
-        get onWillRenameFiles(): vscode.Event<vscode.FileWillRenameEvent> {
-            return Event.None;
-        },
-
-        get onDidRenameFiles(): vscode.Event<vscode.FileRenameEvent> {
-            return Event.None;
-        },
-
-        get onDidGrantWorkspaceTrust(): vscode.Event<void> {
-            return Event.None;
-        },
-
-        getWorkspaceFolder: unsupported,
-        asRelativePath: unsupported,
-        updateWorkspaceFolders: unsupported,
-        findFiles: unsupported,
-        saveAll: unsupported,
-        openTextDocument: unsupported,
-        registerTextDocumentContentProvider: unsupported,
-        registerTaskProvider: unsupported,
-        registerFileSystemProvider: unsupported,
-        openNotebookDocument: unsupported,
-        registerNotebookSerializer: unsupported,
-        notebookDocuments: [],
-        onDidOpenNotebookDocument: unsupported,
-        onDidCloseNotebookDocument: unsupported,
-        isTrusted: true,
-        rootPath: undefined,
-        name: undefined,
-        onDidChangeNotebookDocument: unsupported,
-        onDidSaveNotebookDocument: unsupported
-    };
-
-    function isVsCodeUri(v: vscode.Uri | ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic> | undefined]>): v is vscode.Uri {
-        return (v instanceof URI) !== undefined;
-    }
-
-    class ApiDiagnosticCollection implements vscode.DiagnosticCollection {
-        readonly name: string;
-        private readonly services: Services;
-        private readonly collection: DiagnosticCollection | undefined;
-
-        constructor(name?: string) {
-            this.name = name || 'default',
-                this.services = servicesProvider();
-            this.collection = this.services.languages.createDiagnosticCollection
-                ? this.services.languages.createDiagnosticCollection(name)
-                : undefined;
-        }
-
-        entries() {
-        }
-
-        set(entries: ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic> | undefined]>): void;
-        set(uri: vscode.Uri, arg1: ReadonlyArray<vscode.Diagnostic> | undefined): void;
-        set(arg0: vscode.Uri | ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic> | undefined]>,
-            arg1?: ReadonlyArray<vscode.Diagnostic>): void {
-
-            if (isVsCodeUri(arg0)) {
-                if (this.collection) {
-                    this.collection.set(arg0.toString(), arg1 as unknown as ProtocolDiagnostics[] ?? []);
-                }
-            } else {
-                arg0.forEach(element => {
-                    this.set(element[0], element[1]);
-                });
-            }
-        }
-
-        dispose(): void {
-            if (this.collection) {
-                this.collection.dispose();
-            }
-        }
-
-        delete(uri: vscode.Uri) { }
-        clear() { }
-        forEach(callback: any, thisArg?: any) { }
-        get(uri: vscode.Uri) { return undefined; }
-        has(uri: vscode.Uri) { return false; }
-    }
-
-    const languages: typeof vscode.languages = {
-        match(selector, document): number {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            if (!DocumentIdentifier.is(document)) {
-                throw new Error('unexpected document: ' + JSON.stringify(document));
-            }
-            const services = servicesProvider();
-            const result = services.languages.match(documentSelector, document);
-            return result ? 1 : 0;
-        },
-        registerCallHierarchyProvider(
-            selector: vscode.DocumentSelector,
-            provider: vscode.CallHierarchyProvider): vscode.Disposable {
-
-            /* empty stub for now */
-            return {
-                dispose(): void {
-                }
-            }
-        },
-        createDiagnosticCollection(name?: string): vscode.DiagnosticCollection {
-            return new ApiDiagnosticCollection(name);
-        },
-        registerCompletionItemProvider(selector, provider, ...triggerCharacters) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerCompletionItemProvider) {
-                return Disposable.create(() => { });
-            }
-            const resolveCompletionItem = provider.resolveCompletionItem;
-            return languages.registerCompletionItemProvider(documentSelector, {
-                provideCompletionItems({ textDocument, position, context }, token) {
-                    return provider.provideCompletionItems(<any>textDocument, <any>position, token, {
-                        triggerKind: context?.triggerKind ?? CompletionTriggerKind.Invoked,
-                        triggerCharacter: context?.triggerCharacter
-                    }) as any;
-                },
-                resolveCompletionItem: resolveCompletionItem ? (item, token) => {
-                    return resolveCompletionItem(item as any, token) as any;
-                } : undefined
-            }, ...triggerCharacters);
-        },
-        registerCodeActionsProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerCodeActionsProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerCodeActionsProvider(documentSelector, {
-                provideCodeActions({ textDocument, range, context }, token) {
-                    return provider.provideCodeActions(<any>textDocument, <any>range, <any>context, token) as any;
-                },
-                resolveCodeAction: provider.resolveCodeAction ? (codeAction, token) => {
-                    return provider.resolveCodeAction!(<any>codeAction, <any>token) as any
-                } : undefined
-            });
-        },
-        registerCodeLensProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerCodeLensProvider) {
-                return Disposable.create(() => { });
-            }
-            const resolveCodeLens = provider.resolveCodeLens;
-            return languages.registerCodeLensProvider(documentSelector, {
-                provideCodeLenses({ textDocument }, token) {
-                    return provider.provideCodeLenses(<any>textDocument, token) as any;
-                },
-                resolveCodeLens: resolveCodeLens ? (codeLens, token) => {
-                    return resolveCodeLens(<any>codeLens, token) as any;
-                } : undefined
-            });
-        },
-        registerDefinitionProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDefinitionProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerDefinitionProvider(documentSelector, {
-                provideDefinition({ textDocument, position }, token) {
-                    return provider.provideDefinition(<any>textDocument, <any>position, token) as any;
-                }
-            });
-        },
-        registerImplementationProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerImplementationProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerImplementationProvider(documentSelector, {
-                provideImplementation({ textDocument, position }, token) {
-                    return provider.provideImplementation(<any>textDocument, <any>position, token) as any;
-                }
-            });
-        },
-        registerTypeDefinitionProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerTypeDefinitionProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerTypeDefinitionProvider(documentSelector, {
-                provideTypeDefinition({ textDocument, position }, token) {
-                    return provider.provideTypeDefinition(<any>textDocument, <any>position, token) as any;
-                }
-            });
-        },
-        registerDeclarationProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDeclarationProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerDeclarationProvider(documentSelector, {
-                provideDeclaration({ textDocument, position }, token) {
-                    return provider.provideDeclaration(<any>textDocument, <any>position, token) as any;
-                }
-            })
-        },
-        registerHoverProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (languages.registerHoverProvider) {
-                return languages.registerHoverProvider(documentSelector, {
-                    provideHover({ textDocument, position }, token) {
-                        return provider.provideHover(<any>textDocument, <any>position, token) as any;
-                    }
-                });
-            }
-            return Disposable.create(() => { });
-        },
-        registerDocumentHighlightProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentHighlightProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerDocumentHighlightProvider(documentSelector, {
-                provideDocumentHighlights({ textDocument, position }, token) {
-                    return provider.provideDocumentHighlights(<any>textDocument, <any>position, token) as any;
-                }
-            });
-        },
-        registerDocumentSymbolProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentSymbolProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerDocumentSymbolProvider(documentSelector, {
-                provideDocumentSymbols({ textDocument }, token) {
-                    return provider.provideDocumentSymbols(<any>textDocument, token) as any;
-                }
-            });
-        },
-        registerWorkspaceSymbolProvider(provider) {
-            const { languages } = servicesProvider();
-            if (!languages.registerWorkspaceSymbolProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerWorkspaceSymbolProvider({
-                provideWorkspaceSymbols({ query }, token) {
-                    return provider.provideWorkspaceSymbols(query, token) as any;
-                }
-            });
-        },
-        registerReferenceProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerReferenceProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerReferenceProvider(documentSelector, {
-                provideReferences({ textDocument, position, context }, token) {
-                    return provider.provideReferences(<any>textDocument, <any>position, context, token) as any
-                }
-            });
-        },
-        registerRenameProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerRenameProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerRenameProvider(documentSelector, {
-                provideRenameEdits({ textDocument, position, newName }, token) {
-                    return provider.provideRenameEdits(<any>textDocument, <any>position, newName, token) as any
-                }
-            });
-        },
-        registerDocumentFormattingEditProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentFormattingEditProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerDocumentFormattingEditProvider(documentSelector, {
-                provideDocumentFormattingEdits({ textDocument, options }, token) {
-                    return provider.provideDocumentFormattingEdits(<any>textDocument, <any>options, token) as any
-                }
-            });
-        },
-        registerDocumentRangeFormattingEditProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentRangeFormattingEditProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerDocumentRangeFormattingEditProvider(documentSelector, {
-                provideDocumentRangeFormattingEdits({ textDocument, range, options }, token) {
-                    return provider.provideDocumentRangeFormattingEdits(<any>textDocument, <any>range, <any>options, token) as any
-                }
-            });
-        },
-        registerOnTypeFormattingEditProvider(selector, provider, firstTriggerCharacter, ...moreTriggerCharacter) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerOnTypeFormattingEditProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerOnTypeFormattingEditProvider(documentSelector, {
-                provideOnTypeFormattingEdits({ textDocument, position, ch, options }, token) {
-                    return provider.provideOnTypeFormattingEdits(<any>textDocument, <any>position, ch, <any>options, token) as any
-                }
-            }, firstTriggerCharacter, ...moreTriggerCharacter);
-        },
-        registerSignatureHelpProvider(selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, firstItem?: string | vscode.SignatureHelpProviderMetadata, ...remaining: string[]) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerSignatureHelpProvider) {
-                return Disposable.create(() => { });
-            }
-            let triggerCharacters;
-            let retriggerCharacters;
-            if (typeof firstItem === 'string') {
-                triggerCharacters = [firstItem, ...remaining];
-            } else if (firstItem) {
-                triggerCharacters = firstItem.triggerCharacters;
-                retriggerCharacters = firstItem.retriggerCharacters;
-            }
-            return languages.registerSignatureHelpProvider(documentSelector, {
-                triggerCharacters,
-                retriggerCharacters,
-                provideSignatureHelp({ textDocument, position }, token, context) {
-                    return provider.provideSignatureHelp(<any>textDocument, <any>position, token, <any>context) as any
-                }
-            });
-        },
-        registerDocumentLinkProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentLinkProvider) {
-                return Disposable.create(() => { });
-            }
-            const resolveDocumentLink = provider.resolveDocumentLink;
-            return languages.registerDocumentLinkProvider(documentSelector, {
-                provideDocumentLinks({ textDocument }, token) {
-                    return provider.provideDocumentLinks(<any>textDocument, token) as any
-                },
-                resolveDocumentLink: resolveDocumentLink ? (link, token) => {
-                    return resolveDocumentLink(<any>link, token) as any
-                } : undefined
-            });
-        },
-        registerColorProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerColorProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerColorProvider(documentSelector, {
-                provideDocumentColors({ textDocument }, token) {
-                    return provider.provideDocumentColors(<any>textDocument, token) as any
-                },
-                provideColorPresentations({ textDocument, color, range }, token) {
-                    return provider.provideColorPresentations(color, {
-                        document: <any>textDocument,
-                        range: <any>range
-                    }, token) as any
-                }
-            });
-        },
-        registerFoldingRangeProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerFoldingRangeProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerFoldingRangeProvider(documentSelector, {
-                provideFoldingRanges({ textDocument }, token) {
-                    return provider.provideFoldingRanges(<any>textDocument, {}, token) as any;
-                }
-            });
-        },
-        registerSelectionRangeProvider(selector, provider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerSelectionRangeProvider) {
-                return Disposable.create(() => { });
-            }
-            return languages.registerSelectionRangeProvider(documentSelector, {
-                provideSelectionRanges({ textDocument, positions }, token) {
-                    return provider.provideSelectionRanges(<any>textDocument, <any>positions, token) as any;
-                }
-            });
-        },
-        registerEvaluatableExpressionProvider: unsupported,
-        registerDocumentSemanticTokensProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentSemanticTokensProvider, legend: vscode.SemanticTokensLegend) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentSemanticTokensProvider) {
-                return Disposable.create(() => { });
-            }
-
-            return languages.registerDocumentSemanticTokensProvider(documentSelector, {
-                onDidChange: provider.onDidChangeSemanticTokens,
-                provideDocumentSemanticTokens({ textDocument }, token) {
-                    return provider.provideDocumentSemanticTokens(<any>textDocument, token) as any;
-                },
-                provideDocumentSemanticTokensEdits: provider.provideDocumentSemanticTokensEdits && (({ textDocument, previousResultId }, token) => {
-                    return provider.provideDocumentSemanticTokensEdits!(<any>textDocument, <any>previousResultId, token) as any;
-                })
-            }, legend)
-        },
-        registerDocumentRangeSemanticTokensProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentRangeSemanticTokensProvider, legend: vscode.SemanticTokensLegend) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerDocumentRangeSemanticTokensProvider) {
-                return Disposable.create(() => { });
-            }
-
-            return languages.registerDocumentRangeSemanticTokensProvider(documentSelector, {
-                provideDocumentRangeSemanticTokens({ textDocument, range }, token) {
-                    return provider.provideDocumentRangeSemanticTokens(<any>textDocument, <any>range, token) as any;
-                }
-            }, legend)
-        },
-        registerInlayHintsProvider(selector: vscode.DocumentSelector, provider: vscode.InlayHintsProvider) {
-            const documentSelector = Array.isArray(selector) ? selector : [selector]
-            if (!DocumentSelector.is(documentSelector)) {
-                throw new Error('unexpected selector: ' + JSON.stringify(selector));
-            }
-            const { languages } = servicesProvider();
-            if (!languages.registerInlayHintsProvider) {
-                return Disposable.create(() => { });
-            }
-
-            const resolveInlayHint = provider.resolveInlayHint;
-            return languages.registerInlayHintsProvider(documentSelector, {
-                onDidChangeInlayHints: provider.onDidChangeInlayHints,
-                provideInlayHints({ textDocument, range }, token) {
-                    return provider.provideInlayHints(<any>textDocument, <any>range, token) as any
-                },
-                resolveInlayHint: resolveInlayHint ? (link, token) => {
-                    return resolveInlayHint(<any>link, token) as any
-                } : undefined
-            })
-        },
-        // FIXME: Should be implemented with monaco 0.34
-        registerInlineValuesProvider: unsupported,
-        getLanguages: unsupported,
-        setTextDocumentLanguage: unsupported,
-        getDiagnostics: unsupported,
-        setLanguageConfiguration: unsupported,
-        onDidChangeDiagnostics: unsupported,
-        registerLinkedEditingRangeProvider: unsupported,
-        createLanguageStatusItem: unsupported,
-        registerTypeHierarchyProvider: unsupported
-    };
-    function showMessage(type: MessageType, arg0: any, ...arg1: any[]): Thenable<any> {
-        if (typeof arg0 !== "string") {
-            throw new Error('unexpected message: ' + JSON.stringify(arg0));
-        }
-        const message: string = arg0;
-        if (arg1 !== undefined && !Array.isArray(arg1)) {
-            throw new Error('unexpected actions: ' + JSON.stringify(arg1));
-        }
-        const actions: MessageActionItem[] = arg1 || [];
-        const { window } = servicesProvider();
-        if (!window) {
-            return Promise.resolve(undefined);
-        }
-        return window.showMessage(type, message, ...actions);
-    }
-    const window: typeof vscode.window = {
-        showInformationMessage: showMessage.bind(undefined, MessageType.Info),
-        showWarningMessage: showMessage.bind(undefined, MessageType.Warning),
-        showErrorMessage: showMessage.bind(undefined, MessageType.Error),
-        createOutputChannel(name: string): vscode.OutputChannel {
-            const { window } = servicesProvider();
-            const createOutputChannel = window ? window.createOutputChannel : undefined;
-            const channel: OutputChannel | undefined = createOutputChannel ? createOutputChannel.bind(window)(name) : undefined;
-            return {
-                name,
-                append: channel ? channel.append.bind(channel) : () => { },
-                appendLine: channel ? channel.appendLine.bind(channel) : () => { },
-                clear: unsupported,
-                show: (arg: any) => {
-                    if (arg !== undefined && typeof arg !== 'boolean') {
-                        throw new Error('unexpected preserveFocus argument: ' + JSON.stringify(arg, undefined, 4));
-                    }
-                    return channel ? channel.show(arg) : () => { };
-                },
-                hide: unsupported,
-                replace: unsupported,
-                dispose: channel ? channel.dispose.bind(channel) : () => { }
-            };
-        },
-        withProgress: (options, task) => {
-            const { window } = servicesProvider();
-            if (window && window.withProgress) {
-                return window.withProgress(options, task);
-            }
-            return task({ report: () => { } }, new CancellationTokenSource().token);
-        },
-        showTextDocument: async (textDocumentOrUri: vscode.TextDocument | vscode.Uri, columnOrOptions: vscode.ViewColumn | vscode.TextDocumentShowOptions | undefined, preserveFocus?: boolean) => {
-            const { window } = servicesProvider();
-            let options: vscode.TextDocumentShowOptions | undefined;
-            if (typeof columnOrOptions === 'number') {
-                options = {
-                    viewColumn: columnOrOptions,
-                    preserveFocus
-                };
-            } else {
-                options = columnOrOptions
-            }
-
-            if (window && window.showTextDocument) {
-                await window.showTextDocument((textDocumentOrUri as vscode.TextDocument).uri ?? textDocumentOrUri, options)
-            }
-            // The language client doesn't use the return value of this method
-            return undefined as unknown as vscode.TextEditor
-        },
-        createTextEditorDecorationType: unsupported,
-        showQuickPick: unsupported,
-        showWorkspaceFolderPick: unsupported,
-        showOpenDialog: unsupported,
-        showSaveDialog: unsupported,
-        showInputBox: unsupported,
-        createWebviewPanel: unsupported,
-        setStatusBarMessage: unsupported,
-        withScmProgress: unsupported,
-        createStatusBarItem: unsupported,
-        createTerminal: unsupported,
-        registerTreeDataProvider: unsupported,
-        createTreeView: unsupported,
-        registerWebviewPanelSerializer: unsupported,
-        get activeTextEditor() {
-            return unsupported();
-        },
-        get visibleTextEditors() {
-            return unsupported();
-        },
-        onDidChangeActiveTextEditor: unsupported,
-        onDidChangeVisibleTextEditors: unsupported,
-        onDidChangeTextEditorSelection: unsupported,
-        onDidChangeTextEditorVisibleRanges: unsupported,
-        onDidChangeTextEditorOptions: unsupported,
-        onDidChangeTextEditorViewColumn: unsupported,
-        get terminals() {
-            return unsupported();
-        },
-        get activeTerminal() {
-            return unsupported();
-        },
-        onDidChangeActiveTerminal: unsupported,
-        onDidOpenTerminal: unsupported,
-        onDidCloseTerminal: unsupported,
-        get state() {
-            return unsupported();
-        },
-        onDidChangeWindowState: unsupported,
-        createQuickPick: unsupported,
-        createInputBox: unsupported,
-        registerUriHandler: unsupported,
-        registerWebviewViewProvider: unsupported,
-        registerCustomEditorProvider: unsupported,
-        registerTerminalLinkProvider: unsupported,
-        get activeColorTheme() {
-            return unsupported();
-        },
-        onDidChangeActiveColorTheme: unsupported,
-        registerFileDecorationProvider: unsupported,
-        registerTerminalProfileProvider: unsupported,
-        onDidChangeTerminalState: unsupported,
-        get tabGroups() {
-            return unsupported();
-        }
-    };
-    const commands: typeof vscode.commands = {
-        registerCommand(command, callback, thisArg): Disposable {
-            const { commands } = servicesProvider();
-            if (!commands) {
-                return Disposable.create(() => { });
-            }
-            return commands.registerCommand(command, callback, thisArg);
-        },
-        registerTextEditorCommand: unsupported,
-        executeCommand: unsupported,
-        getCommands: unsupported
-    };
-    class CodeDisposable implements vscode.Disposable {
-        constructor(public callOnDispose: Function) { }
-
-        static from(...inDisposables: { dispose(): any; }[]): Disposable {
-            let disposables: ReadonlyArray<{ dispose(): any; }> | undefined = inDisposables;
-            return new CodeDisposable(function () {
-                if (disposables) {
-                    for (const disposable of disposables) {
-                        if (disposable && typeof disposable.dispose === 'function') {
-                            disposable.dispose();
-                        }
-                    }
-                    disposables = undefined;
-                }
-            });
-        }
-
-        dispose() {
-            this.callOnDispose();
-        }
-    }
-
-    const env: typeof vscode.env = {
-        appName: 'Monaco',
-        appRoot: '',
-        language: navigator.language || 'en-US',
-        get uriScheme() {
-            return unsupported();
-        },
-        get clipboard() {
-            return unsupported();
-        },
-        get machineId() {
-            return unsupported();
-        },
-        get sessionId() {
-            return unsupported();
-        },
-        remoteName: undefined,
-        shell: '',
-        uiKind: 2, // vscode.UIKind.Web,
-        asExternalUri: unsupported,
-        openExternal: async (uri: vscode.Uri) => {
-            const { env } = servicesProvider();
-
-            if (env && env.openExternal) {
-                return env.openExternal(uri)
-            }
-            return false
-        },
-        get appHost() {
-            return unsupported();
-        },
-        isNewAppInstall: false,
-        isTelemetryEnabled: false,
-        onDidChangeTelemetryEnabled: unsupported
-    }
-
-    const partialApi: Partial<typeof vscode> = {
-        workspace,
-        languages,
-        window,
-        commands,
-        env,
-        Uri,
-        CompletionItem,
-        CodeLens,
-        DocumentLink,
-        CodeActionKind,
-        CodeAction,
-        Diagnostic,
-        CallHierarchyItem,
-        TypeHierarchyItem,
-        SemanticTokens,
-        Disposable: CodeDisposable,
-        SignatureHelpTriggerKind,
-        DiagnosticSeverity: ServicesModule.DiagnosticSeverity,
-        EventEmitter: ServicesModule.Emitter,
-        CancellationTokenSource,
-        ProgressLocation: ServicesModule.ProgressLocation,
-        TextDocumentChangeReason,
-        SymbolInformation,
-        InlayHint,
-        CancellationError
-    };
-
-    return partialApi as any;
-}