css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,876 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConverter = void 0;
-const code = require("vscode");
-const proto = require("vscode-languageserver-protocol");
-const Is = require("./utils/is");
-const async = require("./utils/async");
-const protocolCompletionItem_1 = require("./protocolCompletionItem");
-const protocolCodeLens_1 = require("./protocolCodeLens");
-const protocolDocumentLink_1 = require("./protocolDocumentLink");
-const protocolCodeAction_1 = require("./protocolCodeAction");
-const protocolDiagnostic_1 = require("./protocolDiagnostic");
-const protocolCallHierarchyItem_1 = require("./protocolCallHierarchyItem");
-const protocolTypeHierarchyItem_1 = require("./protocolTypeHierarchyItem");
-const protocolWorkspaceSymbol_1 = require("./protocolWorkspaceSymbol");
-const protocolInlayHint_1 = require("./protocolInlayHint");
-var InsertReplaceRange;
-(function (InsertReplaceRange) {
-    function is(value) {
-        const candidate = value;
-        return candidate && !!candidate.inserting && !!candidate.replacing;
-    }
-    InsertReplaceRange.is = is;
-})(InsertReplaceRange || (InsertReplaceRange = {}));
-function createConverter(uriConverter) {
-    const nullConverter = (value) => value.toString();
-    const _uriConverter = uriConverter || nullConverter;
-    function asUri(value) {
-        return _uriConverter(value);
-    }
-    function asTextDocumentIdentifier(textDocument) {
-        return {
-            uri: _uriConverter(textDocument.uri)
-        };
-    }
-    function asTextDocumentItem(textDocument) {
-        return {
-            uri: _uriConverter(textDocument.uri),
-            languageId: textDocument.languageId,
-            version: textDocument.version,
-            text: textDocument.getText()
-        };
-    }
-    function asVersionedTextDocumentIdentifier(textDocument) {
-        return {
-            uri: _uriConverter(textDocument.uri),
-            version: textDocument.version
-        };
-    }
-    function asOpenTextDocumentParams(textDocument) {
-        return {
-            textDocument: asTextDocumentItem(textDocument)
-        };
-    }
-    function isTextDocumentChangeEvent(value) {
-        const candidate = value;
-        return !!candidate.document && !!candidate.contentChanges;
-    }
-    function isTextDocument(value) {
-        const candidate = value;
-        return !!candidate.uri && !!candidate.version;
-    }
-    function asChangeTextDocumentParams(arg0, arg1, arg2) {
-        if (isTextDocument(arg0)) {
-            const result = {
-                textDocument: {
-                    uri: _uriConverter(arg0.uri),
-                    version: arg0.version
-                },
-                contentChanges: [{ text: arg0.getText() }]
-            };
-            return result;
-        }
-        else if (isTextDocumentChangeEvent(arg0)) {
-            const uri = arg1;
-            const version = arg2;
-            const result = {
-                textDocument: {
-                    uri: _uriConverter(uri),
-                    version: version
-                },
-                contentChanges: arg0.contentChanges.map((change) => {
-                    const range = change.range;
-                    return {
-                        range: {
-                            start: { line: range.start.line, character: range.start.character },
-                            end: { line: range.end.line, character: range.end.character }
-                        },
-                        rangeLength: change.rangeLength,
-                        text: change.text
-                    };
-                })
-            };
-            return result;
-        }
-        else {
-            throw Error('Unsupported text document change parameter');
-        }
-    }
-    function asCloseTextDocumentParams(textDocument) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument)
-        };
-    }
-    function asSaveTextDocumentParams(textDocument, includeContent = false) {
-        let result = {
-            textDocument: asTextDocumentIdentifier(textDocument)
-        };
-        if (includeContent) {
-            result.text = textDocument.getText();
-        }
-        return result;
-    }
-    function asTextDocumentSaveReason(reason) {
-        switch (reason) {
-            case code.TextDocumentSaveReason.Manual:
-                return proto.TextDocumentSaveReason.Manual;
-            case code.TextDocumentSaveReason.AfterDelay:
-                return proto.TextDocumentSaveReason.AfterDelay;
-            case code.TextDocumentSaveReason.FocusOut:
-                return proto.TextDocumentSaveReason.FocusOut;
-        }
-        return proto.TextDocumentSaveReason.Manual;
-    }
-    function asWillSaveTextDocumentParams(event) {
-        return {
-            textDocument: asTextDocumentIdentifier(event.document),
-            reason: asTextDocumentSaveReason(event.reason)
-        };
-    }
-    function asDidCreateFilesParams(event) {
-        return {
-            files: event.files.map((fileUri) => ({
-                uri: _uriConverter(fileUri),
-            })),
-        };
-    }
-    function asDidRenameFilesParams(event) {
-        return {
-            files: event.files.map((file) => ({
-                oldUri: _uriConverter(file.oldUri),
-                newUri: _uriConverter(file.newUri),
-            })),
-        };
-    }
-    function asDidDeleteFilesParams(event) {
-        return {
-            files: event.files.map((fileUri) => ({
-                uri: _uriConverter(fileUri),
-            })),
-        };
-    }
-    function asWillCreateFilesParams(event) {
-        return {
-            files: event.files.map((fileUri) => ({
-                uri: _uriConverter(fileUri),
-            })),
-        };
-    }
-    function asWillRenameFilesParams(event) {
-        return {
-            files: event.files.map((file) => ({
-                oldUri: _uriConverter(file.oldUri),
-                newUri: _uriConverter(file.newUri),
-            })),
-        };
-    }
-    function asWillDeleteFilesParams(event) {
-        return {
-            files: event.files.map((fileUri) => ({
-                uri: _uriConverter(fileUri),
-            })),
-        };
-    }
-    function asTextDocumentPositionParams(textDocument, position) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument),
-            position: asWorkerPosition(position)
-        };
-    }
-    function asCompletionTriggerKind(triggerKind) {
-        switch (triggerKind) {
-            case code.CompletionTriggerKind.TriggerCharacter:
-                return proto.CompletionTriggerKind.TriggerCharacter;
-            case code.CompletionTriggerKind.TriggerForIncompleteCompletions:
-                return proto.CompletionTriggerKind.TriggerForIncompleteCompletions;
-            default:
-                return proto.CompletionTriggerKind.Invoked;
-        }
-    }
-    function asCompletionParams(textDocument, position, context) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument),
-            position: asWorkerPosition(position),
-            context: {
-                triggerKind: asCompletionTriggerKind(context.triggerKind),
-                triggerCharacter: context.triggerCharacter
-            }
-        };
-    }
-    function asSignatureHelpTriggerKind(triggerKind) {
-        switch (triggerKind) {
-            case code.SignatureHelpTriggerKind.Invoke:
-                return proto.SignatureHelpTriggerKind.Invoked;
-            case code.SignatureHelpTriggerKind.TriggerCharacter:
-                return proto.SignatureHelpTriggerKind.TriggerCharacter;
-            case code.SignatureHelpTriggerKind.ContentChange:
-                return proto.SignatureHelpTriggerKind.ContentChange;
-        }
-    }
-    function asParameterInformation(value) {
-        // We leave the documentation out on purpose since it usually adds no
-        // value for the server.
-        return {
-            label: value.label
-        };
-    }
-    function asParameterInformations(values) {
-        return values.map(asParameterInformation);
-    }
-    function asSignatureInformation(value) {
-        // We leave the documentation out on purpose since it usually adds no
-        // value for the server.
-        return {
-            label: value.label,
-            parameters: asParameterInformations(value.parameters)
-        };
-    }
-    function asSignatureInformations(values) {
-        return values.map(asSignatureInformation);
-    }
-    function asSignatureHelp(value) {
-        if (value === undefined) {
-            return value;
-        }
-        return {
-            signatures: asSignatureInformations(value.signatures),
-            activeSignature: value.activeSignature,
-            activeParameter: value.activeParameter
-        };
-    }
-    function asSignatureHelpParams(textDocument, position, context) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument),
-            position: asWorkerPosition(position),
-            context: {
-                isRetrigger: context.isRetrigger,
-                triggerCharacter: context.triggerCharacter,
-                triggerKind: asSignatureHelpTriggerKind(context.triggerKind),
-                activeSignatureHelp: asSignatureHelp(context.activeSignatureHelp)
-            }
-        };
-    }
-    function asWorkerPosition(position) {
-        return { line: position.line, character: position.character };
-    }
-    function asPosition(value) {
-        if (value === undefined || value === null) {
-            return value;
-        }
-        return { line: value.line > proto.uinteger.MAX_VALUE ? proto.uinteger.MAX_VALUE : value.line, character: value.character > proto.uinteger.MAX_VALUE ? proto.uinteger.MAX_VALUE : value.character };
-    }
-    function asPositions(values, token) {
-        return async.map(values, asPosition, token);
-    }
-    function asPositionsSync(values) {
-        return values.map(asPosition);
-    }
-    function asRange(value) {
-        if (value === undefined || value === null) {
-            return value;
-        }
-        return { start: asPosition(value.start), end: asPosition(value.end) };
-    }
-    function asRanges(values) {
-        return values.map(asRange);
-    }
-    function asLocation(value) {
-        if (value === undefined || value === null) {
-            return value;
-        }
-        return proto.Location.create(asUri(value.uri), asRange(value.range));
-    }
-    function asDiagnosticSeverity(value) {
-        switch (value) {
-            case code.DiagnosticSeverity.Error:
-                return proto.DiagnosticSeverity.Error;
-            case code.DiagnosticSeverity.Warning:
-                return proto.DiagnosticSeverity.Warning;
-            case code.DiagnosticSeverity.Information:
-                return proto.DiagnosticSeverity.Information;
-            case code.DiagnosticSeverity.Hint:
-                return proto.DiagnosticSeverity.Hint;
-        }
-    }
-    function asDiagnosticTags(tags) {
-        if (!tags) {
-            return undefined;
-        }
-        let result = [];
-        for (let tag of tags) {
-            let converted = asDiagnosticTag(tag);
-            if (converted !== undefined) {
-                result.push(converted);
-            }
-        }
-        return result.length > 0 ? result : undefined;
-    }
-    function asDiagnosticTag(tag) {
-        switch (tag) {
-            case code.DiagnosticTag.Unnecessary:
-                return proto.DiagnosticTag.Unnecessary;
-            case code.DiagnosticTag.Deprecated:
-                return proto.DiagnosticTag.Deprecated;
-            default:
-                return undefined;
-        }
-    }
-    function asRelatedInformation(item) {
-        return {
-            message: item.message,
-            location: asLocation(item.location)
-        };
-    }
-    function asRelatedInformations(items) {
-        return items.map(asRelatedInformation);
-    }
-    function asDiagnosticCode(value) {
-        if (value === undefined || value === null) {
-            return undefined;
-        }
-        if (Is.number(value) || Is.string(value)) {
-            return value;
-        }
-        return { value: value.value, target: asUri(value.target) };
-    }
-    function asDiagnostic(item) {
-        const result = proto.Diagnostic.create(asRange(item.range), item.message);
-        const protocolDiagnostic = item instanceof protocolDiagnostic_1.ProtocolDiagnostic ? item : undefined;
-        if (protocolDiagnostic !== undefined && protocolDiagnostic.data !== undefined) {
-            result.data = protocolDiagnostic.data;
-        }
-        const code = asDiagnosticCode(item.code);
-        if (protocolDiagnostic_1.DiagnosticCode.is(code)) {
-            if (protocolDiagnostic !== undefined && protocolDiagnostic.hasDiagnosticCode) {
-                result.code = code;
-            }
-            else {
-                result.code = code.value;
-                result.codeDescription = { href: code.target };
-            }
-        }
-        else {
-            result.code = code;
-        }
-        if (Is.number(item.severity)) {
-            result.severity = asDiagnosticSeverity(item.severity);
-        }
-        if (Array.isArray(item.tags)) {
-            result.tags = asDiagnosticTags(item.tags);
-        }
-        if (item.relatedInformation) {
-            result.relatedInformation = asRelatedInformations(item.relatedInformation);
-        }
-        if (item.source) {
-            result.source = item.source;
-        }
-        return result;
-    }
-    function asDiagnostics(items, token) {
-        if (items === undefined || items === null) {
-            return items;
-        }
-        return async.map(items, asDiagnostic, token);
-    }
-    function asDiagnosticsSync(items) {
-        if (items === undefined || items === null) {
-            return items;
-        }
-        return items.map(asDiagnostic);
-    }
-    function asDocumentation(format, documentation) {
-        switch (format) {
-            case '$string':
-                return documentation;
-            case proto.MarkupKind.PlainText:
-                return { kind: format, value: documentation };
-            case proto.MarkupKind.Markdown:
-                return { kind: format, value: documentation.value };
-            default:
-                return `Unsupported Markup content received. Kind is: ${format}`;
-        }
-    }
-    function asCompletionItemTag(tag) {
-        switch (tag) {
-            case code.CompletionItemTag.Deprecated:
-                return proto.CompletionItemTag.Deprecated;
-        }
-        return undefined;
-    }
-    function asCompletionItemTags(tags) {
-        if (tags === undefined) {
-            return tags;
-        }
-        const result = [];
-        for (let tag of tags) {
-            const converted = asCompletionItemTag(tag);
-            if (converted !== undefined) {
-                result.push(converted);
-            }
-        }
-        return result;
-    }
-    function asCompletionItemKind(value, original) {
-        if (original !== undefined) {
-            return original;
-        }
-        return value + 1;
-    }
-    function asCompletionItem(item, labelDetailsSupport = false) {
-        let label;
-        let labelDetails;
-        if (Is.string(item.label)) {
-            label = item.label;
-        }
-        else {
-            label = item.label.label;
-            if (labelDetailsSupport && (item.label.detail !== undefined || item.label.description !== undefined)) {
-                labelDetails = { detail: item.label.detail, description: item.label.description };
-            }
-        }
-        let result = { label: label };
-        if (labelDetails !== undefined) {
-            result.labelDetails = labelDetails;
-        }
-        let protocolItem = item instanceof protocolCompletionItem_1.default ? item : undefined;
-        if (item.detail) {
-            result.detail = item.detail;
-        }
-        // We only send items back we created. So this can't be something else than
-        // a string right now.
-        if (item.documentation) {
-            if (!protocolItem || protocolItem.documentationFormat === '$string') {
-                result.documentation = item.documentation;
-            }
-            else {
-                result.documentation = asDocumentation(protocolItem.documentationFormat, item.documentation);
-            }
-        }
-        if (item.filterText) {
-            result.filterText = item.filterText;
-        }
-        fillPrimaryInsertText(result, item);
-        if (Is.number(item.kind)) {
-            result.kind = asCompletionItemKind(item.kind, protocolItem && protocolItem.originalItemKind);
-        }
-        if (item.sortText) {
-            result.sortText = item.sortText;
-        }
-        if (item.additionalTextEdits) {
-            result.additionalTextEdits = asTextEdits(item.additionalTextEdits);
-        }
-        if (item.commitCharacters) {
-            result.commitCharacters = item.commitCharacters.slice();
-        }
-        if (item.command) {
-            result.command = asCommand(item.command);
-        }
-        if (item.preselect === true || item.preselect === false) {
-            result.preselect = item.preselect;
-        }
-        const tags = asCompletionItemTags(item.tags);
-        if (protocolItem) {
-            if (protocolItem.data !== undefined) {
-                result.data = protocolItem.data;
-            }
-            if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
-                if (protocolItem.deprecated === true && tags !== undefined && tags.length > 0) {
-                    const index = tags.indexOf(code.CompletionItemTag.Deprecated);
-                    if (index !== -1) {
-                        tags.splice(index, 1);
-                    }
-                }
-                result.deprecated = protocolItem.deprecated;
-            }
-            if (protocolItem.insertTextMode !== undefined) {
-                result.insertTextMode = protocolItem.insertTextMode;
-            }
-        }
-        if (tags !== undefined && tags.length > 0) {
-            result.tags = tags;
-        }
-        if (result.insertTextMode === undefined && item.keepWhitespace === true) {
-            result.insertTextMode = proto.InsertTextMode.adjustIndentation;
-        }
-        return result;
-    }
-    function fillPrimaryInsertText(target, source) {
-        let format = proto.InsertTextFormat.PlainText;
-        let text = undefined;
-        let range = undefined;
-        if (source.textEdit) {
-            text = source.textEdit.newText;
-            range = source.textEdit.range;
-        }
-        else if (source.insertText instanceof code.SnippetString) {
-            format = proto.InsertTextFormat.Snippet;
-            text = source.insertText.value;
-        }
-        else {
-            text = source.insertText;
-        }
-        if (source.range) {
-            range = source.range;
-        }
-        target.insertTextFormat = format;
-        if (source.fromEdit && text !== undefined && range !== undefined) {
-            target.textEdit = asCompletionTextEdit(text, range);
-        }
-        else {
-            target.insertText = text;
-        }
-    }
-    function asCompletionTextEdit(newText, range) {
-        if (InsertReplaceRange.is(range)) {
-            return proto.InsertReplaceEdit.create(newText, asRange(range.inserting), asRange(range.replacing));
-        }
-        else {
-            return { newText, range: asRange(range) };
-        }
-    }
-    function asTextEdit(edit) {
-        return { range: asRange(edit.range), newText: edit.newText };
-    }
-    function asTextEdits(edits) {
-        if (edits === undefined || edits === null) {
-            return edits;
-        }
-        return edits.map(asTextEdit);
-    }
-    function asSymbolKind(item) {
-        if (item <= code.SymbolKind.TypeParameter) {
-            // Symbol kind is one based in the protocol and zero based in code.
-            return (item + 1);
-        }
-        return proto.SymbolKind.Property;
-    }
-    function asSymbolTag(item) {
-        return item;
-    }
-    function asSymbolTags(items) {
-        return items.map(asSymbolTag);
-    }
-    function asReferenceParams(textDocument, position, options) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument),
-            position: asWorkerPosition(position),
-            context: { includeDeclaration: options.includeDeclaration }
-        };
-    }
-    async function asCodeAction(item, token) {
-        let result = proto.CodeAction.create(item.title);
-        if (item instanceof protocolCodeAction_1.default && item.data !== undefined) {
-            result.data = item.data;
-        }
-        if (item.kind !== undefined) {
-            result.kind = asCodeActionKind(item.kind);
-        }
-        if (item.diagnostics !== undefined) {
-            result.diagnostics = await asDiagnostics(item.diagnostics, token);
-        }
-        if (item.edit !== undefined) {
-            throw new Error(`VS Code code actions can only be converted to a protocol code action without an edit.`);
-        }
-        if (item.command !== undefined) {
-            result.command = asCommand(item.command);
-        }
-        if (item.isPreferred !== undefined) {
-            result.isPreferred = item.isPreferred;
-        }
-        if (item.disabled !== undefined) {
-            result.disabled = { reason: item.disabled.reason };
-        }
-        return result;
-    }
-    function asCodeActionSync(item) {
-        let result = proto.CodeAction.create(item.title);
-        if (item instanceof protocolCodeAction_1.default && item.data !== undefined) {
-            result.data = item.data;
-        }
-        if (item.kind !== undefined) {
-            result.kind = asCodeActionKind(item.kind);
-        }
-        if (item.diagnostics !== undefined) {
-            result.diagnostics = asDiagnosticsSync(item.diagnostics);
-        }
-        if (item.edit !== undefined) {
-            throw new Error(`VS Code code actions can only be converted to a protocol code action without an edit.`);
-        }
-        if (item.command !== undefined) {
-            result.command = asCommand(item.command);
-        }
-        if (item.isPreferred !== undefined) {
-            result.isPreferred = item.isPreferred;
-        }
-        if (item.disabled !== undefined) {
-            result.disabled = { reason: item.disabled.reason };
-        }
-        return result;
-    }
-    async function asCodeActionContext(context, token) {
-        if (context === undefined || context === null) {
-            return context;
-        }
-        let only;
-        if (context.only && Is.string(context.only.value)) {
-            only = [context.only.value];
-        }
-        return proto.CodeActionContext.create(await asDiagnostics(context.diagnostics, token), only, asCodeActionTriggerKind(context.triggerKind));
-    }
-    function asCodeActionContextSync(context) {
-        if (context === undefined || context === null) {
-            return context;
-        }
-        let only;
-        if (context.only && Is.string(context.only.value)) {
-            only = [context.only.value];
-        }
-        return proto.CodeActionContext.create(asDiagnosticsSync(context.diagnostics), only, asCodeActionTriggerKind(context.triggerKind));
-    }
-    function asCodeActionTriggerKind(kind) {
-        switch (kind) {
-            case code.CodeActionTriggerKind.Invoke:
-                return proto.CodeActionTriggerKind.Invoked;
-            case code.CodeActionTriggerKind.Automatic:
-                return proto.CodeActionTriggerKind.Automatic;
-            default:
-                return undefined;
-        }
-    }
-    function asCodeActionKind(item) {
-        if (item === undefined || item === null) {
-            return undefined;
-        }
-        return item.value;
-    }
-    function asInlineValueContext(context) {
-        if (context === undefined || context === null) {
-            return context;
-        }
-        return proto.InlineValueContext.create(context.frameId, asRange(context.stoppedLocation));
-    }
-    function asInlineCompletionParams(document, position, context) {
-        return { context: proto.InlineCompletionContext.create(context.triggerKind, context.selectedCompletionInfo),
-            textDocument: asTextDocumentIdentifier(document), position: asPosition(position) };
-    }
-    function asCommand(item) {
-        let result = proto.Command.create(item.title, item.command);
-        if (item.arguments) {
-            result.arguments = item.arguments;
-        }
-        return result;
-    }
-    function asCodeLens(item) {
-        let result = proto.CodeLens.create(asRange(item.range));
-        if (item.command) {
-            result.command = asCommand(item.command);
-        }
-        if (item instanceof protocolCodeLens_1.default) {
-            if (item.data) {
-                result.data = item.data;
-            }
-        }
-        return result;
-    }
-    function asFormattingOptions(options, fileOptions) {
-        const result = { tabSize: options.tabSize, insertSpaces: options.insertSpaces };
-        if (fileOptions.trimTrailingWhitespace) {
-            result.trimTrailingWhitespace = true;
-        }
-        if (fileOptions.trimFinalNewlines) {
-            result.trimFinalNewlines = true;
-        }
-        if (fileOptions.insertFinalNewline) {
-            result.insertFinalNewline = true;
-        }
-        return result;
-    }
-    function asDocumentSymbolParams(textDocument) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument)
-        };
-    }
-    function asCodeLensParams(textDocument) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument)
-        };
-    }
-    function asDocumentLink(item) {
-        let result = proto.DocumentLink.create(asRange(item.range));
-        if (item.target) {
-            result.target = asUri(item.target);
-        }
-        if (item.tooltip !== undefined) {
-            result.tooltip = item.tooltip;
-        }
-        let protocolItem = item instanceof protocolDocumentLink_1.default ? item : undefined;
-        if (protocolItem && protocolItem.data) {
-            result.data = protocolItem.data;
-        }
-        return result;
-    }
-    function asDocumentLinkParams(textDocument) {
-        return {
-            textDocument: asTextDocumentIdentifier(textDocument)
-        };
-    }
-    function asCallHierarchyItem(value) {
-        const result = {
-            name: value.name,
-            kind: asSymbolKind(value.kind),
-            uri: asUri(value.uri),
-            range: asRange(value.range),
-            selectionRange: asRange(value.selectionRange)
-        };
-        if (value.detail !== undefined && value.detail.length > 0) {
-            result.detail = value.detail;
-        }
-        if (value.tags !== undefined) {
-            result.tags = asSymbolTags(value.tags);
-        }
-        if (value instanceof protocolCallHierarchyItem_1.default && value.data !== undefined) {
-            result.data = value.data;
-        }
-        return result;
-    }
-    function asTypeHierarchyItem(value) {
-        const result = {
-            name: value.name,
-            kind: asSymbolKind(value.kind),
-            uri: asUri(value.uri),
-            range: asRange(value.range),
-            selectionRange: asRange(value.selectionRange),
-        };
-        if (value.detail !== undefined && value.detail.length > 0) {
-            result.detail = value.detail;
-        }
-        if (value.tags !== undefined) {
-            result.tags = asSymbolTags(value.tags);
-        }
-        if (value instanceof protocolTypeHierarchyItem_1.default && value.data !== undefined) {
-            result.data = value.data;
-        }
-        return result;
-    }
-    function asWorkspaceSymbol(item) {
-        const result = item instanceof protocolWorkspaceSymbol_1.default
-            ? { name: item.name, kind: asSymbolKind(item.kind), location: item.hasRange ? asLocation(item.location) : { uri: _uriConverter(item.location.uri) }, data: item.data }
-            : { name: item.name, kind: asSymbolKind(item.kind), location: asLocation(item.location) };
-        if (item.tags !== undefined) {
-            result.tags = asSymbolTags(item.tags);
-        }
-        if (item.containerName !== '') {
-            result.containerName = item.containerName;
-        }
-        return result;
-    }
-    function asInlayHint(item) {
-        const label = typeof item.label === 'string'
-            ? item.label
-            : item.label.map(asInlayHintLabelPart);
-        const result = proto.InlayHint.create(asPosition(item.position), label);
-        if (item.kind !== undefined) {
-            result.kind = item.kind;
-        }
-        if (item.textEdits !== undefined) {
-            result.textEdits = asTextEdits(item.textEdits);
-        }
-        if (item.tooltip !== undefined) {
-            result.tooltip = asTooltip(item.tooltip);
-        }
-        if (item.paddingLeft !== undefined) {
-            result.paddingLeft = item.paddingLeft;
-        }
-        if (item.paddingRight !== undefined) {
-            result.paddingRight = item.paddingRight;
-        }
-        if (item instanceof protocolInlayHint_1.default && item.data !== undefined) {
-            result.data = item.data;
-        }
-        return result;
-    }
-    function asInlayHintLabelPart(item) {
-        const result = proto.InlayHintLabelPart.create(item.value);
-        if (item.location !== undefined) {
-            result.location = asLocation(item.location);
-        }
-        if (item.command !== undefined) {
-            result.command = asCommand(item.command);
-        }
-        if (item.tooltip !== undefined) {
-            result.tooltip = asTooltip(item.tooltip);
-        }
-        return result;
-    }
-    function asTooltip(value) {
-        if (typeof value === 'string') {
-            return value;
-        }
-        const result = {
-            kind: proto.MarkupKind.Markdown,
-            value: value.value
-        };
-        return result;
-    }
-    return {
-        asUri,
-        asTextDocumentIdentifier,
-        asTextDocumentItem,
-        asVersionedTextDocumentIdentifier,
-        asOpenTextDocumentParams,
-        asChangeTextDocumentParams,
-        asCloseTextDocumentParams,
-        asSaveTextDocumentParams,
-        asWillSaveTextDocumentParams,
-        asDidCreateFilesParams,
-        asDidRenameFilesParams,
-        asDidDeleteFilesParams,
-        asWillCreateFilesParams,
-        asWillRenameFilesParams,
-        asWillDeleteFilesParams,
-        asTextDocumentPositionParams,
-        asCompletionParams,
-        asSignatureHelpParams,
-        asWorkerPosition,
-        asRange,
-        asRanges,
-        asPosition,
-        asPositions,
-        asPositionsSync,
-        asLocation,
-        asDiagnosticSeverity,
-        asDiagnosticTag,
-        asDiagnostic,
-        asDiagnostics,
-        asDiagnosticsSync,
-        asCompletionItem,
-        asTextEdit,
-        asSymbolKind,
-        asSymbolTag,
-        asSymbolTags,
-        asReferenceParams,
-        asCodeAction,
-        asCodeActionSync,
-        asCodeActionContext,
-        asCodeActionContextSync,
-        asInlineValueContext,
-        asCommand,
-        asCodeLens,
-        asFormattingOptions,
-        asDocumentSymbolParams,
-        asCodeLensParams,
-        asDocumentLink,
-        asDocumentLinkParams,
-        asCallHierarchyItem,
-        asTypeHierarchyItem,
-        asInlayHint,
-        asWorkspaceSymbol,
-        asInlineCompletionParams
-    };
-}
-exports.createConverter = createConverter;