@difizen/libro-language-client 0.1.18

package/es/common/vscodeAdaptor/monaco-converter.js

@@ -0,0 +1,1613 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/ban-types */
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2018-2022 TypeFox GmbH (http://www.typefox.io). All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as ls from '@difizen/vscode-languageserver-protocol';
+import { CompletionTriggerKind, InsertTextFormat, Diagnostic, CompletionItemKind, LocationLink, DocumentHighlightKind, CodeActionContext, DiagnosticSeverity, Command, CodeLens, DocumentLink, MarkupContent, FoldingRangeKind, MarkupKind, SymbolKind, DocumentSymbol, SignatureHelpTriggerKind, AnnotatedTextEdit, InlayHint } from '@difizen/vscode-languageserver-protocol';
+import * as Is from "./hostTypeUtil.js";
+export var ProtocolDocumentLink;
+(function (_ProtocolDocumentLink) {
+  function is(item) {
+    return !!item && 'data' in item;
+  }
+  _ProtocolDocumentLink.is = is;
+})(ProtocolDocumentLink || (ProtocolDocumentLink = {}));
+export var ProtocolCodeLens;
+(function (_ProtocolCodeLens) {
+  function is(item) {
+    return !!item && 'data' in item;
+  }
+  _ProtocolCodeLens.is = is;
+})(ProtocolCodeLens || (ProtocolCodeLens = {}));
+export var ProtocolCompletionItem;
+(function (_ProtocolCompletionItem) {
+  function is(item) {
+    return !!item && 'data' in item;
+  }
+  _ProtocolCompletionItem.is = is;
+})(ProtocolCompletionItem || (ProtocolCompletionItem = {}));
+export var ProtocolCodeAction;
+(function (_ProtocolCodeAction) {
+  function is(item) {
+    return !!item && 'data' in item;
+  }
+  _ProtocolCodeAction.is = is;
+})(ProtocolCodeAction || (ProtocolCodeAction = {}));
+export var ProtocolInlayHint;
+(function (_ProtocolInlayHint) {
+  function is(item) {
+    return !!item && 'data' in item;
+  }
+  _ProtocolInlayHint.is = is;
+})(ProtocolInlayHint || (ProtocolInlayHint = {}));
+function isRangeReplace(v) {
+  return v.insert !== undefined;
+}
+export var MonacoToProtocolConverter = /*#__PURE__*/function () {
+  function MonacoToProtocolConverter(_monaco) {
+    _classCallCheck(this, MonacoToProtocolConverter);
+    this._monaco = _monaco;
+  }
+  _createClass(MonacoToProtocolConverter, [{
+    key: "asPosition",
+    value: function asPosition(lineNumber, column) {
+      var line = lineNumber === undefined || lineNumber === null ? undefined : lineNumber - 1;
+      var character = column === undefined || column === null ? undefined : column - 1;
+      return {
+        line: line,
+        character: character
+      };
+    }
+  }, {
+    key: "asRange",
+    value: function asRange(range) {
+      if (range === undefined) {
+        return undefined;
+      }
+      if (range === null) {
+        return null;
+      }
+      if (isRangeReplace(range)) {
+        return this.asRange(range.insert);
+      } else {
+        var start = this.asPosition(range.startLineNumber, range.startColumn);
+        var end = this.asPosition(range.endLineNumber, range.endColumn);
+        return {
+          start: start,
+          end: end
+        };
+      }
+    }
+  }, {
+    key: "asLocation",
+    value: function asLocation(item) {
+      if (!item) {
+        return undefined;
+      }
+      var uri = item.uri.toString();
+      var range = this.asRange(item.range);
+      return {
+        uri: uri,
+        range: range
+      };
+    }
+  }, {
+    key: "asTextDocumentIdentifier",
+    value: function asTextDocumentIdentifier(model) {
+      return {
+        uri: model.uri.toString()
+      };
+    }
+  }, {
+    key: "asTextDocumentPositionParams",
+    value: function asTextDocumentPositionParams(model, position) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        position: this.asPosition(position.lineNumber, position.column)
+      };
+    }
+  }, {
+    key: "asCompletionParams",
+    value: function asCompletionParams(model, position, context) {
+      return Object.assign(this.asTextDocumentPositionParams(model, position), {
+        context: this.asCompletionContext(context)
+      });
+    }
+  }, {
+    key: "asCompletionContext",
+    value: function asCompletionContext(context) {
+      return {
+        triggerKind: this.asCompletionTriggerKind(context.triggerKind),
+        triggerCharacter: context.triggerCharacter
+      };
+    }
+  }, {
+    key: "asSignatureHelpContext",
+    value: function asSignatureHelpContext(context) {
+      return {
+        triggerKind: this.asSignatureHelpTriggerKind(context.triggerKind),
+        triggerCharacter: context.triggerCharacter,
+        isRetrigger: context.isRetrigger,
+        activeSignatureHelp: this.asSignatureHelp(context.activeSignatureHelp)
+      };
+    }
+  }, {
+    key: "asSignatureHelp",
+    value: function asSignatureHelp(signatureHelp) {
+      var _this = this;
+      if (signatureHelp === undefined) {
+        return undefined;
+      }
+      return {
+        signatures: signatureHelp.signatures.map(function (signatureInfo) {
+          return _this.asSignatureInformation(signatureInfo);
+        }),
+        activeParameter: signatureHelp.activeParameter,
+        activeSignature: signatureHelp.activeSignature
+      };
+    }
+  }, {
+    key: "asSignatureInformation",
+    value: function asSignatureInformation(signatureInformation) {
+      var _this2 = this;
+      return {
+        documentation: this.asMarkupContent(signatureInformation.documentation),
+        label: signatureInformation.label,
+        parameters: signatureInformation.parameters.map(function (paramInfo) {
+          return _this2.asParameterInformation(paramInfo);
+        }),
+        activeParameter: signatureInformation.activeParameter
+      };
+    }
+  }, {
+    key: "asParameterInformation",
+    value: function asParameterInformation(parameterInformation) {
+      return {
+        documentation: this.asMarkupContent(parameterInformation.documentation),
+        label: parameterInformation.label
+      };
+    }
+  }, {
+    key: "asMarkupContent",
+    value: function asMarkupContent(markupContent) {
+      if (markupContent === undefined) {
+        return undefined;
+      }
+      if (typeof markupContent === 'string') {
+        return markupContent;
+      }
+      return {
+        kind: MarkupKind.Markdown,
+        value: markupContent.value
+      };
+    }
+  }, {
+    key: "asSignatureHelpTriggerKind",
+    value: function asSignatureHelpTriggerKind(triggerKind) {
+      switch (triggerKind) {
+        case this._monaco.languages.SignatureHelpTriggerKind.ContentChange:
+          return SignatureHelpTriggerKind.ContentChange;
+        case this._monaco.languages.SignatureHelpTriggerKind.TriggerCharacter:
+          return SignatureHelpTriggerKind.TriggerCharacter;
+        default:
+          return SignatureHelpTriggerKind.Invoked;
+      }
+    }
+  }, {
+    key: "asCompletionTriggerKind",
+    value: function asCompletionTriggerKind(triggerKind) {
+      switch (triggerKind) {
+        case this._monaco.languages.CompletionTriggerKind.TriggerCharacter:
+          return CompletionTriggerKind.TriggerCharacter;
+        case this._monaco.languages.CompletionTriggerKind.TriggerForIncompleteCompletions:
+          return CompletionTriggerKind.TriggerForIncompleteCompletions;
+        default:
+          return CompletionTriggerKind.Invoked;
+      }
+    }
+  }, {
+    key: "asCompletionItem",
+    value: function asCompletionItem(item) {
+      var result = {
+        label: item.label
+      };
+      var protocolItem = ProtocolCompletionItem.is(item) ? item : undefined;
+      if (item.detail) {
+        result.detail = item.detail;
+      }
+      if (item.documentation) {
+        if (typeof item.documentation === 'string') {
+          result.documentation = item.documentation;
+        } else {
+          var _protocolItem$documen;
+          result.documentation = this.asDocumentation((_protocolItem$documen = protocolItem === null || protocolItem === void 0 ? void 0 : protocolItem.documentationFormat) !== null && _protocolItem$documen !== void 0 ? _protocolItem$documen : MarkupKind.Markdown, item.documentation);
+        }
+      }
+      if (item.filterText) {
+        result.filterText = item.filterText;
+      }
+      this.fillPrimaryInsertText(result, item);
+      if (Is.isNumber(item.kind)) {
+        result.kind = this.asCompletionItemKind(item.kind, protocolItem && protocolItem.originalItemKind);
+      }
+      if (item.sortText) {
+        result.sortText = item.sortText;
+      }
+      if (item.additionalTextEdits) {
+        result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+      }
+      if (item.command) {
+        result.command = this.asCommand(item.command);
+      }
+      if (item.commitCharacters) {
+        result.commitCharacters = item.commitCharacters.slice();
+      }
+      if (item.command) {
+        result.command = this.asCommand(item.command);
+      }
+      if (item.preselect === true || item.preselect === false) {
+        result.preselect = item.preselect;
+      }
+      if (protocolItem) {
+        if (protocolItem.data !== undefined) {
+          result.data = protocolItem.data;
+        }
+        if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
+          result.deprecated = protocolItem.deprecated;
+        }
+      }
+      if (item.tags) {
+        var _item$tags;
+        result.tags = (_item$tags = item.tags) === null || _item$tags === void 0 ? void 0 : _item$tags.slice();
+      }
+      return result;
+    }
+  }, {
+    key: "asCompletionItemKind",
+    value: function asCompletionItemKind(value, original) {
+      if (original !== undefined) {
+        return original;
+      }
+      switch (value) {
+        case this._monaco.languages.CompletionItemKind.Method:
+          return CompletionItemKind.Method;
+        case this._monaco.languages.CompletionItemKind.Function:
+          return CompletionItemKind.Function;
+        case this._monaco.languages.CompletionItemKind.Constructor:
+          return CompletionItemKind.Constructor;
+        case this._monaco.languages.CompletionItemKind.Field:
+          return CompletionItemKind.Field;
+        case this._monaco.languages.CompletionItemKind.Variable:
+          return CompletionItemKind.Variable;
+        case this._monaco.languages.CompletionItemKind.Class:
+          return CompletionItemKind.Class;
+        case this._monaco.languages.CompletionItemKind.Struct:
+          return CompletionItemKind.Struct;
+        case this._monaco.languages.CompletionItemKind.Interface:
+          return CompletionItemKind.Interface;
+        case this._monaco.languages.CompletionItemKind.Module:
+          return CompletionItemKind.Module;
+        case this._monaco.languages.CompletionItemKind.Property:
+          return CompletionItemKind.Property;
+        case this._monaco.languages.CompletionItemKind.Event:
+          return CompletionItemKind.Event;
+        case this._monaco.languages.CompletionItemKind.Operator:
+          return CompletionItemKind.Operator;
+        case this._monaco.languages.CompletionItemKind.Unit:
+          return CompletionItemKind.Unit;
+        case this._monaco.languages.CompletionItemKind.Value:
+          return CompletionItemKind.Value;
+        case this._monaco.languages.CompletionItemKind.Constant:
+          return CompletionItemKind.Constant;
+        case this._monaco.languages.CompletionItemKind.Enum:
+          return CompletionItemKind.Enum;
+        case this._monaco.languages.CompletionItemKind.EnumMember:
+          return CompletionItemKind.EnumMember;
+        case this._monaco.languages.CompletionItemKind.Keyword:
+          return CompletionItemKind.Keyword;
+        case this._monaco.languages.CompletionItemKind.Text:
+          return CompletionItemKind.Text;
+        case this._monaco.languages.CompletionItemKind.Color:
+          return CompletionItemKind.Color;
+        case this._monaco.languages.CompletionItemKind.File:
+          return CompletionItemKind.File;
+        case this._monaco.languages.CompletionItemKind.Reference:
+          return CompletionItemKind.Reference;
+        case this._monaco.languages.CompletionItemKind.Customcolor:
+          return CompletionItemKind.Color;
+        case this._monaco.languages.CompletionItemKind.Folder:
+          return CompletionItemKind.Folder;
+        case this._monaco.languages.CompletionItemKind.TypeParameter:
+          return CompletionItemKind.TypeParameter;
+        case this._monaco.languages.CompletionItemKind.Snippet:
+          return CompletionItemKind.Snippet;
+        default:
+          return value + 1;
+      }
+    }
+  }, {
+    key: "asDocumentation",
+    value: function asDocumentation(format, documentation) {
+      switch (format) {
+        case MarkupKind.PlainText:
+          return {
+            kind: format,
+            value: documentation
+          };
+        case MarkupKind.Markdown:
+          return {
+            kind: format,
+            value: documentation.value
+          };
+        default:
+          return "Unsupported Markup content received. Kind is: ".concat(format);
+      }
+    }
+  }, {
+    key: "fillPrimaryInsertText",
+    value: function fillPrimaryInsertText(target, source) {
+      var format = InsertTextFormat.PlainText;
+      var text;
+      var range;
+      if (source.insertTextRules !== undefined && (source.insertTextRules & this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet) === 0) {
+        format = InsertTextFormat.Snippet;
+        text = source.insertText;
+      }
+      target.insertTextFormat = format;
+      text = source.insertText;
+      if (source.range) {
+        range = this.asRange(source.range);
+      }
+      target.insertTextFormat = format;
+      if (source.fromEdit && text && range) {
+        target.textEdit = {
+          newText: text,
+          range: range
+        };
+      } else {
+        target.insertText = text;
+      }
+      target.insertTextMode = source.insertTextMode;
+    }
+  }, {
+    key: "asTextEdit",
+    value: function asTextEdit(edit) {
+      var range = this.asRange(edit.range);
+      return {
+        range: range,
+        newText: edit.text || ''
+      };
+    }
+  }, {
+    key: "asTextEdits",
+    value: function asTextEdits(items) {
+      var _this3 = this;
+      if (!items) {
+        return undefined;
+      }
+      return items.map(function (item) {
+        return _this3.asTextEdit(item);
+      });
+    }
+  }, {
+    key: "asReferenceParams",
+    value: function asReferenceParams(model, position, options) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        position: this.asPosition(position.lineNumber, position.column),
+        context: {
+          includeDeclaration: options.includeDeclaration
+        }
+      };
+    }
+  }, {
+    key: "asDocumentSymbolParams",
+    value: function asDocumentSymbolParams(model) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model)
+      };
+    }
+  }, {
+    key: "asCodeLensParams",
+    value: function asCodeLensParams(model) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model)
+      };
+    }
+  }, {
+    key: "asDiagnosticSeverity",
+    value: function asDiagnosticSeverity(value) {
+      switch (value) {
+        case this._monaco.MarkerSeverity.Error:
+          return DiagnosticSeverity.Error;
+        case this._monaco.MarkerSeverity.Warning:
+          return DiagnosticSeverity.Warning;
+        case this._monaco.MarkerSeverity.Info:
+          return DiagnosticSeverity.Information;
+        case this._monaco.MarkerSeverity.Hint:
+          return DiagnosticSeverity.Hint;
+      }
+      return undefined;
+    }
+  }, {
+    key: "asDiagnostic",
+    value: function asDiagnostic(marker) {
+      var range = this.asRange(new this._monaco.Range(marker.startLineNumber, marker.startColumn, marker.endLineNumber, marker.endColumn));
+      var severity = this.asDiagnosticSeverity(marker.severity);
+      var diag = Diagnostic.create(range, marker.message, severity, marker.code, marker.source);
+      return diag;
+    }
+  }, {
+    key: "asDiagnostics",
+    value: function asDiagnostics(markers) {
+      var _this4 = this;
+      if (markers === void 0 || markers === null) {
+        return markers;
+      }
+      return markers.map(function (marker) {
+        return _this4.asDiagnostic(marker);
+      });
+    }
+  }, {
+    key: "asCodeActionContext",
+    value: function asCodeActionContext(context, diagnostics) {
+      if (context === void 0 || context === null) {
+        return context;
+      }
+      return CodeActionContext.create(diagnostics, Is.isString(context.only) ? [context.only] : undefined, context.trigger);
+    }
+  }, {
+    key: "asCodeActionParams",
+    value: function asCodeActionParams(model, range, context, diagnostics) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        range: this.asRange(range),
+        context: this.asCodeActionContext(context, diagnostics)
+      };
+    }
+  }, {
+    key: "asCommand",
+    value: function asCommand(item) {
+      if (item) {
+        var args = item.arguments || [];
+        return Command.create.apply(Command, [item.title, item.id].concat(_toConsumableArray(args)));
+      }
+      return undefined;
+    }
+  }, {
+    key: "asCodeLens",
+    value: function asCodeLens(item) {
+      var result = CodeLens.create(this.asRange(item.range));
+      if (item.command) {
+        result.command = this.asCommand(item.command);
+      }
+      if (ProtocolCodeLens.is(item)) {
+        if (item.data) {
+          result.data = item.data;
+        }
+      }
+      return result;
+    }
+  }, {
+    key: "asFormattingOptions",
+    value: function asFormattingOptions(options) {
+      return {
+        tabSize: options.tabSize,
+        insertSpaces: options.insertSpaces
+      };
+    }
+  }, {
+    key: "asDocumentFormattingParams",
+    value: function asDocumentFormattingParams(model, options) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        options: this.asFormattingOptions(options)
+      };
+    }
+  }, {
+    key: "asDocumentRangeFormattingParams",
+    value: function asDocumentRangeFormattingParams(model, range, options) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        range: this.asRange(range),
+        options: this.asFormattingOptions(options)
+      };
+    }
+  }, {
+    key: "asDocumentOnTypeFormattingParams",
+    value: function asDocumentOnTypeFormattingParams(model, position, ch, options) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        position: this.asPosition(position.lineNumber, position.column),
+        ch: ch,
+        options: this.asFormattingOptions(options)
+      };
+    }
+  }, {
+    key: "asRenameParams",
+    value: function asRenameParams(model, position, newName) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model),
+        position: this.asPosition(position.lineNumber, position.column),
+        newName: newName
+      };
+    }
+  }, {
+    key: "asDocumentLinkParams",
+    value: function asDocumentLinkParams(model) {
+      return {
+        textDocument: this.asTextDocumentIdentifier(model)
+      };
+    }
+  }, {
+    key: "asDocumentLink",
+    value: function asDocumentLink(item) {
+      var result = DocumentLink.create(this.asRange(item.range));
+      if (item.url) {
+        result.target = typeof item.url === 'string' ? item.url : item.url.toString();
+      }
+      if (ProtocolDocumentLink.is(item) && item.data) {
+        result.data = item.data;
+      }
+      if (item.tooltip) {
+        result.tooltip = item.tooltip;
+      }
+      return result;
+    }
+  }, {
+    key: "asCodeAction",
+    value: function asCodeAction(item) {
+      var result = {
+        title: item.title
+      };
+      var protocolCodeAction = ProtocolCodeAction.is(item) ? item : undefined;
+      if (Is.isNumber(item.kind)) {
+        result.kind = item.kind;
+      }
+      if (item.diagnostics) {
+        result.diagnostics = this.asDiagnostics(item.diagnostics);
+      }
+      if (item.edit) {
+        throw new Error("VS Code code actions can only be converted to a protocol code action without an edit.");
+      }
+      if (item.command) {
+        result.command = this.asCommand(item.command);
+      }
+      if (item.isPreferred !== undefined) {
+        result.isPreferred = item.isPreferred;
+      }
+      if (item.disabled) {
+        result.disabled = {
+          reason: item.disabled
+        };
+      }
+      if (protocolCodeAction) {
+        if (protocolCodeAction.data !== undefined) {
+          result.data = protocolCodeAction.data;
+        }
+      }
+      return result;
+    }
+  }, {
+    key: "asInlayHintLabelPart",
+    value: function asInlayHintLabelPart(part) {
+      return {
+        value: part.label,
+        command: this.asCommand(part.command),
+        location: this.asLocation(part.location),
+        tooltip: this.asMarkupContent(part.tooltip)
+      };
+    }
+  }, {
+    key: "asInlayHintLabel",
+    value: function asInlayHintLabel(label) {
+      var _this5 = this;
+      if (Array.isArray(label)) {
+        return label.map(function (part) {
+          return _this5.asInlayHintLabelPart(part);
+        });
+      }
+      return label;
+    }
+  }, {
+    key: "asInlayHint",
+    value: function asInlayHint(item) {
+      var result = InlayHint.create(this.asPosition(item.position.lineNumber, item.position.column), this.asInlayHintLabel(item.label), item.kind);
+      if (ProtocolInlayHint.is(item)) {
+        if (item.data) {
+          result.data = item.data;
+        }
+      }
+      return result;
+    }
+  }]);
+  return MonacoToProtocolConverter;
+}();
+export var ProtocolToMonacoConverter = /*#__PURE__*/function () {
+  function ProtocolToMonacoConverter(_monaco) {
+    _classCallCheck(this, ProtocolToMonacoConverter);
+    this._monaco = _monaco;
+  }
+  _createClass(ProtocolToMonacoConverter, [{
+    key: "asResourceEdits",
+    value: function asResourceEdits(resource, edits, asMetadata, modelVersionId) {
+      var _this6 = this;
+      return edits.map(function (edit) {
+        return {
+          resource: resource,
+          textEdit: _this6.asTextEdit(edit),
+          versionId: modelVersionId,
+          metadata: AnnotatedTextEdit.is(edit) ? asMetadata(edit.annotationId) : undefined
+        };
+      });
+    }
+  }, {
+    key: "asWorkspaceEditMetadata",
+    value: function asWorkspaceEditMetadata(changeAnnotation) {
+      return {
+        needsConfirmation: changeAnnotation.needsConfirmation === true,
+        label: changeAnnotation.label,
+        description: changeAnnotation.description
+      };
+    }
+  }, {
+    key: "asWorkspaceEdit",
+    value: function asWorkspaceEdit(item) {
+      var _this7 = this;
+      if (!item) {
+        return undefined;
+      }
+      var sharedMetadata = new Map();
+      if (item.changeAnnotations !== undefined) {
+        for (var _i = 0, _Object$keys = Object.keys(item.changeAnnotations); _i < _Object$keys.length; _i++) {
+          var key = _Object$keys[_i];
+          var metaData = this.asWorkspaceEditMetadata(item.changeAnnotations[key]);
+          sharedMetadata.set(key, metaData);
+        }
+      }
+      var asMetadata = function asMetadata(annotation) {
+        if (annotation === undefined) {
+          return undefined;
+        } else {
+          return sharedMetadata.get(annotation);
+        }
+      };
+      var edits = [];
+      if (item.documentChanges) {
+        item.documentChanges.forEach(function (change) {
+          if (ls.CreateFile.is(change)) {
+            edits.push({
+              newUri: _this7._monaco.Uri.parse(change.uri),
+              options: change.options,
+              metadata: asMetadata(change.annotationId)
+            });
+          } else if (ls.RenameFile.is(change)) {
+            edits.push({
+              oldUri: _this7._monaco.Uri.parse(change.oldUri),
+              newUri: _this7._monaco.Uri.parse(change.newUri),
+              options: change.options,
+              metadata: asMetadata(change.annotationId)
+            });
+          } else if (ls.DeleteFile.is(change)) {
+            edits.push({
+              oldUri: _this7._monaco.Uri.parse(change.uri),
+              options: change.options,
+              metadata: asMetadata(change.annotationId)
+            });
+          } else if (ls.TextDocumentEdit.is(change)) {
+            var resource = _this7._monaco.Uri.parse(change.textDocument.uri);
+            var version = typeof change.textDocument.version === 'number' ? change.textDocument.version : undefined;
+            edits.push.apply(edits, _toConsumableArray(_this7.asResourceEdits(resource, change.edits, asMetadata, version)));
+          } else {
+            console.error("Unknown workspace edit change received:\n".concat(JSON.stringify(change, undefined, 4)));
+          }
+        });
+      } else if (item.changes) {
+        for (var _i2 = 0, _Object$keys2 = Object.keys(item.changes); _i2 < _Object$keys2.length; _i2++) {
+          var _key = _Object$keys2[_i2];
+          var resource = this._monaco.Uri.parse(_key);
+          edits.push.apply(edits, _toConsumableArray(this.asResourceEdits(resource, item.changes[_key], asMetadata)));
+        }
+      }
+      return {
+        edits: edits
+      };
+    }
+  }, {
+    key: "asTextEdit",
+    value: function asTextEdit(edit) {
+      if (!edit) {
+        return undefined;
+      }
+      var range = this.asRange(edit.range);
+      return {
+        range: range,
+        text: edit.newText
+      };
+    }
+  }, {
+    key: "asTextEdits",
+    value: function asTextEdits(items) {
+      var _this8 = this;
+      if (!items) {
+        return undefined;
+      }
+      return items.map(function (item) {
+        return _this8.asTextEdit(item);
+      });
+    }
+  }, {
+    key: "asCodeLens",
+    value: function asCodeLens(item) {
+      if (!item) {
+        return undefined;
+      }
+      var range = this.asRange(item.range);
+      var result = {
+        range: range
+      };
+      if (item.command) {
+        result.command = this.asCommand(item.command);
+      }
+      if (item.data !== void 0 && item.data !== null) {
+        result.data = item.data;
+      }
+      return result;
+    }
+  }, {
+    key: "asCodeLensList",
+    value: function asCodeLensList(items) {
+      var _this9 = this;
+      if (!items) {
+        return undefined;
+      }
+      return {
+        lenses: items.map(function (codeLens) {
+          return _this9.asCodeLens(codeLens);
+        }),
+        dispose: function dispose() {}
+      };
+    }
+  }, {
+    key: "asCodeActionList",
+    value: function asCodeActionList(actions) {
+      var _this10 = this;
+      return {
+        actions: actions.map(function (action) {
+          return _this10.asCodeAction(action);
+        }),
+        dispose: function dispose() {}
+      };
+    }
+  }, {
+    key: "asCodeAction",
+    value: function asCodeAction(item) {
+      if (Command.is(item)) {
+        return {
+          command: {
+            id: item.command,
+            title: item.title,
+            arguments: item.arguments
+          },
+          title: item.title
+        };
+      }
+      return {
+        title: item.title,
+        command: this.asCommand(item.command),
+        edit: this.asWorkspaceEdit(item.edit),
+        diagnostics: this.asDiagnostics(item.diagnostics),
+        kind: item.kind,
+        disabled: item.disabled ? item.disabled.reason : undefined,
+        isPreferred: item.isPreferred,
+        data: item.data
+      };
+    }
+  }, {
+    key: "asCommand",
+    value: function asCommand(command) {
+      if (!command) {
+        return undefined;
+      }
+      return {
+        id: command.command,
+        title: command.title,
+        arguments: command.arguments
+      };
+    }
+  }, {
+    key: "asDocumentSymbol",
+    value: function asDocumentSymbol(value) {
+      var _this11 = this;
+      var children = value.children && value.children.map(function (c) {
+        return _this11.asDocumentSymbol(c);
+      });
+      return {
+        name: value.name,
+        detail: value.detail || '',
+        kind: this.asSymbolKind(value.kind),
+        tags: value.tags || [],
+        range: this.asRange(value.range),
+        selectionRange: this.asRange(value.selectionRange),
+        children: children
+      };
+    }
+  }, {
+    key: "asDocumentSymbols",
+    value: function asDocumentSymbols(values) {
+      var _this12 = this;
+      if (DocumentSymbol.is(values[0])) {
+        return values.map(function (s) {
+          return _this12.asDocumentSymbol(s);
+        });
+      }
+      return this.asSymbolInformations(values);
+    }
+  }, {
+    key: "asSymbolInformations",
+    value: function asSymbolInformations(values, uri) {
+      var _this13 = this;
+      if (!values) {
+        return undefined;
+      }
+      return values.map(function (information) {
+        return _this13.asSymbolInformation(information, uri);
+      });
+    }
+  }, {
+    key: "asSymbolInformation",
+    value: function asSymbolInformation(item, uri) {
+      var location = this.asLocation(uri ? _objectSpread(_objectSpread({}, item.location), {}, {
+        uri: uri.toString()
+      }) : item.location);
+      return {
+        name: item.name,
+        detail: '',
+        containerName: item.containerName,
+        kind: this.asSymbolKind(item.kind),
+        tags: item.tags || [],
+        range: location.range,
+        selectionRange: location.range
+      };
+    }
+  }, {
+    key: "asSymbolKind",
+    value: function asSymbolKind(item) {
+      if (item <= SymbolKind.TypeParameter) {
+        // Symbol kind is one based in the protocol and zero based in code.
+        return item - 1;
+      }
+      return this._monaco.languages.SymbolKind.Property;
+    }
+  }, {
+    key: "asDocumentHighlights",
+    value: function asDocumentHighlights(values) {
+      var _this14 = this;
+      if (!values) {
+        return undefined;
+      }
+      return values.map(function (item) {
+        return _this14.asDocumentHighlight(item);
+      });
+    }
+  }, {
+    key: "asDocumentHighlight",
+    value: function asDocumentHighlight(item) {
+      var range = this.asRange(item.range);
+      var kind = Is.isNumber(item.kind) ? this.asDocumentHighlightKind(item.kind) : undefined;
+      return {
+        range: range,
+        kind: kind
+      };
+    }
+  }, {
+    key: "asDocumentHighlightKind",
+    value: function asDocumentHighlightKind(item) {
+      switch (item) {
+        case DocumentHighlightKind.Text:
+          return this._monaco.languages.DocumentHighlightKind.Text;
+        case DocumentHighlightKind.Read:
+          return this._monaco.languages.DocumentHighlightKind.Read;
+        case DocumentHighlightKind.Write:
+          return this._monaco.languages.DocumentHighlightKind.Write;
+      }
+      return this._monaco.languages.DocumentHighlightKind.Text;
+    }
+  }, {
+    key: "asReferences",
+    value: function asReferences(values) {
+      var _this15 = this;
+      if (!values) {
+        return undefined;
+      }
+      return values.map(function (location) {
+        return _this15.asLocation(location);
+      });
+    }
+  }, {
+    key: "asDefinitionResult",
+    value: function asDefinitionResult(item) {
+      var _this16 = this;
+      if (!item) {
+        return undefined;
+      }
+      if (Array.isArray(item)) {
+        if (item.length === 0) {
+          return undefined;
+        } else if (LocationLink.is(item[0])) {
+          var links = item;
+          return links.map(function (location) {
+            return _this16.asLocationLink(location);
+          });
+        } else {
+          var locations = item;
+          return locations.map(function (location) {
+            return _this16.asLocation(location);
+          });
+        }
+      } else {
+        return this.asLocation(item);
+      }
+    }
+  }, {
+    key: "asLocation",
+    value: function asLocation(item) {
+      if (!item) {
+        return undefined;
+      }
+      var uri = this._monaco.Uri.parse(item.uri);
+      var range = this.asRange(item.range);
+      return {
+        uri: uri,
+        range: range
+      };
+    }
+  }, {
+    key: "asLocationLink",
+    value: function asLocationLink(item) {
+      if (!item) {
+        return undefined;
+      }
+      var result = {
+        uri: this._monaco.Uri.parse(item.targetUri),
+        range: this.asRange(item.targetSelectionRange),
+        // See issue: https://github.com/Microsoft/vscode/issues/58649
+        originSelectionRange: this.asRange(item.originSelectionRange),
+        targetSelectionRange: this.asRange(item.targetSelectionRange)
+      };
+      if (!result.targetSelectionRange) {
+        throw new Error("targetSelectionRange must not be undefined or null");
+      }
+      return result;
+    }
+  }, {
+    key: "asSignatureHelpResult",
+    value: function asSignatureHelpResult(item) {
+      if (!item) {
+        return undefined;
+      }
+      var result = {};
+      if (Is.isNumber(item.activeSignature)) {
+        result.activeSignature = item.activeSignature;
+      } else {
+        // activeSignature was optional in the past
+        result.activeSignature = 0;
+      }
+      if (Is.isNumber(item.activeParameter)) {
+        result.activeParameter = item.activeParameter;
+      } else {
+        // activeParameter was optional in the past
+        result.activeParameter = 0;
+      }
+      if (item.signatures) {
+        result.signatures = this.asSignatureInformations(item.signatures);
+      } else {
+        result.signatures = [];
+      }
+      return {
+        value: result,
+        dispose: function dispose() {}
+      };
+    }
+  }, {
+    key: "asSignatureInformations",
+    value: function asSignatureInformations(items) {
+      var _this17 = this;
+      return items.map(function (item) {
+        return _this17.asSignatureInformation(item);
+      });
+    }
+  }, {
+    key: "asSignatureInformation",
+    value: function asSignatureInformation(item) {
+      var result = {
+        label: item.label
+      };
+      if (item.documentation) {
+        result.documentation = this.asDocumentation(item.documentation);
+      }
+      if (item.parameters) {
+        result.parameters = this.asParameterInformations(item.parameters);
+      } else {
+        result.parameters = [];
+      }
+      if (item.activeParameter) {
+        result.activeParameter = item.activeParameter;
+      }
+      return result;
+    }
+  }, {
+    key: "asParameterInformations",
+    value: function asParameterInformations(item) {
+      var _this18 = this;
+      return item.map(function (item) {
+        return _this18.asParameterInformation(item);
+      });
+    }
+  }, {
+    key: "asParameterInformation",
+    value: function asParameterInformation(item) {
+      var result = {
+        label: item.label
+      };
+      if (item.documentation) {
+        result.documentation = this.asDocumentation(item.documentation);
+      }
+      return result;
+    }
+  }, {
+    key: "asHover",
+    value: function asHover(hover) {
+      if (!hover) {
+        return undefined;
+      }
+      return {
+        contents: this.asHoverContent(hover.contents),
+        range: this.asRange(hover.range)
+      };
+    }
+  }, {
+    key: "asHoverContent",
+    value: function asHoverContent(contents) {
+      var _this19 = this;
+      if (Array.isArray(contents)) {
+        return contents.map(function (content) {
+          return _this19.asMarkdownString(content);
+        });
+      }
+      return [this.asMarkdownString(contents)];
+    }
+  }, {
+    key: "asDocumentation",
+    value: function asDocumentation(value) {
+      if (Is.isString(value)) {
+        return value;
+      }
+      if (value.kind === MarkupKind.PlainText) {
+        return value.value;
+      }
+      return this.asMarkdownString(value);
+    }
+  }, {
+    key: "asMarkdownString",
+    value: function asMarkdownString(content) {
+      if (MarkupContent.is(content)) {
+        return {
+          value: content.value
+        };
+      }
+      if (Is.isString(content)) {
+        return {
+          value: content
+        };
+      }
+      var language = content.language,
+        value = content.value;
+      return {
+        value: '```' + language + '\n' + value + '\n```'
+      };
+    }
+  }, {
+    key: "asSeverity",
+    value: function asSeverity(severity) {
+      if (severity === 1) {
+        return this._monaco.MarkerSeverity.Error;
+      }
+      if (severity === 2) {
+        return this._monaco.MarkerSeverity.Warning;
+      }
+      if (severity === 3) {
+        return this._monaco.MarkerSeverity.Info;
+      }
+      return this._monaco.MarkerSeverity.Hint;
+    }
+  }, {
+    key: "asDiagnostics",
+    value: function asDiagnostics(diagnostics) {
+      var _this20 = this;
+      if (!diagnostics) {
+        return undefined;
+      }
+      return diagnostics.map(function (diagnostic) {
+        return _this20.asDiagnostic(diagnostic);
+      });
+    }
+  }, {
+    key: "asDiagnostic",
+    value: function asDiagnostic(diagnostic) {
+      return {
+        code: typeof diagnostic.code === 'number' ? diagnostic.code.toString() : diagnostic.code,
+        severity: this.asSeverity(diagnostic.severity),
+        message: diagnostic.message,
+        source: diagnostic.source,
+        startLineNumber: diagnostic.range.start.line + 1,
+        startColumn: diagnostic.range.start.character + 1,
+        endLineNumber: diagnostic.range.end.line + 1,
+        endColumn: diagnostic.range.end.character + 1,
+        relatedInformation: this.asRelatedInformations(diagnostic.relatedInformation),
+        tags: diagnostic.tags
+      };
+    }
+  }, {
+    key: "asRelatedInformations",
+    value: function asRelatedInformations(relatedInformation) {
+      var _this21 = this;
+      if (!relatedInformation) {
+        return undefined;
+      }
+      return relatedInformation.map(function (item) {
+        return _this21.asRelatedInformation(item);
+      });
+    }
+  }, {
+    key: "asRelatedInformation",
+    value: function asRelatedInformation(relatedInformation) {
+      return {
+        resource: this._monaco.Uri.parse(relatedInformation.location.uri),
+        startLineNumber: relatedInformation.location.range.start.line + 1,
+        startColumn: relatedInformation.location.range.start.character + 1,
+        endLineNumber: relatedInformation.location.range.end.line + 1,
+        endColumn: relatedInformation.location.range.end.character + 1,
+        message: relatedInformation.message
+      };
+    }
+  }, {
+    key: "asCompletionResult",
+    value: function asCompletionResult(result, defaultMonacoRange) {
+      var _this22 = this;
+      if (!result) {
+        return {
+          incomplete: false,
+          suggestions: []
+        };
+      }
+      if (Array.isArray(result)) {
+        var suggestions = result.map(function (item) {
+          return _this22.asCompletionItem(item, defaultMonacoRange, defaultRange);
+        });
+        return {
+          incomplete: false,
+          suggestions: suggestions
+        };
+      }
+      var defaultRange = this.getCompletionItemDefaultRange(result);
+      return {
+        incomplete: result.isIncomplete,
+        suggestions: result.items.map(function (item) {
+          return _this22.asCompletionItem(item, defaultMonacoRange, defaultRange, result.itemDefaults);
+        })
+      };
+    }
+  }, {
+    key: "asCompletionItem",
+    value: function asCompletionItem(item, defaultMonacoRange, defaultRange, itemDefaults) {
+      var _insertText$range, _item$data, _item$insertTextMode;
+      var result = {
+        label: this.asCompletionItemLabel(item)
+      };
+      if (item.detail) {
+        result.detail = item.detail;
+      }
+      if (item.documentation) {
+        result.documentation = this.asDocumentation(item.documentation);
+        result.documentationFormat = Is.isString(item.documentation) ? undefined : item.documentation.kind;
+      }
+      if (item.filterText) {
+        result.filterText = item.filterText;
+      }
+      var insertText = this.asCompletionInsertText(item, defaultRange, itemDefaults === null || itemDefaults === void 0 ? void 0 : itemDefaults.insertTextFormat);
+      result.insertText = insertText.insertText;
+      result.range = (_insertText$range = insertText.range) !== null && _insertText$range !== void 0 ? _insertText$range : defaultMonacoRange;
+      result.fromEdit = insertText.fromEdit;
+      if (insertText.isSnippet) {
+        result.insertTextRules = this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+      }
+      if (Is.isNumber(item.kind)) {
+        var _this$asCompletionIte = this.asCompletionItemKind(item.kind),
+          _this$asCompletionIte2 = _slicedToArray(_this$asCompletionIte, 2),
+          itemKind = _this$asCompletionIte2[0],
+          original = _this$asCompletionIte2[1];
+        result.kind = itemKind;
+        if (original) {
+          result.originalItemKind = original;
+        }
+      }
+      if (item.sortText) {
+        result.sortText = item.sortText;
+      }
+      if (item.additionalTextEdits) {
+        result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+      }
+      if (Is.isStringArray(item.commitCharacters)) {
+        result.commitCharacters = item.commitCharacters.slice();
+      }
+      if (item.command) {
+        result.command = this.asCommand(item.command);
+      }
+      if (item.deprecated === true || item.deprecated === false) {
+        result.deprecated = item.deprecated;
+      }
+      if (item.preselect === true || item.preselect === false) {
+        result.preselect = item.preselect;
+      }
+      var data = (_item$data = item.data) !== null && _item$data !== void 0 ? _item$data : itemDefaults === null || itemDefaults === void 0 ? void 0 : itemDefaults.data;
+      if (data !== undefined) {
+        result.data = data;
+      }
+      if (item.deprecated === true || item.deprecated === false) {
+        result.deprecated = item.deprecated;
+      }
+      var insertTextMode = (_item$insertTextMode = item.insertTextMode) !== null && _item$insertTextMode !== void 0 ? _item$insertTextMode : itemDefaults === null || itemDefaults === void 0 ? void 0 : itemDefaults.insertTextMode;
+      if (insertTextMode) {
+        result.insertTextMode = insertTextMode;
+      }
+      if (item.tags) {
+        result.tags = item.tags;
+      }
+      return result;
+    }
+  }, {
+    key: "getCompletionItemDefaultRange",
+    value: function getCompletionItemDefaultRange(list) {
+      var _list$itemDefaults;
+      var rangeDefaults = (_list$itemDefaults = list.itemDefaults) === null || _list$itemDefaults === void 0 ? void 0 : _list$itemDefaults.editRange;
+      return ls.Range.is(rangeDefaults) ? this.asRange(rangeDefaults) : rangeDefaults !== undefined ? {
+        insert: this.asRange(rangeDefaults.insert),
+        replace: this.asRange(rangeDefaults.replace)
+      } : undefined;
+    }
+  }, {
+    key: "asCompletionItemLabel",
+    value: function asCompletionItemLabel(item) {
+      if (ls.CompletionItemLabelDetails.is(item.labelDetails)) {
+        return {
+          label: item.label,
+          detail: item.labelDetails.detail,
+          description: item.labelDetails.description
+        };
+      } else {
+        return item.label;
+      }
+    }
+  }, {
+    key: "asCompletionItemKind",
+    value: function asCompletionItemKind(value) {
+      if (CompletionItemKind.Text <= value && value <= CompletionItemKind.TypeParameter) {
+        switch (value) {
+          case CompletionItemKind.Text:
+            return [this._monaco.languages.CompletionItemKind.Text, undefined];
+          case CompletionItemKind.Method:
+            return [this._monaco.languages.CompletionItemKind.Method, undefined];
+          case CompletionItemKind.Function:
+            return [this._monaco.languages.CompletionItemKind.Function, undefined];
+          case CompletionItemKind.Constructor:
+            return [this._monaco.languages.CompletionItemKind.Constructor, undefined];
+          case CompletionItemKind.Field:
+            return [this._monaco.languages.CompletionItemKind.Field, undefined];
+          case CompletionItemKind.Variable:
+            return [this._monaco.languages.CompletionItemKind.Variable, undefined];
+          case CompletionItemKind.Class:
+            return [this._monaco.languages.CompletionItemKind.Class, undefined];
+          case CompletionItemKind.Interface:
+            return [this._monaco.languages.CompletionItemKind.Interface, undefined];
+          case CompletionItemKind.Module:
+            return [this._monaco.languages.CompletionItemKind.Module, undefined];
+          case CompletionItemKind.Property:
+            return [this._monaco.languages.CompletionItemKind.Property, undefined];
+          case CompletionItemKind.Unit:
+            return [this._monaco.languages.CompletionItemKind.Unit, undefined];
+          case CompletionItemKind.Value:
+            return [this._monaco.languages.CompletionItemKind.Value, undefined];
+          case CompletionItemKind.Enum:
+            return [this._monaco.languages.CompletionItemKind.Enum, undefined];
+          case CompletionItemKind.Keyword:
+            return [this._monaco.languages.CompletionItemKind.Keyword, undefined];
+          case CompletionItemKind.Snippet:
+            return [this._monaco.languages.CompletionItemKind.Snippet, undefined];
+          case CompletionItemKind.Color:
+            return [this._monaco.languages.CompletionItemKind.Color, undefined];
+          case CompletionItemKind.File:
+            return [this._monaco.languages.CompletionItemKind.File, undefined];
+          case CompletionItemKind.Reference:
+            return [this._monaco.languages.CompletionItemKind.Reference, undefined];
+          case CompletionItemKind.Folder:
+            return [this._monaco.languages.CompletionItemKind.Folder, undefined];
+          case CompletionItemKind.EnumMember:
+            return [this._monaco.languages.CompletionItemKind.EnumMember, undefined];
+          case CompletionItemKind.Constant:
+            return [this._monaco.languages.CompletionItemKind.Constant, undefined];
+          case CompletionItemKind.Struct:
+            return [this._monaco.languages.CompletionItemKind.Struct, undefined];
+          case CompletionItemKind.Event:
+            return [this._monaco.languages.CompletionItemKind.Event, undefined];
+          case CompletionItemKind.Operator:
+            return [this._monaco.languages.CompletionItemKind.Operator, undefined];
+          case CompletionItemKind.TypeParameter:
+            return [this._monaco.languages.CompletionItemKind.TypeParameter, undefined];
+          default:
+            return [value - 1, undefined];
+        }
+      }
+      return [CompletionItemKind.Text, value];
+    }
+  }, {
+    key: "asCompletionInsertText",
+    value: function asCompletionInsertText(item, defaultRange, defaultInsertTextFormat) {
+      var _item$insertTextForma;
+      var insertTextFormat = (_item$insertTextForma = item.insertTextFormat) !== null && _item$insertTextForma !== void 0 ? _item$insertTextForma : defaultInsertTextFormat;
+      var isSnippet = insertTextFormat === InsertTextFormat.Snippet;
+      if (item.textEdit !== undefined || defaultRange !== undefined) {
+        var _item$textEditText;
+        var _ref = item.textEdit !== undefined ? this.getCompletionRangeAndText(item.textEdit) : [defaultRange, (_item$textEditText = item.textEditText) !== null && _item$textEditText !== void 0 ? _item$textEditText : item.label],
+          _ref2 = _slicedToArray(_ref, 2),
+          _range = _ref2[0],
+          newText = _ref2[1];
+        return {
+          insertText: newText,
+          range: _range,
+          fromEdit: true,
+          isSnippet: isSnippet
+        };
+      } else if (item.insertText) {
+        return {
+          isSnippet: isSnippet,
+          insertText: item.insertText,
+          fromEdit: false,
+          range: defaultRange
+        };
+      }
+      return {
+        insertText: item.label,
+        range: defaultRange,
+        fromEdit: false,
+        isSnippet: false
+      };
+    }
+  }, {
+    key: "getCompletionRangeAndText",
+    value: function getCompletionRangeAndText(value) {
+      if (ls.InsertReplaceEdit.is(value)) {
+        return [{
+          insert: this.asRange(value.insert),
+          replace: this.asRange(value.replace)
+        }, value.newText];
+      } else {
+        return [this.asRange(value.range), value.newText];
+      }
+    }
+  }, {
+    key: "asDocumentLinks",
+    value: function asDocumentLinks(documentLinks) {
+      var _this23 = this;
+      var links = documentLinks.map(function (link) {
+        return _this23.asDocumentLink(link);
+      });
+      return {
+        links: links
+      };
+    }
+  }, {
+    key: "asDocumentLink",
+    value: function asDocumentLink(documentLink) {
+      return {
+        range: this.asRange(documentLink.range),
+        url: documentLink.target,
+        data: documentLink.data,
+        tooltip: documentLink.tooltip
+      };
+    }
+  }, {
+    key: "asRange",
+    value: function asRange(range) {
+      if (range === undefined) {
+        return undefined;
+      }
+      if (range === null) {
+        return null;
+      }
+      var start = this.asPosition(range.start);
+      var end = this.asPosition(range.end);
+      if (start instanceof this._monaco.Position && end instanceof this._monaco.Position) {
+        return new this._monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+      }
+      var startLineNumber = !start || start.lineNumber === undefined ? undefined : start.lineNumber;
+      var startColumn = !start || start.column === undefined ? undefined : start.column;
+      var endLineNumber = !end || end.lineNumber === undefined ? undefined : end.lineNumber;
+      var endColumn = !end || end.column === undefined ? undefined : end.column;
+      return {
+        startLineNumber: startLineNumber,
+        startColumn: startColumn,
+        endLineNumber: endLineNumber,
+        endColumn: endColumn
+      };
+    }
+  }, {
+    key: "asPosition",
+    value: function asPosition(position) {
+      if (position === undefined) {
+        return undefined;
+      }
+      if (position === null) {
+        return null;
+      }
+      var line = position.line,
+        character = position.character;
+      var lineNumber = line === undefined ? undefined : line + 1;
+      var column = character === undefined ? undefined : character + 1;
+      if (lineNumber !== undefined && column !== undefined) {
+        return new this._monaco.Position(lineNumber, column);
+      }
+      return {
+        lineNumber: lineNumber,
+        column: column
+      };
+    }
+  }, {
+    key: "asColorInformations",
+    value: function asColorInformations(items) {
+      var _this24 = this;
+      return items.map(function (item) {
+        return _this24.asColorInformation(item);
+      });
+    }
+  }, {
+    key: "asColorInformation",
+    value: function asColorInformation(item) {
+      return {
+        range: this.asRange(item.range),
+        color: item.color
+      };
+    }
+  }, {
+    key: "asColorPresentations",
+    value: function asColorPresentations(items) {
+      var _this25 = this;
+      return items.map(function (item) {
+        return _this25.asColorPresentation(item);
+      });
+    }
+  }, {
+    key: "asColorPresentation",
+    value: function asColorPresentation(item) {
+      return {
+        label: item.label,
+        textEdit: this.asTextEdit(item.textEdit),
+        additionalTextEdits: this.asTextEdits(item.additionalTextEdits)
+      };
+    }
+  }, {
+    key: "asFoldingRanges",
+    value: function asFoldingRanges(items) {
+      var _this26 = this;
+      if (!items) {
+        return items;
+      }
+      return items.map(function (item) {
+        return _this26.asFoldingRange(item);
+      });
+    }
+  }, {
+    key: "asFoldingRange",
+    value: function asFoldingRange(item) {
+      return {
+        start: item.startLine + 1,
+        end: item.endLine + 1,
+        kind: this.asFoldingRangeKind(item.kind)
+      };
+    }
+  }, {
+    key: "asFoldingRangeKind",
+    value: function asFoldingRangeKind(kind) {
+      if (kind) {
+        switch (kind) {
+          case FoldingRangeKind.Comment:
+            return this._monaco.languages.FoldingRangeKind.Comment;
+          case FoldingRangeKind.Imports:
+            return this._monaco.languages.FoldingRangeKind.Imports;
+          case FoldingRangeKind.Region:
+            return this._monaco.languages.FoldingRangeKind.Region;
+        }
+      }
+      return undefined;
+    }
+  }, {
+    key: "asSemanticTokens",
+    value: function asSemanticTokens(semanticTokens) {
+      return {
+        resultId: semanticTokens.resultId,
+        data: Uint32Array.from(semanticTokens.data)
+      };
+    }
+  }, {
+    key: "asInlayHintLabelPart",
+    value: function asInlayHintLabelPart(part) {
+      return {
+        label: part.value,
+        command: this.asCommand(part.command),
+        location: this.asLocation(part.location),
+        tooltip: part.tooltip && this.asMarkdownString(part.tooltip)
+      };
+    }
+  }, {
+    key: "asInlayHintLabel",
+    value: function asInlayHintLabel(label) {
+      var _this27 = this;
+      if (Array.isArray(label)) {
+        return label.map(function (part) {
+          return _this27.asInlayHintLabelPart(part);
+        });
+      }
+      return label;
+    }
+  }, {
+    key: "asInlayHint",
+    value: function asInlayHint(inlayHint) {
+      return {
+        data: inlayHint.data,
+        label: this.asInlayHintLabel(inlayHint.label),
+        position: this.asPosition(inlayHint.position),
+        kind: inlayHint.kind,
+        paddingLeft: inlayHint.paddingLeft,
+        paddingRight: inlayHint.paddingRight,
+        tooltip: inlayHint.tooltip && this.asMarkdownString(inlayHint.tooltip)
+      };
+    }
+  }, {
+    key: "asInlayHintList",
+    value: function asInlayHintList(items) {
+      var _this28 = this;
+      if (!items) {
+        return undefined;
+      }
+      return {
+        hints: items.map(function (hint) {
+          return _this28.asInlayHint(hint);
+        }),
+        dispose: function dispose() {}
+      };
+    }
+  }]);
+  return ProtocolToMonacoConverter;
+}();