@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/api/common/extHostLanguageFeatures.js

@@ -0,0 +1,2038 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Range, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, location, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
+import { Disposable, DocumentSymbol, Range as Range$2, CodeActionKind, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, Location, CompletionList, InlineCompletionTriggerKind } from './extHostTypes.js';
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { MainContext } from './extHost.protocol.js';
+import { regExpFlags, regExpLeadsToEndlessLoop } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Range as Range$1 } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { isFalsyOrEmpty, coalesce, isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { assertType, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { encodeSemanticTokensDto } from 'monaco-editor/esm/vs/editor/common/services/semanticTokensDto.js';
+import { IdGenerator } from 'monaco-editor/esm/vs/base/common/idGenerator.js';
+import { Cache } from './cache.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { isCancellationError, NotImplementedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { raceCancellationError } from 'monaco-editor/esm/vs/base/common/async.js';
+import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+class DocumentSymbolAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDocumentSymbols(resource, token) {
+        const doc = this._documents.getDocument(resource);
+        const value = await this._provider.provideDocumentSymbols(doc, token);
+        if (isFalsyOrEmpty(value)) {
+            return undefined;
+        }
+        else if (value[0] instanceof DocumentSymbol) {
+            return (
+                 (value.map(DocumentSymbol$1.from))
+            );
+        }
+        else {
+            return DocumentSymbolAdapter._asDocumentSymbolTree(value);
+        }
+    }
+    static _asDocumentSymbolTree(infos) {
+        infos = infos.slice(0).sort((a, b) => {
+            let res = a.location.range.start.compareTo(b.location.range.start);
+            if (res === 0) {
+                res = b.location.range.end.compareTo(a.location.range.end);
+            }
+            return res;
+        });
+        const res = [];
+        const parentStack = [];
+        for (const info of infos) {
+            const element = {
+                name: info.name || '!!MISSING: name!!',
+                kind: SymbolKind.from(info.kind),
+                tags: info.tags?.map(SymbolTag.from) || [],
+                detail: '',
+                containerName: info.containerName,
+                range: Range.from(info.location.range),
+                selectionRange: Range.from(info.location.range),
+                children: []
+            };
+            while (true) {
+                if (parentStack.length === 0) {
+                    parentStack.push(element);
+                    res.push(element);
+                    break;
+                }
+                const parent = parentStack[parentStack.length - 1];
+                if (Range$1.containsRange(parent.range, element.range) && !Range$1.equalsRange(parent.range, element.range)) {
+                    parent.children?.push(element);
+                    parentStack.push(element);
+                    break;
+                }
+                parentStack.pop();
+            }
+        }
+        return res;
+    }
+}
+class CodeLensAdapter {
+    constructor(_documents, _commands, _provider) {
+        this._documents = _documents;
+        this._commands = _commands;
+        this._provider = _provider;
+        this._cache = ( (new Cache('CodeLens')));
+        this._disposables = ( (new Map()));
+    }
+    async provideCodeLenses(resource, token) {
+        const doc = this._documents.getDocument(resource);
+        const lenses = await this._provider.provideCodeLenses(doc, token);
+        if (!lenses || token.isCancellationRequested) {
+            return undefined;
+        }
+        const cacheId = this._cache.add(lenses);
+        const disposables = ( (new DisposableStore()));
+        this._disposables.set(cacheId, disposables);
+        const result = {
+            cacheId,
+            lenses: [],
+        };
+        for (let i = 0; i < lenses.length; i++) {
+            result.lenses.push({
+                cacheId: [cacheId, i],
+                range: Range.from(lenses[i].range),
+                command: this._commands.toInternal(lenses[i].command, disposables)
+            });
+        }
+        return result;
+    }
+    async resolveCodeLens(symbol, token) {
+        const lens = symbol.cacheId && this._cache.get(...symbol.cacheId);
+        if (!lens) {
+            return undefined;
+        }
+        let resolvedLens;
+        if (typeof this._provider.resolveCodeLens !== 'function' || lens.isResolved) {
+            resolvedLens = lens;
+        }
+        else {
+            resolvedLens = await this._provider.resolveCodeLens(lens, token);
+        }
+        if (!resolvedLens) {
+            resolvedLens = lens;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const disposables = symbol.cacheId && this._disposables.get(symbol.cacheId[0]);
+        if (!disposables) {
+            return undefined;
+        }
+        symbol.command = this._commands.toInternal(resolvedLens.command ?? CodeLensAdapter._badCmd, disposables);
+        return symbol;
+    }
+    releaseCodeLenses(cachedId) {
+        this._disposables.get(cachedId)?.dispose();
+        this._disposables.delete(cachedId);
+        this._cache.delete(cachedId);
+    }
+}
+CodeLensAdapter._badCmd = { command: 'missing', title: '!!MISSING: command!!' };
+function convertToLocationLinks(value) {
+    if (Array.isArray(value)) {
+        return (
+             (value.map(DefinitionLink.from))
+        );
+    }
+    else if (value) {
+        return [DefinitionLink.from(value)];
+    }
+    return [];
+}
+class DefinitionAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDefinition(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideDefinition(doc, pos, token);
+        return convertToLocationLinks(value);
+    }
+}
+class DeclarationAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDeclaration(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideDeclaration(doc, pos, token);
+        return convertToLocationLinks(value);
+    }
+}
+class ImplementationAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideImplementation(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideImplementation(doc, pos, token);
+        return convertToLocationLinks(value);
+    }
+}
+class TypeDefinitionAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideTypeDefinition(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideTypeDefinition(doc, pos, token);
+        return convertToLocationLinks(value);
+    }
+}
+class HoverAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideHover(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideHover(doc, pos, token);
+        if (!value || isFalsyOrEmpty(value.contents)) {
+            return undefined;
+        }
+        if (!value.range) {
+            value.range = doc.getWordRangeAtPosition(pos);
+        }
+        if (!value.range) {
+            value.range = ( (new Range$2(pos, pos)));
+        }
+        return Hover.from(value);
+    }
+}
+class EvaluatableExpressionAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideEvaluatableExpression(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideEvaluatableExpression(doc, pos, token);
+        if (value) {
+            return EvaluatableExpression.from(value);
+        }
+        return undefined;
+    }
+}
+class InlineValuesAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideInlineValues(resource, viewPort, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const value = await this._provider.provideInlineValues(doc, Range.to(viewPort), InlineValueContext.to(context), token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(iv => InlineValue.from(iv)))
+            );
+        }
+        return undefined;
+    }
+}
+class DocumentHighlightAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDocumentHighlights(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideDocumentHighlights(doc, pos, token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(DocumentHighlight.from))
+            );
+        }
+        return undefined;
+    }
+}
+class LinkedEditingRangeAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideLinkedEditingRanges(resource, position, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideLinkedEditingRanges(doc, pos, token);
+        if (value && Array.isArray(value.ranges)) {
+            return {
+                ranges: coalesce(( (value.ranges.map(Range.from)))),
+                wordPattern: value.wordPattern
+            };
+        }
+        return undefined;
+    }
+}
+class ReferenceAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideReferences(resource, position, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideReferences(doc, pos, context, token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(location.from))
+            );
+        }
+        return undefined;
+    }
+}
+class CodeActionAdapter {
+    constructor(_documents, _commands, _diagnostics, _provider, _logService, _extension, _apiDeprecation) {
+        this._documents = _documents;
+        this._commands = _commands;
+        this._diagnostics = _diagnostics;
+        this._provider = _provider;
+        this._logService = _logService;
+        this._extension = _extension;
+        this._apiDeprecation = _apiDeprecation;
+        this._cache = ( (new Cache('CodeAction')));
+        this._disposables = ( (new Map()));
+    }
+    async provideCodeActions(resource, rangeOrSelection, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const ran = Selection.isISelection(rangeOrSelection)
+            ? Selection$1.to(rangeOrSelection)
+            : Range.to(rangeOrSelection);
+        const allDiagnostics = [];
+        for (const diagnostic of this._diagnostics.getDiagnostics(resource)) {
+            if (ran.intersection(diagnostic.range)) {
+                const newLen = allDiagnostics.push(diagnostic);
+                if (newLen > CodeActionAdapter._maxCodeActionsPerFile) {
+                    break;
+                }
+            }
+        }
+        const codeActionContext = {
+            diagnostics: allDiagnostics,
+            only: context.only ? ( (new CodeActionKind(context.only))) : undefined,
+            triggerKind: CodeActionTriggerKind.to(context.trigger),
+        };
+        const commandsOrActions = await this._provider.provideCodeActions(doc, ran, codeActionContext, token);
+        if (!isNonEmptyArray(commandsOrActions) || token.isCancellationRequested) {
+            return undefined;
+        }
+        const cacheId = this._cache.add(commandsOrActions);
+        const disposables = ( (new DisposableStore()));
+        this._disposables.set(cacheId, disposables);
+        const actions = [];
+        for (let i = 0; i < commandsOrActions.length; i++) {
+            const candidate = commandsOrActions[i];
+            if (!candidate) {
+                continue;
+            }
+            if (CodeActionAdapter._isCommand(candidate)) {
+                this._apiDeprecation.report('CodeActionProvider.provideCodeActions - return commands', this._extension, `Return 'CodeAction' instances instead.`);
+                actions.push({
+                    _isSynthetic: true,
+                    title: candidate.title,
+                    command: this._commands.toInternal(candidate, disposables),
+                });
+            }
+            else {
+                if (codeActionContext.only) {
+                    if (!candidate.kind) {
+                        this._logService.warn(`${this._extension.identifier.value} - Code actions of kind '${codeActionContext.only.value} 'requested but returned code action does not have a 'kind'. Code action will be dropped. Please set 'CodeAction.kind'.`);
+                    }
+                    else if (!codeActionContext.only.contains(candidate.kind)) {
+                        this._logService.warn(`${this._extension.identifier.value} - Code actions of kind '${codeActionContext.only.value} 'requested but returned code action is of kind '${candidate.kind.value}'. Code action will be dropped. Please check 'CodeActionContext.only' to only return requested code actions.`);
+                    }
+                }
+                actions.push({
+                    cacheId: [cacheId, i],
+                    title: candidate.title,
+                    command: candidate.command && this._commands.toInternal(candidate.command, disposables),
+                    diagnostics: candidate.diagnostics && ( (candidate.diagnostics.map(Diagnostic.from))),
+                    edit: candidate.edit && WorkspaceEdit.from(candidate.edit, undefined),
+                    kind: candidate.kind && candidate.kind.value,
+                    isPreferred: candidate.isPreferred,
+                    disabled: candidate.disabled?.reason
+                });
+            }
+        }
+        return { cacheId, actions };
+    }
+    async resolveCodeAction(id, token) {
+        const [sessionId, itemId] = id;
+        const item = this._cache.get(sessionId, itemId);
+        if (!item || CodeActionAdapter._isCommand(item)) {
+            return {};
+        }
+        if (!this._provider.resolveCodeAction) {
+            return {};
+        }
+        const resolvedItem = (await this._provider.resolveCodeAction(item, token)) ?? item;
+        let resolvedEdit;
+        if (resolvedItem.edit) {
+            resolvedEdit = WorkspaceEdit.from(resolvedItem.edit, undefined);
+        }
+        let resolvedCommand;
+        if (resolvedItem.command) {
+            const disposables = this._disposables.get(sessionId);
+            if (disposables) {
+                resolvedCommand = this._commands.toInternal(resolvedItem.command, disposables);
+            }
+        }
+        return { edit: resolvedEdit, command: resolvedCommand };
+    }
+    releaseCodeActions(cachedId) {
+        this._disposables.get(cachedId)?.dispose();
+        this._disposables.delete(cachedId);
+        this._cache.delete(cachedId);
+    }
+    static _isCommand(thing) {
+        return typeof thing.command === 'string' && typeof thing.title === 'string';
+    }
+}
+CodeActionAdapter._maxCodeActionsPerFile = 1000;
+class DocumentPasteEditProvider {
+    constructor(_proxy, _documents, _provider, _handle) {
+        this._proxy = _proxy;
+        this._documents = _documents;
+        this._provider = _provider;
+        this._handle = _handle;
+    }
+    async prepareDocumentPaste(resource, ranges, dataTransferDto, token) {
+        if (!this._provider.prepareDocumentPaste) {
+            return undefined;
+        }
+        const doc = this._documents.getDocument(resource);
+        const vscodeRanges = ( (ranges.map(range => Range.to(range))));
+        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, () => {
+            throw new NotImplementedError();
+        });
+        await this._provider.prepareDocumentPaste(doc, vscodeRanges, dataTransfer, token);
+        return DataTransfer.toDataTransferDTO(dataTransfer);
+    }
+    async providePasteEdits(requestId, resource, ranges, dataTransferDto, token) {
+        const doc = this._documents.getDocument(resource);
+        const vscodeRanges = ( (ranges.map(range => Range.to(range))));
+        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
+            return (await this._proxy.$resolvePasteFileData(this._handle, requestId, id)).buffer;
+        });
+        const edit = await this._provider.provideDocumentPasteEdits(doc, vscodeRanges, dataTransfer, token);
+        if (!edit) {
+            return;
+        }
+        return {
+            insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
+            additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
+        };
+    }
+}
+class DocumentFormattingAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDocumentFormattingEdits(resource, options, token) {
+        const document = this._documents.getDocument(resource);
+        const value = await this._provider.provideDocumentFormattingEdits(document, options, token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(TextEdit.from))
+            );
+        }
+        return undefined;
+    }
+}
+class RangeFormattingAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDocumentRangeFormattingEdits(resource, range, options, token) {
+        const document = this._documents.getDocument(resource);
+        const ran = Range.to(range);
+        const value = await this._provider.provideDocumentRangeFormattingEdits(document, ran, options, token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(TextEdit.from))
+            );
+        }
+        return undefined;
+    }
+    async provideDocumentRangesFormattingEdits(resource, ranges, options, token) {
+        assertType(typeof this._provider.provideDocumentRangesFormattingEdits === 'function', 'INVALID invocation of `provideDocumentRangesFormattingEdits`');
+        const document = this._documents.getDocument(resource);
+        const _ranges = ( (ranges.map(Range.to)));
+        const value = await this._provider.provideDocumentRangesFormattingEdits(document, _ranges, options, token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(TextEdit.from))
+            );
+        }
+        return undefined;
+    }
+}
+class OnTypeFormattingAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this.autoFormatTriggerCharacters = [];
+    }
+    async provideOnTypeFormattingEdits(resource, position, ch, options, token) {
+        const document = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const value = await this._provider.provideOnTypeFormattingEdits(document, pos, ch, options, token);
+        if (Array.isArray(value)) {
+            return (
+                 (value.map(TextEdit.from))
+            );
+        }
+        return undefined;
+    }
+}
+class NavigateTypeAdapter {
+    constructor(_provider, _logService) {
+        this._provider = _provider;
+        this._logService = _logService;
+        this._cache = ( (new Cache('WorkspaceSymbols')));
+    }
+    async provideWorkspaceSymbols(search, token) {
+        const value = await this._provider.provideWorkspaceSymbols(search, token);
+        if (!isNonEmptyArray(value)) {
+            return { symbols: [] };
+        }
+        const sid = this._cache.add(value);
+        const result = {
+            cacheId: sid,
+            symbols: []
+        };
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            if (!item || !item.name) {
+                this._logService.warn('INVALID SymbolInformation', item);
+                continue;
+            }
+            result.symbols.push({
+                ...WorkspaceSymbol.from(item),
+                cacheId: [sid, i]
+            });
+        }
+        return result;
+    }
+    async resolveWorkspaceSymbol(symbol, token) {
+        if (typeof this._provider.resolveWorkspaceSymbol !== 'function') {
+            return symbol;
+        }
+        if (!symbol.cacheId) {
+            return symbol;
+        }
+        const item = this._cache.get(...symbol.cacheId);
+        if (item) {
+            const value = await this._provider.resolveWorkspaceSymbol(item, token);
+            return value && mixin(symbol, WorkspaceSymbol.from(value), true);
+        }
+        return undefined;
+    }
+    releaseWorkspaceSymbols(id) {
+        this._cache.delete(id);
+    }
+}
+class RenameAdapter {
+    static supportsResolving(provider) {
+        return typeof provider.prepareRename === 'function';
+    }
+    constructor(_documents, _provider, _logService) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._logService = _logService;
+    }
+    async provideRenameEdits(resource, position, newName, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        try {
+            const value = await this._provider.provideRenameEdits(doc, pos, newName, token);
+            if (!value) {
+                return undefined;
+            }
+            return WorkspaceEdit.from(value);
+        }
+        catch (err) {
+            const rejectReason = RenameAdapter._asMessage(err);
+            if (rejectReason) {
+                return { rejectReason, edits: undefined };
+            }
+            else {
+                return Promise.reject(err);
+            }
+        }
+    }
+    async resolveRenameLocation(resource, position, token) {
+        if (typeof this._provider.prepareRename !== 'function') {
+            return Promise.resolve(undefined);
+        }
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        try {
+            const rangeOrLocation = await this._provider.prepareRename(doc, pos, token);
+            let range;
+            let text;
+            if (Range$2.isRange(rangeOrLocation)) {
+                range = rangeOrLocation;
+                text = doc.getText(rangeOrLocation);
+            }
+            else if (isObject(rangeOrLocation)) {
+                range = rangeOrLocation.range;
+                text = rangeOrLocation.placeholder;
+            }
+            if (!range || !text) {
+                return undefined;
+            }
+            if (range.start.line > pos.line || range.end.line < pos.line) {
+                this._logService.warn('INVALID rename location: position line must be within range start/end lines');
+                return undefined;
+            }
+            return { range: Range.from(range), text };
+        }
+        catch (err) {
+            const rejectReason = RenameAdapter._asMessage(err);
+            if (rejectReason) {
+                return { rejectReason, range: undefined, text: undefined };
+            }
+            else {
+                return Promise.reject(err);
+            }
+        }
+    }
+    static _asMessage(err) {
+        if (typeof err === 'string') {
+            return err;
+        }
+        else if (err instanceof Error && typeof err.message === 'string') {
+            return err.message;
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+class SemanticTokensPreviousResult {
+    constructor(resultId, tokens) {
+        this.resultId = resultId;
+        this.tokens = tokens;
+    }
+}
+class DocumentSemanticTokensAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._nextResultId = 1;
+        this._previousResults = ( (new Map()));
+    }
+    async provideDocumentSemanticTokens(resource, previousResultId, token) {
+        const doc = this._documents.getDocument(resource);
+        const previousResult = (previousResultId !== 0 ? this._previousResults.get(previousResultId) : null);
+        let value = typeof previousResult?.resultId === 'string' && typeof this._provider.provideDocumentSemanticTokensEdits === 'function'
+            ? await this._provider.provideDocumentSemanticTokensEdits(doc, previousResult.resultId, token)
+            : await this._provider.provideDocumentSemanticTokens(doc, token);
+        if (previousResult) {
+            this._previousResults.delete(previousResultId);
+        }
+        if (!value) {
+            return null;
+        }
+        value = DocumentSemanticTokensAdapter._fixProvidedSemanticTokens(value);
+        return this._send(DocumentSemanticTokensAdapter._convertToEdits(previousResult, value), value);
+    }
+    async releaseDocumentSemanticColoring(semanticColoringResultId) {
+        this._previousResults.delete(semanticColoringResultId);
+    }
+    static _fixProvidedSemanticTokens(v) {
+        if (DocumentSemanticTokensAdapter._isSemanticTokens(v)) {
+            if (DocumentSemanticTokensAdapter._isCorrectSemanticTokens(v)) {
+                return v;
+            }
+            return (
+                 (new SemanticTokens( (new Uint32Array(v.data)), v.resultId))
+            );
+        }
+        else if (DocumentSemanticTokensAdapter._isSemanticTokensEdits(v)) {
+            if (DocumentSemanticTokensAdapter._isCorrectSemanticTokensEdits(v)) {
+                return v;
+            }
+            return (
+                 (new SemanticTokensEdits( (v.edits.map(edit => ( (new SemanticTokensEdit(
+                    edit.start,
+                    edit.deleteCount,
+                    edit.data ? ( (new Uint32Array(edit.data))) : edit.data
+                ))))), v.resultId))
+            );
+        }
+        return v;
+    }
+    static _isSemanticTokens(v) {
+        return v && !!(v.data);
+    }
+    static _isCorrectSemanticTokens(v) {
+        return (v.data instanceof Uint32Array);
+    }
+    static _isSemanticTokensEdits(v) {
+        return v && Array.isArray(v.edits);
+    }
+    static _isCorrectSemanticTokensEdits(v) {
+        for (const edit of v.edits) {
+            if (!(edit.data instanceof Uint32Array)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static _convertToEdits(previousResult, newResult) {
+        if (!DocumentSemanticTokensAdapter._isSemanticTokens(newResult)) {
+            return newResult;
+        }
+        if (!previousResult || !previousResult.tokens) {
+            return newResult;
+        }
+        const oldData = previousResult.tokens;
+        const oldLength = oldData.length;
+        const newData = newResult.data;
+        const newLength = newData.length;
+        let commonPrefixLength = 0;
+        const maxCommonPrefixLength = Math.min(oldLength, newLength);
+        while (commonPrefixLength < maxCommonPrefixLength && oldData[commonPrefixLength] === newData[commonPrefixLength]) {
+            commonPrefixLength++;
+        }
+        if (commonPrefixLength === oldLength && commonPrefixLength === newLength) {
+            return (
+                 (new SemanticTokensEdits([], newResult.resultId))
+            );
+        }
+        let commonSuffixLength = 0;
+        const maxCommonSuffixLength = maxCommonPrefixLength - commonPrefixLength;
+        while (commonSuffixLength < maxCommonSuffixLength && oldData[oldLength - commonSuffixLength - 1] === newData[newLength - commonSuffixLength - 1]) {
+            commonSuffixLength++;
+        }
+        return (
+             (new SemanticTokensEdits([{
+                    start: commonPrefixLength,
+                    deleteCount: (oldLength - commonPrefixLength - commonSuffixLength),
+                    data: newData.subarray(commonPrefixLength, newLength - commonSuffixLength)
+                }], newResult.resultId))
+        );
+    }
+    _send(value, original) {
+        if (DocumentSemanticTokensAdapter._isSemanticTokens(value)) {
+            const myId = this._nextResultId++;
+            this._previousResults.set(myId, ( (new SemanticTokensPreviousResult(value.resultId, value.data))));
+            return encodeSemanticTokensDto({
+                id: myId,
+                type: 'full',
+                data: value.data
+            });
+        }
+        if (DocumentSemanticTokensAdapter._isSemanticTokensEdits(value)) {
+            const myId = this._nextResultId++;
+            if (DocumentSemanticTokensAdapter._isSemanticTokens(original)) {
+                this._previousResults.set(myId, ( (new SemanticTokensPreviousResult(original.resultId, original.data))));
+            }
+            else {
+                this._previousResults.set(myId, ( (new SemanticTokensPreviousResult(value.resultId))));
+            }
+            return encodeSemanticTokensDto({
+                id: myId,
+                type: 'delta',
+                deltas: ( ((value.edits || []).map(
+                    edit => ({ start: edit.start, deleteCount: edit.deleteCount, data: edit.data })
+                )))
+            });
+        }
+        return null;
+    }
+}
+class DocumentRangeSemanticTokensAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideDocumentRangeSemanticTokens(resource, range, token) {
+        const doc = this._documents.getDocument(resource);
+        const value = await this._provider.provideDocumentRangeSemanticTokens(doc, Range.to(range), token);
+        if (!value) {
+            return null;
+        }
+        return this._send(value);
+    }
+    _send(value) {
+        return encodeSemanticTokensDto({
+            id: 0,
+            type: 'full',
+            data: value.data
+        });
+    }
+}
+class CompletionsAdapter {
+    static supportsResolving(provider) {
+        return typeof provider.resolveCompletionItem === 'function';
+    }
+    constructor(_documents, _commands, _provider, _apiDeprecation, _extension) {
+        this._documents = _documents;
+        this._commands = _commands;
+        this._provider = _provider;
+        this._apiDeprecation = _apiDeprecation;
+        this._extension = _extension;
+        this._cache = ( (new Cache('CompletionItem')));
+        this._disposables = ( (new Map()));
+    }
+    async provideCompletionItems(resource, position, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const replaceRange = doc.getWordRangeAtPosition(pos) || ( (new Range$2(pos, pos)));
+        const insertRange = replaceRange.with({ end: pos });
+        const sw = ( (new StopWatch(true)));
+        const itemsOrList = await this._provider.provideCompletionItems(doc, pos, token, CompletionContext.to(context));
+        if (!itemsOrList) {
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const list = Array.isArray(itemsOrList) ? ( (new CompletionList(itemsOrList))) : itemsOrList;
+        const pid = CompletionsAdapter.supportsResolving(this._provider) ? this._cache.add(list.items) : this._cache.add([]);
+        const disposables = ( (new DisposableStore()));
+        this._disposables.set(pid, disposables);
+        const completions = [];
+        const result = {
+            x: pid,
+            ["b" ]: completions,
+            ["a" ]: { replace: Range.from(replaceRange), insert: Range.from(insertRange) },
+            ["c" ]: list.isIncomplete || undefined,
+            ["d" ]: sw.elapsed()
+        };
+        for (let i = 0; i < list.items.length; i++) {
+            const item = list.items[i];
+            const dto = this._convertCompletionItem(item, [pid, i], insertRange, replaceRange);
+            completions.push(dto);
+        }
+        return result;
+    }
+    async resolveCompletionItem(id, token) {
+        if (typeof this._provider.resolveCompletionItem !== 'function') {
+            return undefined;
+        }
+        const item = this._cache.get(...id);
+        if (!item) {
+            return undefined;
+        }
+        const resolvedItem = await this._provider.resolveCompletionItem(item, token);
+        if (!resolvedItem) {
+            return undefined;
+        }
+        return this._convertCompletionItem(resolvedItem, id);
+    }
+    releaseCompletionItems(id) {
+        this._disposables.get(id)?.dispose();
+        this._disposables.delete(id);
+        this._cache.delete(id);
+    }
+    _convertCompletionItem(item, id, defaultInsertRange, defaultReplaceRange) {
+        const disposables = this._disposables.get(id[0]);
+        if (!disposables) {
+            throw Error('DisposableStore is missing...');
+        }
+        const command = this._commands.toInternal(item.command, disposables);
+        const result = {
+            x: id,
+            ["a" ]: item.label,
+            ["b" ]: item.kind !== undefined ? CompletionItemKind.from(item.kind) : undefined,
+            ["m" ]: item.tags && ( (item.tags.map(CompletionItemTag.from))),
+            ["c" ]: item.detail,
+            ["d" ]: typeof item.documentation === 'undefined' ? undefined : MarkdownString.fromStrict(item.documentation),
+            ["e" ]: item.sortText !== item.label ? item.sortText : undefined,
+            ["f" ]: item.filterText !== item.label ? item.filterText : undefined,
+            ["g" ]: item.preselect || undefined,
+            ["i" ]: item.keepWhitespace ? 1  : 0 ,
+            ["k" ]: item.commitCharacters?.join(''),
+            ["l" ]: item.additionalTextEdits && ( (item.additionalTextEdits.map(TextEdit.from))),
+            ["n" ]: command?.$ident,
+            ["o" ]: command?.id,
+            ["p" ]: command?.$ident ? undefined : command?.arguments,
+        };
+        if (item.textEdit) {
+            this._apiDeprecation.report('CompletionItem.textEdit', this._extension, `Use 'CompletionItem.insertText' and 'CompletionItem.range' instead.`);
+            result["h" ] = item.textEdit.newText;
+        }
+        else if (typeof item.insertText === 'string') {
+            result["h" ] = item.insertText;
+        }
+        else if (item.insertText instanceof SnippetString) {
+            result["h" ] = item.insertText.value;
+            result["i" ] |= 4 ;
+        }
+        let range;
+        if (item.textEdit) {
+            range = item.textEdit.range;
+        }
+        else if (item.range) {
+            range = item.range;
+        }
+        if (Range$2.isRange(range)) {
+            result["j" ] = Range.from(range);
+        }
+        else if (range && (!defaultInsertRange?.isEqual(range.inserting) || !defaultReplaceRange?.isEqual(range.replacing))) {
+            result["j" ] = {
+                insert: Range.from(range.inserting),
+                replace: Range.from(range.replacing)
+            };
+        }
+        return result;
+    }
+}
+class InlineCompletionAdapterBase {
+    async provideInlineCompletions(resource, position, context, token) {
+        return undefined;
+    }
+    disposeCompletions(pid) { }
+    handleDidShowCompletionItem(pid, idx) { }
+    handlePartialAccept(pid, idx, acceptedCharacters) { }
+}
+class InlineCompletionAdapter extends InlineCompletionAdapterBase {
+    constructor(_extension, _documents, _provider, _commands) {
+        super();
+        this._extension = _extension;
+        this._documents = _documents;
+        this._provider = _provider;
+        this._commands = _commands;
+        this._references = ( (new ReferenceMap()));
+        this._isAdditionsProposedApiEnabled = isProposedApiEnabled(this._extension, 'inlineCompletionsAdditions');
+        this.languageTriggerKindToVSCodeTriggerKind = {
+            [languages.InlineCompletionTriggerKind.Automatic]: InlineCompletionTriggerKind.Automatic,
+            [languages.InlineCompletionTriggerKind.Explicit]: InlineCompletionTriggerKind.Invoke,
+        };
+    }
+    get supportsHandleEvents() {
+        return isProposedApiEnabled(this._extension, 'inlineCompletionsAdditions')
+            && (typeof this._provider.handleDidShowCompletionItem === 'function'
+                || typeof this._provider.handleDidPartiallyAcceptCompletionItem === 'function');
+    }
+    async provideInlineCompletions(resource, position, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const result = await this._provider.provideInlineCompletionItems(doc, pos, {
+            selectedCompletionInfo: context.selectedSuggestionInfo
+                ? {
+                    range: Range.to(context.selectedSuggestionInfo.range),
+                    text: context.selectedSuggestionInfo.text
+                }
+                : undefined,
+            triggerKind: this.languageTriggerKindToVSCodeTriggerKind[context.triggerKind]
+        }, token);
+        if (!result) {
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const normalizedResult = Array.isArray(result) ? result : result.items;
+        const commands = this._isAdditionsProposedApiEnabled ? Array.isArray(result) ? [] : result.commands || [] : [];
+        let disposableStore = undefined;
+        const pid = this._references.createReferenceId({
+            dispose() {
+                disposableStore?.dispose();
+            },
+            items: normalizedResult
+        });
+        return {
+            pid,
+            items: ( (normalizedResult.map((item, idx) => {
+                let command = undefined;
+                if (item.command) {
+                    if (!disposableStore) {
+                        disposableStore = ( (new DisposableStore()));
+                    }
+                    command = this._commands.toInternal(item.command, disposableStore);
+                }
+                const insertText = item.insertText;
+                return ({
+                    insertText: typeof insertText === 'string' ? insertText : { snippet: insertText.value },
+                    filterText: item.filterText,
+                    range: item.range ? Range.from(item.range) : undefined,
+                    command,
+                    idx: idx,
+                    completeBracketPairs: this._isAdditionsProposedApiEnabled ? item.completeBracketPairs : false
+                });
+            }))),
+            commands: ( (commands.map(c => {
+                if (!disposableStore) {
+                    disposableStore = ( (new DisposableStore()));
+                }
+                return this._commands.toInternal(c, disposableStore);
+            })))
+        };
+    }
+    disposeCompletions(pid) {
+        const data = this._references.disposeReferenceId(pid);
+        data?.dispose();
+    }
+    handleDidShowCompletionItem(pid, idx) {
+        const completionItem = this._references.get(pid)?.items[idx];
+        if (completionItem) {
+            if (this._provider.handleDidShowCompletionItem && this._isAdditionsProposedApiEnabled) {
+                this._provider.handleDidShowCompletionItem(completionItem);
+            }
+        }
+    }
+    handlePartialAccept(pid, idx, acceptedCharacters) {
+        const completionItem = this._references.get(pid)?.items[idx];
+        if (completionItem) {
+            if (this._provider.handleDidPartiallyAcceptCompletionItem && this._isAdditionsProposedApiEnabled) {
+                this._provider.handleDidPartiallyAcceptCompletionItem(completionItem, acceptedCharacters);
+            }
+        }
+    }
+}
+class ReferenceMap {
+    constructor() {
+        this._references = ( (new Map()));
+        this._idPool = 1;
+    }
+    createReferenceId(value) {
+        const id = this._idPool++;
+        this._references.set(id, value);
+        return id;
+    }
+    disposeReferenceId(referenceId) {
+        const value = this._references.get(referenceId);
+        this._references.delete(referenceId);
+        return value;
+    }
+    get(referenceId) {
+        return this._references.get(referenceId);
+    }
+}
+class SignatureHelpAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._cache = ( (new Cache('SignatureHelp')));
+    }
+    async provideSignatureHelp(resource, position, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const pos = Position.to(position);
+        const vscodeContext = this.reviveContext(context);
+        const value = await this._provider.provideSignatureHelp(doc, pos, token, vscodeContext);
+        if (value) {
+            const id = this._cache.add([value]);
+            return { ...SignatureHelp.from(value), id };
+        }
+        return undefined;
+    }
+    reviveContext(context) {
+        let activeSignatureHelp = undefined;
+        if (context.activeSignatureHelp) {
+            const revivedSignatureHelp = SignatureHelp.to(context.activeSignatureHelp);
+            const saved = this._cache.get(context.activeSignatureHelp.id, 0);
+            if (saved) {
+                activeSignatureHelp = saved;
+                activeSignatureHelp.activeSignature = revivedSignatureHelp.activeSignature;
+                activeSignatureHelp.activeParameter = revivedSignatureHelp.activeParameter;
+            }
+            else {
+                activeSignatureHelp = revivedSignatureHelp;
+            }
+        }
+        return { ...context, activeSignatureHelp };
+    }
+    releaseSignatureHelp(id) {
+        this._cache.delete(id);
+    }
+}
+class InlayHintsAdapter {
+    constructor(_documents, _commands, _provider, _logService, _extension) {
+        this._documents = _documents;
+        this._commands = _commands;
+        this._provider = _provider;
+        this._logService = _logService;
+        this._extension = _extension;
+        this._cache = ( (new Cache('InlayHints')));
+        this._disposables = ( (new Map()));
+    }
+    async provideInlayHints(resource, ran, token) {
+        const doc = this._documents.getDocument(resource);
+        const range = Range.to(ran);
+        const hints = await this._provider.provideInlayHints(doc, range, token);
+        if (!Array.isArray(hints) || hints.length === 0) {
+            this._logService.trace(`[InlayHints] NO inlay hints from '${this._extension.identifier.value}' for ${ran}`);
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const pid = this._cache.add(hints);
+        this._disposables.set(pid, ( (new DisposableStore())));
+        const result = { hints: [], cacheId: pid };
+        for (let i = 0; i < hints.length; i++) {
+            if (this._isValidInlayHint(hints[i], range)) {
+                result.hints.push(this._convertInlayHint(hints[i], [pid, i]));
+            }
+        }
+        this._logService.trace(`[InlayHints] ${result.hints.length} inlay hints from '${this._extension.identifier.value}' for ${ran}`);
+        return result;
+    }
+    async resolveInlayHint(id, token) {
+        if (typeof this._provider.resolveInlayHint !== 'function') {
+            return undefined;
+        }
+        const item = this._cache.get(...id);
+        if (!item) {
+            return undefined;
+        }
+        const hint = await this._provider.resolveInlayHint(item, token);
+        if (!hint) {
+            return undefined;
+        }
+        if (!this._isValidInlayHint(hint)) {
+            return undefined;
+        }
+        return this._convertInlayHint(hint, id);
+    }
+    releaseHints(id) {
+        this._disposables.get(id)?.dispose();
+        this._disposables.delete(id);
+        this._cache.delete(id);
+    }
+    _isValidInlayHint(hint, range) {
+        if (hint.label.length === 0 || Array.isArray(hint.label) && hint.label.every(part => part.value.length === 0)) {
+            console.log('INVALID inlay hint, empty label', hint);
+            return false;
+        }
+        if (range && !range.contains(hint.position)) {
+            return false;
+        }
+        return true;
+    }
+    _convertInlayHint(hint, id) {
+        const disposables = this._disposables.get(id[0]);
+        if (!disposables) {
+            throw Error('DisposableStore is missing...');
+        }
+        const result = {
+            label: '',
+            cacheId: id,
+            tooltip: MarkdownString.fromStrict(hint.tooltip),
+            position: Position.from(hint.position),
+            textEdits: hint.textEdits && ( (hint.textEdits.map(TextEdit.from))),
+            kind: hint.kind && InlayHintKind.from(hint.kind),
+            paddingLeft: hint.paddingLeft,
+            paddingRight: hint.paddingRight,
+        };
+        if (typeof hint.label === 'string') {
+            result.label = hint.label;
+        }
+        else {
+            result.label = ( (hint.label.map(part => {
+                const result = { label: part.value };
+                result.tooltip = MarkdownString.fromStrict(part.tooltip);
+                if (Location.isLocation(part.location)) {
+                    result.location = location.from(part.location);
+                }
+                if (part.command) {
+                    result.command = this._commands.toInternal(part.command, disposables);
+                }
+                return result;
+            })));
+        }
+        return result;
+    }
+}
+class LinkProviderAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._cache = ( (new Cache('DocumentLink')));
+    }
+    async provideLinks(resource, token) {
+        const doc = this._documents.getDocument(resource);
+        const links = await this._provider.provideDocumentLinks(doc, token);
+        if (!Array.isArray(links) || links.length === 0) {
+            return undefined;
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        if (typeof this._provider.resolveDocumentLink !== 'function') {
+            return { links: ( (links.filter(LinkProviderAdapter._validateLink).map(DocumentLink.from))) };
+        }
+        else {
+            const pid = this._cache.add(links);
+            const result = { links: [], cacheId: pid };
+            for (let i = 0; i < links.length; i++) {
+                if (!LinkProviderAdapter._validateLink(links[i])) {
+                    continue;
+                }
+                const dto = DocumentLink.from(links[i]);
+                dto.cacheId = [pid, i];
+                result.links.push(dto);
+            }
+            return result;
+        }
+    }
+    static _validateLink(link) {
+        if (link.target && link.target.path.length > 50000) {
+            console.warn('DROPPING link because it is too long');
+            return false;
+        }
+        return true;
+    }
+    async resolveLink(id, token) {
+        if (typeof this._provider.resolveDocumentLink !== 'function') {
+            return undefined;
+        }
+        const item = this._cache.get(...id);
+        if (!item) {
+            return undefined;
+        }
+        const link = await this._provider.resolveDocumentLink(item, token);
+        if (!link || !LinkProviderAdapter._validateLink(link)) {
+            return undefined;
+        }
+        return DocumentLink.from(link);
+    }
+    releaseLinks(id) {
+        this._cache.delete(id);
+    }
+}
+class ColorProviderAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideColors(resource, token) {
+        const doc = this._documents.getDocument(resource);
+        const colors = await this._provider.provideDocumentColors(doc, token);
+        if (!Array.isArray(colors)) {
+            return [];
+        }
+        const colorInfos = ( (colors.map(ci => {
+            return {
+                color: Color.from(ci.color),
+                range: Range.from(ci.range)
+            };
+        })));
+        return colorInfos;
+    }
+    async provideColorPresentations(resource, raw, token) {
+        const document = this._documents.getDocument(resource);
+        const range = Range.to(raw.range);
+        const color = Color.to(raw.color);
+        const value = await this._provider.provideColorPresentations(color, { document, range }, token);
+        if (!Array.isArray(value)) {
+            return undefined;
+        }
+        return (
+             (value.map(ColorPresentation.from))
+        );
+    }
+}
+class FoldingProviderAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideFoldingRanges(resource, context, token) {
+        const doc = this._documents.getDocument(resource);
+        const ranges = await this._provider.provideFoldingRanges(doc, context, token);
+        if (!Array.isArray(ranges)) {
+            return undefined;
+        }
+        return (
+             (ranges.map(FoldingRange.from))
+        );
+    }
+}
+class SelectionRangeAdapter {
+    constructor(_documents, _provider, _logService) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._logService = _logService;
+    }
+    async provideSelectionRanges(resource, pos, token) {
+        const document = this._documents.getDocument(resource);
+        const positions = ( (pos.map(Position.to)));
+        const allProviderRanges = await this._provider.provideSelectionRanges(document, positions, token);
+        if (!isNonEmptyArray(allProviderRanges)) {
+            return [];
+        }
+        if (allProviderRanges.length !== positions.length) {
+            this._logService.warn('BAD selection ranges, provider must return ranges for each position');
+            return [];
+        }
+        const allResults = [];
+        for (let i = 0; i < positions.length; i++) {
+            const oneResult = [];
+            allResults.push(oneResult);
+            let last = positions[i];
+            let selectionRange = allProviderRanges[i];
+            while (true) {
+                if (!selectionRange.range.contains(last)) {
+                    throw new Error('INVALID selection range, must contain the previous range');
+                }
+                oneResult.push(SelectionRange.from(selectionRange));
+                if (!selectionRange.parent) {
+                    break;
+                }
+                last = selectionRange.range;
+                selectionRange = selectionRange.parent;
+            }
+        }
+        return allResults;
+    }
+}
+class CallHierarchyAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._idPool = ( (new IdGenerator('')));
+        this._cache = ( (new Map()));
+    }
+    async prepareSession(uri, position, token) {
+        const doc = this._documents.getDocument(uri);
+        const pos = Position.to(position);
+        const items = await this._provider.prepareCallHierarchy(doc, pos, token);
+        if (!items) {
+            return undefined;
+        }
+        const sessionId = this._idPool.nextId();
+        this._cache.set(sessionId, ( (new Map())));
+        if (Array.isArray(items)) {
+            return (
+                 (items.map(item => this._cacheAndConvertItem(sessionId, item)))
+            );
+        }
+        else {
+            return [this._cacheAndConvertItem(sessionId, items)];
+        }
+    }
+    async provideCallsTo(sessionId, itemId, token) {
+        const item = this._itemFromCache(sessionId, itemId);
+        if (!item) {
+            throw new Error('missing call hierarchy item');
+        }
+        const calls = await this._provider.provideCallHierarchyIncomingCalls(item, token);
+        if (!calls) {
+            return undefined;
+        }
+        return (
+             (calls.map(call => {
+                return {
+                    from: this._cacheAndConvertItem(sessionId, call.from),
+                    fromRanges: ( (call.fromRanges.map(r => Range.from(r))))
+                };
+            }))
+        );
+    }
+    async provideCallsFrom(sessionId, itemId, token) {
+        const item = this._itemFromCache(sessionId, itemId);
+        if (!item) {
+            throw new Error('missing call hierarchy item');
+        }
+        const calls = await this._provider.provideCallHierarchyOutgoingCalls(item, token);
+        if (!calls) {
+            return undefined;
+        }
+        return (
+             (calls.map(call => {
+                return {
+                    to: this._cacheAndConvertItem(sessionId, call.to),
+                    fromRanges: ( (call.fromRanges.map(r => Range.from(r))))
+                };
+            }))
+        );
+    }
+    releaseSession(sessionId) {
+        this._cache.delete(sessionId);
+    }
+    _cacheAndConvertItem(sessionId, item) {
+        const map = this._cache.get(sessionId);
+        const dto = CallHierarchyItem.from(item, sessionId, ( (map.size.toString(36))));
+        map.set(dto._itemId, item);
+        return dto;
+    }
+    _itemFromCache(sessionId, itemId) {
+        const map = this._cache.get(sessionId);
+        return map?.get(itemId);
+    }
+}
+class TypeHierarchyAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+        this._idPool = ( (new IdGenerator('')));
+        this._cache = ( (new Map()));
+    }
+    async prepareSession(uri, position, token) {
+        const doc = this._documents.getDocument(uri);
+        const pos = Position.to(position);
+        const items = await this._provider.prepareTypeHierarchy(doc, pos, token);
+        if (!items) {
+            return undefined;
+        }
+        const sessionId = this._idPool.nextId();
+        this._cache.set(sessionId, ( (new Map())));
+        if (Array.isArray(items)) {
+            return (
+                 (items.map(item => this._cacheAndConvertItem(sessionId, item)))
+            );
+        }
+        else {
+            return [this._cacheAndConvertItem(sessionId, items)];
+        }
+    }
+    async provideSupertypes(sessionId, itemId, token) {
+        const item = this._itemFromCache(sessionId, itemId);
+        if (!item) {
+            throw new Error('missing type hierarchy item');
+        }
+        const supertypes = await this._provider.provideTypeHierarchySupertypes(item, token);
+        if (!supertypes) {
+            return undefined;
+        }
+        return (
+             (supertypes.map(supertype => {
+                return this._cacheAndConvertItem(sessionId, supertype);
+            }))
+        );
+    }
+    async provideSubtypes(sessionId, itemId, token) {
+        const item = this._itemFromCache(sessionId, itemId);
+        if (!item) {
+            throw new Error('missing type hierarchy item');
+        }
+        const subtypes = await this._provider.provideTypeHierarchySubtypes(item, token);
+        if (!subtypes) {
+            return undefined;
+        }
+        return (
+             (subtypes.map(subtype => {
+                return this._cacheAndConvertItem(sessionId, subtype);
+            }))
+        );
+    }
+    releaseSession(sessionId) {
+        this._cache.delete(sessionId);
+    }
+    _cacheAndConvertItem(sessionId, item) {
+        const map = this._cache.get(sessionId);
+        const dto = TypeHierarchyItem.from(item, sessionId, ( (map.size.toString(36))));
+        map.set(dto._itemId, item);
+        return dto;
+    }
+    _itemFromCache(sessionId, itemId) {
+        const map = this._cache.get(sessionId);
+        return map?.get(itemId);
+    }
+}
+class DocumentOnDropEditAdapter {
+    constructor(_proxy, _documents, _provider, _handle) {
+        this._proxy = _proxy;
+        this._documents = _documents;
+        this._provider = _provider;
+        this._handle = _handle;
+    }
+    async provideDocumentOnDropEdits(requestId, uri, position, dataTransferDto, token) {
+        const doc = this._documents.getDocument(uri);
+        const pos = Position.to(position);
+        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
+            return (await this._proxy.$resolveDocumentOnDropFileData(this._handle, requestId, id)).buffer;
+        });
+        const edit = await this._provider.provideDocumentDropEdits(doc, pos, dataTransfer, token);
+        if (!edit) {
+            return undefined;
+        }
+        return {
+            insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
+            additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
+        };
+    }
+}
+class AdapterData {
+    constructor(adapter, extension) {
+        this.adapter = adapter;
+        this.extension = extension;
+    }
+}
+class ExtHostLanguageFeatures {
+    constructor(mainContext, _uriTransformer, _documents, _commands, _diagnostics, _logService, _apiDeprecation, _extensionTelemetry) {
+        this._uriTransformer = _uriTransformer;
+        this._documents = _documents;
+        this._commands = _commands;
+        this._diagnostics = _diagnostics;
+        this._logService = _logService;
+        this._apiDeprecation = _apiDeprecation;
+        this._extensionTelemetry = _extensionTelemetry;
+        this._adapter = ( (new Map()));
+        this._proxy = ( (mainContext.getProxy(MainContext.MainThreadLanguageFeatures)));
+    }
+    _transformDocumentSelector(selector) {
+        return DocumentSelector.from(selector, this._uriTransformer);
+    }
+    _createDisposable(handle) {
+        return (
+             (new Disposable(() => {
+                this._adapter.delete(handle);
+                this._proxy.$unregister(handle);
+            }))
+        );
+    }
+    _nextHandle() {
+        return ExtHostLanguageFeatures._handlePool++;
+    }
+    async _withAdapter(handle, ctor, callback, fallbackValue, tokenToRaceAgainst, doNotLog = false) {
+        const data = this._adapter.get(handle);
+        if (!data || !(data.adapter instanceof ctor)) {
+            return fallbackValue;
+        }
+        const t1 = Date.now();
+        if (!doNotLog) {
+            this._logService.trace(`[${data.extension.identifier.value}] INVOKE provider '${( ( callback.toString())).replace(/[\r\n]/g, '')}'`);
+        }
+        const result = callback(data.adapter, data.extension);
+        Promise.resolve(result).catch(err => {
+            if (!isCancellationError(err)) {
+                this._logService.error(`[${data.extension.identifier.value}] provider FAILED`);
+                this._logService.error(err);
+                this._extensionTelemetry.onExtensionError(data.extension.identifier, err);
+            }
+        }).finally(() => {
+            if (!doNotLog) {
+                this._logService.trace(`[${data.extension.identifier.value}] provider DONE after ${Date.now() - t1}ms`);
+            }
+        });
+        if (CancellationToken.isCancellationToken(tokenToRaceAgainst)) {
+            return raceCancellationError(result, tokenToRaceAgainst);
+        }
+        return result;
+    }
+    _addNewAdapter(adapter, extension) {
+        const handle = this._nextHandle();
+        this._adapter.set(handle, ( (new AdapterData(adapter, extension))));
+        return handle;
+    }
+    static _extLabel(ext) {
+        return ext.displayName || ext.name;
+    }
+    registerDocumentSymbolProvider(extension, selector, provider, metadata) {
+        const handle = this._addNewAdapter(( (new DocumentSymbolAdapter(this._documents, provider))), extension);
+        const displayName = (metadata && metadata.label) || ExtHostLanguageFeatures._extLabel(extension);
+        this._proxy.$registerDocumentSymbolProvider(handle, this._transformDocumentSelector(selector), displayName);
+        return this._createDisposable(handle);
+    }
+    $provideDocumentSymbols(handle, resource, token) {
+        return this._withAdapter(handle, DocumentSymbolAdapter, adapter => adapter.provideDocumentSymbols(URI.revive(resource), token), undefined, token);
+    }
+    registerCodeLensProvider(extension, selector, provider) {
+        const handle = this._nextHandle();
+        const eventHandle = typeof provider.onDidChangeCodeLenses === 'function' ? this._nextHandle() : undefined;
+        this._adapter.set(handle, ( (new AdapterData(
+             (new CodeLensAdapter(this._documents, this._commands.converter, provider)),
+            extension
+        ))));
+        this._proxy.$registerCodeLensSupport(handle, this._transformDocumentSelector(selector), eventHandle);
+        let result = this._createDisposable(handle);
+        if (eventHandle !== undefined) {
+            const subscription = provider.onDidChangeCodeLenses(_ => this._proxy.$emitCodeLensEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+        return result;
+    }
+    $provideCodeLenses(handle, resource, token) {
+        return this._withAdapter(handle, CodeLensAdapter, adapter => adapter.provideCodeLenses(URI.revive(resource), token), undefined, token);
+    }
+    $resolveCodeLens(handle, symbol, token) {
+        return this._withAdapter(handle, CodeLensAdapter, adapter => adapter.resolveCodeLens(symbol, token), undefined, undefined);
+    }
+    $releaseCodeLenses(handle, cacheId) {
+        this._withAdapter(handle, CodeLensAdapter, adapter => Promise.resolve(adapter.releaseCodeLenses(cacheId)), undefined, undefined);
+    }
+    registerDefinitionProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new DefinitionAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDefinitionSupport(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideDefinition(handle, resource, position, token) {
+        return this._withAdapter(handle, DefinitionAdapter, adapter => adapter.provideDefinition(URI.revive(resource), position, token), [], token);
+    }
+    registerDeclarationProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new DeclarationAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDeclarationSupport(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideDeclaration(handle, resource, position, token) {
+        return this._withAdapter(handle, DeclarationAdapter, adapter => adapter.provideDeclaration(URI.revive(resource), position, token), [], token);
+    }
+    registerImplementationProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new ImplementationAdapter(this._documents, provider))), extension);
+        this._proxy.$registerImplementationSupport(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideImplementation(handle, resource, position, token) {
+        return this._withAdapter(handle, ImplementationAdapter, adapter => adapter.provideImplementation(URI.revive(resource), position, token), [], token);
+    }
+    registerTypeDefinitionProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new TypeDefinitionAdapter(this._documents, provider))), extension);
+        this._proxy.$registerTypeDefinitionSupport(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideTypeDefinition(handle, resource, position, token) {
+        return this._withAdapter(handle, TypeDefinitionAdapter, adapter => adapter.provideTypeDefinition(URI.revive(resource), position, token), [], token);
+    }
+    registerHoverProvider(extension, selector, provider, extensionId) {
+        const handle = this._addNewAdapter(( (new HoverAdapter(this._documents, provider))), extension);
+        this._proxy.$registerHoverProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideHover(handle, resource, position, token) {
+        return this._withAdapter(handle, HoverAdapter, adapter => adapter.provideHover(URI.revive(resource), position, token), undefined, token);
+    }
+    registerEvaluatableExpressionProvider(extension, selector, provider, extensionId) {
+        const handle = this._addNewAdapter(( (new EvaluatableExpressionAdapter(this._documents, provider))), extension);
+        this._proxy.$registerEvaluatableExpressionProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideEvaluatableExpression(handle, resource, position, token) {
+        return this._withAdapter(handle, EvaluatableExpressionAdapter, adapter => adapter.provideEvaluatableExpression(URI.revive(resource), position, token), undefined, token);
+    }
+    registerInlineValuesProvider(extension, selector, provider, extensionId) {
+        const eventHandle = typeof provider.onDidChangeInlineValues === 'function' ? this._nextHandle() : undefined;
+        const handle = this._addNewAdapter(( (new InlineValuesAdapter(this._documents, provider))), extension);
+        this._proxy.$registerInlineValuesProvider(handle, this._transformDocumentSelector(selector), eventHandle);
+        let result = this._createDisposable(handle);
+        if (eventHandle !== undefined) {
+            const subscription = provider.onDidChangeInlineValues(_ => this._proxy.$emitInlineValuesEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+        return result;
+    }
+    $provideInlineValues(handle, resource, range, context, token) {
+        return this._withAdapter(handle, InlineValuesAdapter, adapter => adapter.provideInlineValues(URI.revive(resource), range, context, token), undefined, token);
+    }
+    registerDocumentHighlightProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new DocumentHighlightAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDocumentHighlightProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideDocumentHighlights(handle, resource, position, token) {
+        return this._withAdapter(handle, DocumentHighlightAdapter, adapter => adapter.provideDocumentHighlights(URI.revive(resource), position, token), undefined, token);
+    }
+    registerLinkedEditingRangeProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new LinkedEditingRangeAdapter(this._documents, provider))), extension);
+        this._proxy.$registerLinkedEditingRangeProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideLinkedEditingRanges(handle, resource, position, token) {
+        return this._withAdapter(handle, LinkedEditingRangeAdapter, async (adapter) => {
+            const res = await adapter.provideLinkedEditingRanges(URI.revive(resource), position, token);
+            if (res) {
+                return {
+                    ranges: res.ranges,
+                    wordPattern: res.wordPattern ? ExtHostLanguageFeatures._serializeRegExp(res.wordPattern) : undefined
+                };
+            }
+            return undefined;
+        }, undefined, token);
+    }
+    registerReferenceProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new ReferenceAdapter(this._documents, provider))), extension);
+        this._proxy.$registerReferenceSupport(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideReferences(handle, resource, position, context, token) {
+        return this._withAdapter(handle, ReferenceAdapter, adapter => adapter.provideReferences(URI.revive(resource), position, context, token), undefined, token);
+    }
+    registerCodeActionProvider(extension, selector, provider, metadata) {
+        const store = ( (new DisposableStore()));
+        const handle = this._addNewAdapter(( (new CodeActionAdapter(
+            this._documents,
+            this._commands.converter,
+            this._diagnostics,
+            provider,
+            this._logService,
+            extension,
+            this._apiDeprecation
+        ))), extension);
+        this._proxy.$registerQuickFixSupport(handle, this._transformDocumentSelector(selector), {
+            providedKinds: metadata?.providedCodeActionKinds?.map(kind => kind.value),
+            documentation: metadata?.documentation?.map(x => ({
+                kind: x.kind.value,
+                command: this._commands.converter.toInternal(x.command, store),
+            }))
+        }, ExtHostLanguageFeatures._extLabel(extension), Boolean(provider.resolveCodeAction));
+        store.add(this._createDisposable(handle));
+        return store;
+    }
+    $provideCodeActions(handle, resource, rangeOrSelection, context, token) {
+        return this._withAdapter(handle, CodeActionAdapter, adapter => adapter.provideCodeActions(URI.revive(resource), rangeOrSelection, context, token), undefined, token);
+    }
+    $resolveCodeAction(handle, id, token) {
+        return this._withAdapter(handle, CodeActionAdapter, adapter => adapter.resolveCodeAction(id, token), {}, undefined);
+    }
+    $releaseCodeActions(handle, cacheId) {
+        this._withAdapter(handle, CodeActionAdapter, adapter => Promise.resolve(adapter.releaseCodeActions(cacheId)), undefined, undefined);
+    }
+    registerDocumentFormattingEditProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new DocumentFormattingAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDocumentFormattingSupport(handle, this._transformDocumentSelector(selector), extension.identifier, extension.displayName || extension.name);
+        return this._createDisposable(handle);
+    }
+    $provideDocumentFormattingEdits(handle, resource, options, token) {
+        return this._withAdapter(handle, DocumentFormattingAdapter, adapter => adapter.provideDocumentFormattingEdits(URI.revive(resource), options, token), undefined, token);
+    }
+    registerDocumentRangeFormattingEditProvider(extension, selector, provider) {
+        const canFormatMultipleRanges = typeof provider.provideDocumentRangesFormattingEdits === 'function';
+        if (canFormatMultipleRanges) {
+            checkProposedApiEnabled(extension, 'formatMultipleRanges');
+        }
+        const handle = this._addNewAdapter(( (new RangeFormattingAdapter(this._documents, provider))), extension);
+        this._proxy.$registerRangeFormattingSupport(handle, this._transformDocumentSelector(selector), extension.identifier, extension.displayName || extension.name, canFormatMultipleRanges);
+        return this._createDisposable(handle);
+    }
+    $provideDocumentRangeFormattingEdits(handle, resource, range, options, token) {
+        return this._withAdapter(handle, RangeFormattingAdapter, adapter => adapter.provideDocumentRangeFormattingEdits(URI.revive(resource), range, options, token), undefined, token);
+    }
+    $provideDocumentRangesFormattingEdits(handle, resource, ranges, options, token) {
+        return this._withAdapter(handle, RangeFormattingAdapter, adapter => adapter.provideDocumentRangesFormattingEdits(URI.revive(resource), ranges, options, token), undefined, token);
+    }
+    registerOnTypeFormattingEditProvider(extension, selector, provider, triggerCharacters) {
+        const handle = this._addNewAdapter(( (new OnTypeFormattingAdapter(this._documents, provider))), extension);
+        this._proxy.$registerOnTypeFormattingSupport(handle, this._transformDocumentSelector(selector), triggerCharacters, extension.identifier);
+        return this._createDisposable(handle);
+    }
+    $provideOnTypeFormattingEdits(handle, resource, position, ch, options, token) {
+        return this._withAdapter(handle, OnTypeFormattingAdapter, adapter => adapter.provideOnTypeFormattingEdits(URI.revive(resource), position, ch, options, token), undefined, token);
+    }
+    registerWorkspaceSymbolProvider(extension, provider) {
+        const handle = this._addNewAdapter(( (new NavigateTypeAdapter(provider, this._logService))), extension);
+        this._proxy.$registerNavigateTypeSupport(handle, typeof provider.resolveWorkspaceSymbol === 'function');
+        return this._createDisposable(handle);
+    }
+    $provideWorkspaceSymbols(handle, search, token) {
+        return this._withAdapter(handle, NavigateTypeAdapter, adapter => adapter.provideWorkspaceSymbols(search, token), { symbols: [] }, token);
+    }
+    $resolveWorkspaceSymbol(handle, symbol, token) {
+        return this._withAdapter(handle, NavigateTypeAdapter, adapter => adapter.resolveWorkspaceSymbol(symbol, token), undefined, undefined);
+    }
+    $releaseWorkspaceSymbols(handle, id) {
+        this._withAdapter(handle, NavigateTypeAdapter, adapter => adapter.releaseWorkspaceSymbols(id), undefined, undefined);
+    }
+    registerRenameProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new RenameAdapter(this._documents, provider, this._logService))), extension);
+        this._proxy.$registerRenameSupport(handle, this._transformDocumentSelector(selector), RenameAdapter.supportsResolving(provider));
+        return this._createDisposable(handle);
+    }
+    $provideRenameEdits(handle, resource, position, newName, token) {
+        return this._withAdapter(handle, RenameAdapter, adapter => adapter.provideRenameEdits(URI.revive(resource), position, newName, token), undefined, token);
+    }
+    $resolveRenameLocation(handle, resource, position, token) {
+        return this._withAdapter(handle, RenameAdapter, adapter => adapter.resolveRenameLocation(URI.revive(resource), position, token), undefined, token);
+    }
+    registerDocumentSemanticTokensProvider(extension, selector, provider, legend) {
+        const handle = this._addNewAdapter(( (new DocumentSemanticTokensAdapter(this._documents, provider))), extension);
+        const eventHandle = (typeof provider.onDidChangeSemanticTokens === 'function' ? this._nextHandle() : undefined);
+        this._proxy.$registerDocumentSemanticTokensProvider(handle, this._transformDocumentSelector(selector), legend, eventHandle);
+        let result = this._createDisposable(handle);
+        if (eventHandle) {
+            const subscription = provider.onDidChangeSemanticTokens(_ => this._proxy.$emitDocumentSemanticTokensEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+        return result;
+    }
+    $provideDocumentSemanticTokens(handle, resource, previousResultId, token) {
+        return this._withAdapter(handle, DocumentSemanticTokensAdapter, adapter => adapter.provideDocumentSemanticTokens(URI.revive(resource), previousResultId, token), null, token);
+    }
+    $releaseDocumentSemanticTokens(handle, semanticColoringResultId) {
+        this._withAdapter(handle, DocumentSemanticTokensAdapter, adapter => adapter.releaseDocumentSemanticColoring(semanticColoringResultId), undefined, undefined);
+    }
+    registerDocumentRangeSemanticTokensProvider(extension, selector, provider, legend) {
+        const handle = this._addNewAdapter(( (new DocumentRangeSemanticTokensAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDocumentRangeSemanticTokensProvider(handle, this._transformDocumentSelector(selector), legend);
+        return this._createDisposable(handle);
+    }
+    $provideDocumentRangeSemanticTokens(handle, resource, range, token) {
+        return this._withAdapter(handle, DocumentRangeSemanticTokensAdapter, adapter => adapter.provideDocumentRangeSemanticTokens(URI.revive(resource), range, token), null, token);
+    }
+    registerCompletionItemProvider(extension, selector, provider, triggerCharacters) {
+        const handle = this._addNewAdapter(( (new CompletionsAdapter(
+            this._documents,
+            this._commands.converter,
+            provider,
+            this._apiDeprecation,
+            extension
+        ))), extension);
+        this._proxy.$registerCompletionsProvider(handle, this._transformDocumentSelector(selector), triggerCharacters, CompletionsAdapter.supportsResolving(provider), `${extension.identifier.value}(${triggerCharacters.join('')})`);
+        return this._createDisposable(handle);
+    }
+    $provideCompletionItems(handle, resource, position, context, token) {
+        return this._withAdapter(handle, CompletionsAdapter, adapter => adapter.provideCompletionItems(URI.revive(resource), position, context, token), undefined, token);
+    }
+    $resolveCompletionItem(handle, id, token) {
+        return this._withAdapter(handle, CompletionsAdapter, adapter => adapter.resolveCompletionItem(id, token), undefined, token);
+    }
+    $releaseCompletionItems(handle, id) {
+        this._withAdapter(handle, CompletionsAdapter, adapter => adapter.releaseCompletionItems(id), undefined, undefined);
+    }
+    registerInlineCompletionsProvider(extension, selector, provider) {
+        const adapter = ( (new InlineCompletionAdapter(extension, this._documents, provider, this._commands.converter)));
+        const handle = this._addNewAdapter(adapter, extension);
+        this._proxy.$registerInlineCompletionsSupport(handle, this._transformDocumentSelector(selector), adapter.supportsHandleEvents);
+        return this._createDisposable(handle);
+    }
+    $provideInlineCompletions(handle, resource, position, context, token) {
+        return this._withAdapter(handle, InlineCompletionAdapterBase, adapter => adapter.provideInlineCompletions(URI.revive(resource), position, context, token), undefined, token);
+    }
+    $handleInlineCompletionDidShow(handle, pid, idx) {
+        this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => {
+            adapter.handleDidShowCompletionItem(pid, idx);
+        }, undefined, undefined);
+    }
+    $handleInlineCompletionPartialAccept(handle, pid, idx, acceptedCharacters) {
+        this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => {
+            adapter.handlePartialAccept(pid, idx, acceptedCharacters);
+        }, undefined, undefined);
+    }
+    $freeInlineCompletionsList(handle, pid) {
+        this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => { adapter.disposeCompletions(pid); }, undefined, undefined);
+    }
+    registerSignatureHelpProvider(extension, selector, provider, metadataOrTriggerChars) {
+        const metadata = Array.isArray(metadataOrTriggerChars)
+            ? { triggerCharacters: metadataOrTriggerChars, retriggerCharacters: [] }
+            : metadataOrTriggerChars;
+        const handle = this._addNewAdapter(( (new SignatureHelpAdapter(this._documents, provider))), extension);
+        this._proxy.$registerSignatureHelpProvider(handle, this._transformDocumentSelector(selector), metadata);
+        return this._createDisposable(handle);
+    }
+    $provideSignatureHelp(handle, resource, position, context, token) {
+        return this._withAdapter(handle, SignatureHelpAdapter, adapter => adapter.provideSignatureHelp(URI.revive(resource), position, context, token), undefined, token);
+    }
+    $releaseSignatureHelp(handle, id) {
+        this._withAdapter(handle, SignatureHelpAdapter, adapter => adapter.releaseSignatureHelp(id), undefined, undefined);
+    }
+    registerInlayHintsProvider(extension, selector, provider) {
+        const eventHandle = typeof provider.onDidChangeInlayHints === 'function' ? this._nextHandle() : undefined;
+        const handle = this._addNewAdapter(( (new InlayHintsAdapter(
+            this._documents,
+            this._commands.converter,
+            provider,
+            this._logService,
+            extension
+        ))), extension);
+        this._proxy.$registerInlayHintsProvider(handle, this._transformDocumentSelector(selector), typeof provider.resolveInlayHint === 'function', eventHandle, ExtHostLanguageFeatures._extLabel(extension));
+        let result = this._createDisposable(handle);
+        if (eventHandle !== undefined) {
+            const subscription = provider.onDidChangeInlayHints(uri => this._proxy.$emitInlayHintsEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+        return result;
+    }
+    $provideInlayHints(handle, resource, range, token) {
+        return this._withAdapter(handle, InlayHintsAdapter, adapter => adapter.provideInlayHints(URI.revive(resource), range, token), undefined, token);
+    }
+    $resolveInlayHint(handle, id, token) {
+        return this._withAdapter(handle, InlayHintsAdapter, adapter => adapter.resolveInlayHint(id, token), undefined, token);
+    }
+    $releaseInlayHints(handle, id) {
+        this._withAdapter(handle, InlayHintsAdapter, adapter => adapter.releaseHints(id), undefined, undefined);
+    }
+    registerDocumentLinkProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new LinkProviderAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDocumentLinkProvider(handle, this._transformDocumentSelector(selector), typeof provider.resolveDocumentLink === 'function');
+        return this._createDisposable(handle);
+    }
+    $provideDocumentLinks(handle, resource, token) {
+        return this._withAdapter(handle, LinkProviderAdapter, adapter => adapter.provideLinks(URI.revive(resource), token), undefined, token, resource.scheme === 'output');
+    }
+    $resolveDocumentLink(handle, id, token) {
+        return this._withAdapter(handle, LinkProviderAdapter, adapter => adapter.resolveLink(id, token), undefined, undefined, true);
+    }
+    $releaseDocumentLinks(handle, id) {
+        this._withAdapter(handle, LinkProviderAdapter, adapter => adapter.releaseLinks(id), undefined, undefined, true);
+    }
+    registerColorProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new ColorProviderAdapter(this._documents, provider))), extension);
+        this._proxy.$registerDocumentColorProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideDocumentColors(handle, resource, token) {
+        return this._withAdapter(handle, ColorProviderAdapter, adapter => adapter.provideColors(URI.revive(resource), token), [], token);
+    }
+    $provideColorPresentations(handle, resource, colorInfo, token) {
+        return this._withAdapter(handle, ColorProviderAdapter, adapter => adapter.provideColorPresentations(URI.revive(resource), colorInfo, token), undefined, token);
+    }
+    registerFoldingRangeProvider(extension, selector, provider) {
+        const handle = this._nextHandle();
+        const eventHandle = typeof provider.onDidChangeFoldingRanges === 'function' ? this._nextHandle() : undefined;
+        this._adapter.set(handle, ( (new AdapterData(
+             (new FoldingProviderAdapter(this._documents, provider)),
+            extension
+        ))));
+        this._proxy.$registerFoldingRangeProvider(handle, this._transformDocumentSelector(selector), extension.identifier, eventHandle);
+        let result = this._createDisposable(handle);
+        if (eventHandle !== undefined) {
+            const subscription = provider.onDidChangeFoldingRanges(() => this._proxy.$emitFoldingRangeEvent(eventHandle));
+            result = Disposable.from(result, subscription);
+        }
+        return result;
+    }
+    $provideFoldingRanges(handle, resource, context, token) {
+        return this._withAdapter(handle, FoldingProviderAdapter, adapter => adapter.provideFoldingRanges(URI.revive(resource), context, token), undefined, token);
+    }
+    registerSelectionRangeProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new SelectionRangeAdapter(this._documents, provider, this._logService))), extension);
+        this._proxy.$registerSelectionRangeProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideSelectionRanges(handle, resource, positions, token) {
+        return this._withAdapter(handle, SelectionRangeAdapter, adapter => adapter.provideSelectionRanges(URI.revive(resource), positions, token), [], token);
+    }
+    registerCallHierarchyProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new CallHierarchyAdapter(this._documents, provider))), extension);
+        this._proxy.$registerCallHierarchyProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $prepareCallHierarchy(handle, resource, position, token) {
+        return this._withAdapter(handle, CallHierarchyAdapter, adapter => Promise.resolve(adapter.prepareSession(URI.revive(resource), position, token)), undefined, token);
+    }
+    $provideCallHierarchyIncomingCalls(handle, sessionId, itemId, token) {
+        return this._withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideCallsTo(sessionId, itemId, token), undefined, token);
+    }
+    $provideCallHierarchyOutgoingCalls(handle, sessionId, itemId, token) {
+        return this._withAdapter(handle, CallHierarchyAdapter, adapter => adapter.provideCallsFrom(sessionId, itemId, token), undefined, token);
+    }
+    $releaseCallHierarchy(handle, sessionId) {
+        this._withAdapter(handle, CallHierarchyAdapter, adapter => Promise.resolve(adapter.releaseSession(sessionId)), undefined, undefined);
+    }
+    registerTypeHierarchyProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( (new TypeHierarchyAdapter(this._documents, provider))), extension);
+        this._proxy.$registerTypeHierarchyProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $prepareTypeHierarchy(handle, resource, position, token) {
+        return this._withAdapter(handle, TypeHierarchyAdapter, adapter => Promise.resolve(adapter.prepareSession(URI.revive(resource), position, token)), undefined, token);
+    }
+    $provideTypeHierarchySupertypes(handle, sessionId, itemId, token) {
+        return this._withAdapter(handle, TypeHierarchyAdapter, adapter => adapter.provideSupertypes(sessionId, itemId, token), undefined, token);
+    }
+    $provideTypeHierarchySubtypes(handle, sessionId, itemId, token) {
+        return this._withAdapter(handle, TypeHierarchyAdapter, adapter => adapter.provideSubtypes(sessionId, itemId, token), undefined, token);
+    }
+    $releaseTypeHierarchy(handle, sessionId) {
+        this._withAdapter(handle, TypeHierarchyAdapter, adapter => Promise.resolve(adapter.releaseSession(sessionId)), undefined, undefined);
+    }
+    registerDocumentOnDropEditProvider(extension, selector, provider) {
+        const handle = this._nextHandle();
+        this._adapter.set(handle, ( (new AdapterData(
+             (new DocumentOnDropEditAdapter(this._proxy, this._documents, provider, handle)),
+            extension
+        ))));
+        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector));
+        return this._createDisposable(handle);
+    }
+    $provideDocumentOnDropEdits(handle, requestId, resource, position, dataTransferDto, token) {
+        return this._withAdapter(handle, DocumentOnDropEditAdapter, adapter => Promise.resolve(adapter.provideDocumentOnDropEdits(requestId, URI.revive(resource), position, dataTransferDto, token)), undefined, undefined);
+    }
+    registerDocumentPasteEditProvider(extension, selector, provider, metadata) {
+        const handle = this._nextHandle();
+        this._adapter.set(handle, ( (new AdapterData(
+             (new DocumentPasteEditProvider(this._proxy, this._documents, provider, handle)),
+            extension
+        ))));
+        this._proxy.$registerPasteEditProvider(handle, this._transformDocumentSelector(selector), !!provider.prepareDocumentPaste, metadata.pasteMimeTypes);
+        return this._createDisposable(handle);
+    }
+    $prepareDocumentPaste(handle, resource, ranges, dataTransfer, token) {
+        return this._withAdapter(handle, DocumentPasteEditProvider, adapter => adapter.prepareDocumentPaste(URI.revive(resource), ranges, dataTransfer, token), undefined, token);
+    }
+    $providePasteEdits(handle, requestId, resource, ranges, dataTransferDto, token) {
+        return this._withAdapter(handle, DocumentPasteEditProvider, adapter => adapter.providePasteEdits(requestId, URI.revive(resource), ranges, dataTransferDto, token), undefined, token);
+    }
+    static _serializeRegExp(regExp) {
+        return {
+            pattern: regExp.source,
+            flags: regExpFlags(regExp),
+        };
+    }
+    static _serializeIndentationRule(indentationRule) {
+        return {
+            decreaseIndentPattern: ExtHostLanguageFeatures._serializeRegExp(indentationRule.decreaseIndentPattern),
+            increaseIndentPattern: ExtHostLanguageFeatures._serializeRegExp(indentationRule.increaseIndentPattern),
+            indentNextLinePattern: indentationRule.indentNextLinePattern ? ExtHostLanguageFeatures._serializeRegExp(indentationRule.indentNextLinePattern) : undefined,
+            unIndentedLinePattern: indentationRule.unIndentedLinePattern ? ExtHostLanguageFeatures._serializeRegExp(indentationRule.unIndentedLinePattern) : undefined,
+        };
+    }
+    static _serializeOnEnterRule(onEnterRule) {
+        return {
+            beforeText: ExtHostLanguageFeatures._serializeRegExp(onEnterRule.beforeText),
+            afterText: onEnterRule.afterText ? ExtHostLanguageFeatures._serializeRegExp(onEnterRule.afterText) : undefined,
+            previousLineText: onEnterRule.previousLineText ? ExtHostLanguageFeatures._serializeRegExp(onEnterRule.previousLineText) : undefined,
+            action: onEnterRule.action
+        };
+    }
+    static _serializeOnEnterRules(onEnterRules) {
+        return (
+             (onEnterRules.map(ExtHostLanguageFeatures._serializeOnEnterRule))
+        );
+    }
+    setLanguageConfiguration(extension, languageId, configuration) {
+        const { wordPattern } = configuration;
+        if (wordPattern && regExpLeadsToEndlessLoop(wordPattern)) {
+            throw new Error(`Invalid language configuration: wordPattern '${wordPattern}' is not allowed to match the empty string.`);
+        }
+        if (wordPattern) {
+            this._documents.setWordDefinitionFor(languageId, wordPattern);
+        }
+        else {
+            this._documents.setWordDefinitionFor(languageId, undefined);
+        }
+        if (configuration.__electricCharacterSupport) {
+            this._apiDeprecation.report('LanguageConfiguration.__electricCharacterSupport', extension, `Do not use.`);
+        }
+        if (configuration.__characterPairSupport) {
+            this._apiDeprecation.report('LanguageConfiguration.__characterPairSupport', extension, `Do not use.`);
+        }
+        const handle = this._nextHandle();
+        const serializedConfiguration = {
+            comments: configuration.comments,
+            brackets: configuration.brackets,
+            wordPattern: configuration.wordPattern ? ExtHostLanguageFeatures._serializeRegExp(configuration.wordPattern) : undefined,
+            indentationRules: configuration.indentationRules ? ExtHostLanguageFeatures._serializeIndentationRule(configuration.indentationRules) : undefined,
+            onEnterRules: configuration.onEnterRules ? ExtHostLanguageFeatures._serializeOnEnterRules(configuration.onEnterRules) : undefined,
+            __electricCharacterSupport: configuration.__electricCharacterSupport,
+            __characterPairSupport: configuration.__characterPairSupport,
+        };
+        this._proxy.$setLanguageConfiguration(handle, languageId, serializedConfiguration);
+        return this._createDisposable(handle);
+    }
+    $setWordDefinitions(wordDefinitions) {
+        for (const wordDefinition of wordDefinitions) {
+            this._documents.setWordDefinitionFor(wordDefinition.languageId, ( (new RegExp(wordDefinition.regexSource, wordDefinition.regexFlags))));
+        }
+    }
+}
+ExtHostLanguageFeatures._handlePool = 0;
+export { ExtHostLanguageFeatures };