@difizen/libro-language-client 0.1.18

package/es/common/protocolConverter.js

@@ -0,0 +1,1982 @@
+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 _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, ""); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, "_invoke", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: "normal", arg: t.call(e, r) }; } catch (t) { return { type: "throw", arg: t }; } } e.wrap = wrap; var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { ["next", "throw", "return"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if ("throw" !== c.type) { var u = c.arg, h = u.value; return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { invoke("next", t, i, a); }, function (t) { invoke("throw", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke("throw", t, i, a); }); } a(c.arg); } var r; o(this, "_invoke", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error("Generator is already running"); if (o === s) { if ("throw" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else "return" === n.method && n.abrupt("return", n.arg); o = f; var p = tryCatch(e, r, n); if ("normal" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; var i = tryCatch(o, e.iterator, r.arg); if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = "normal", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: "root" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || "" === e) { var r = e[a]; if (r) return r.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + " is not iterable"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { var e = "function" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { return this; }), define(g, "toString", function () { return "[object Generator]"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if ("throw" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if ("root" === i.tryLoc) return handle("end"); if (i.tryLoc <= this.prev) { var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { var i = o; break; } } i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if ("throw" === t.type) throw t.arg; return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, catch: function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if ("throw" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, "next" === this.method && (this.arg = t), y; } }, e; }
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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 _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; }
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. 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 { NotebookCellTextDocumentFilter, TextDocumentFilter } from '@difizen/vscode-languageserver-protocol';
+import { URI } from 'vscode-uri';
+import ProtocolCallHierarchyItem from "./protocolCallHierarchyItem.js";
+import ProtocolCodeAction from "./protocolCodeAction.js";
+import ProtocolCodeLens from "./protocolCodeLens.js";
+import ProtocolCompletionItem from "./protocolCompletionItem.js";
+import { ProtocolDiagnostic, DiagnosticCode } from "./protocolDiagnostic.js";
+import ProtocolDocumentLink from "./protocolDocumentLink.js";
+import ProtocolInlayHint from "./protocolInlayHint.js";
+import ProtocolTypeHierarchyItem from "./protocolTypeHierarchyItem.js";
+import WorkspaceSymbol from "./protocolWorkspaceSymbol.js";
+import * as async from "./utils/async.js";
+import * as Is from "./utils/is.js";
+import { Position, Uri, CompletionList, DiagnosticSeverity, DiagnosticTag, Hover, DocumentHighlight, DocumentHighlightKind, DocumentSymbol, ParameterInformation, SignatureHelp, SignatureInformation, SymbolInformation, SymbolKind, SymbolTag, TextEdit, CodeActionKind, WorkspaceEdit, CallHierarchyIncomingCall, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, SemanticTokensEdit, SemanticTokensEdits, CallHierarchyOutgoingCall, InlineSuggestion as InlineCompletionItem, InlineSuggestionList as InlineCompletionList, MarkdownString, SemanticTokens, LinkedEditingRanges } from "./vscodeAdaptor/vscodeAdaptor.js";
+import { DiagnosticRelatedInformation, Range, Location, InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression, RelativePattern, InlayHintLabelPart } from "./vscodeAdaptor/vscodeAdaptor.js";
+import { CompletionItemKind, CompletionItemTag, workspace } from "./vscodeAdaptor/vscodeAdaptor.js";
+import { SnippetString } from "./vscodeAdaptor/vscodeAdaptor.js";
+var CodeBlock;
+(function (_CodeBlock) {
+  function is(value) {
+    var candidate = value;
+    return candidate && Is.string(candidate.language) && Is.string(candidate.value);
+  }
+  _CodeBlock.is = is;
+})(CodeBlock || (CodeBlock = {}));
+export function createConverter(uriConverter, trustMarkdown, supportHtml) {
+  var nullConverter = function nullConverter(value) {
+    return Uri.parse(value);
+  };
+  var _uriConverter = uriConverter || nullConverter;
+  function asUri(value) {
+    return _uriConverter(value);
+  }
+  function asDocumentSelector(selector) {
+    var result = [];
+    var _iterator = _createForOfIteratorHelper(selector),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var filter = _step.value;
+        if (typeof filter === 'string') {
+          result.push(filter);
+        } else if (NotebookCellTextDocumentFilter.is(filter)) {
+          // We first need to check for the notebook cell filter since a TextDocumentFilter would
+          // match both (e.g. the notebook is optional).
+          if (typeof filter.notebook === 'string') {
+            result.push({
+              notebookType: filter.notebook,
+              language: filter.language
+            });
+          } else {
+            var _filter$notebook$note;
+            var notebookType = (_filter$notebook$note = filter.notebook.notebookType) !== null && _filter$notebook$note !== void 0 ? _filter$notebook$note : '*';
+            result.push({
+              notebookType: notebookType,
+              scheme: filter.notebook.scheme,
+              pattern: filter.notebook.pattern,
+              language: filter.language
+            });
+          }
+        } else if (TextDocumentFilter.is(filter)) {
+          result.push({
+            language: filter.language,
+            scheme: filter.scheme,
+            pattern: filter.pattern
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  }
+  function asDiagnostics(_x, _x2) {
+    return _asDiagnostics.apply(this, arguments);
+  }
+  function _asDiagnostics() {
+    _asDiagnostics = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(diagnostics, token) {
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            return _context2.abrupt("return", async.map(diagnostics, asDiagnostic, token));
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return _asDiagnostics.apply(this, arguments);
+  }
+  function asDiagnosticsSync(diagnostics) {
+    var result = new Array(diagnostics.length);
+    for (var i = 0; i < diagnostics.length; i++) {
+      result[i] = asDiagnostic(diagnostics[i]);
+    }
+    return result;
+  }
+  function asDiagnostic(diagnostic) {
+    var result = new ProtocolDiagnostic(asRange(diagnostic.range), diagnostic.message, asDiagnosticSeverity(diagnostic.severity), diagnostic.data);
+    if (diagnostic.code !== undefined) {
+      if (typeof diagnostic.code === 'string' || typeof diagnostic.code === 'number') {
+        if (ls.CodeDescription.is(diagnostic.codeDescription)) {
+          result.code = {
+            value: diagnostic.code,
+            target: asUri(diagnostic.codeDescription.href)
+          };
+        } else {
+          result.code = diagnostic.code;
+        }
+      } else if (DiagnosticCode.is(diagnostic.code)) {
+        // This is for backwards compatibility of a proposed API.
+        // We should remove this at some point.
+        result.hasDiagnosticCode = true;
+        var diagnosticCode = diagnostic.code;
+        result.code = {
+          value: diagnosticCode.value,
+          target: asUri(diagnosticCode.target)
+        };
+      }
+    }
+    if (diagnostic.source) {
+      result.source = diagnostic.source;
+    }
+    if (diagnostic.relatedInformation) {
+      result.relatedInformation = asRelatedInformation(diagnostic.relatedInformation);
+    }
+    if (Array.isArray(diagnostic.tags)) {
+      result.tags = asDiagnosticTags(diagnostic.tags);
+    }
+    return result;
+  }
+  function asRelatedInformation(relatedInformation) {
+    var result = new Array(relatedInformation.length);
+    for (var i = 0; i < relatedInformation.length; i++) {
+      var info = relatedInformation[i];
+      result[i] = new DiagnosticRelatedInformation(asLocation(info.location), info.message);
+    }
+    return result;
+  }
+  function asDiagnosticTags(tags) {
+    if (!tags) {
+      return undefined;
+    }
+    var result = [];
+    var _iterator2 = _createForOfIteratorHelper(tags),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _tag = _step2.value;
+        var converted = asDiagnosticTag(_tag);
+        if (converted !== undefined) {
+          result.push(converted);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return result.length > 0 ? result : undefined;
+  }
+  function asDiagnosticTag(tag) {
+    switch (tag) {
+      case ls.DiagnosticTag.Unnecessary:
+        return DiagnosticTag.Unnecessary;
+      case ls.DiagnosticTag.Deprecated:
+        return DiagnosticTag.Deprecated;
+      default:
+        return undefined;
+    }
+  }
+  function asPosition(value) {
+    return value ? new Position(value.line, value.character) : undefined;
+  }
+  function asRange(value) {
+    return value ? new Range(value.start.line, value.start.character, value.end.line, value.end.character) : undefined;
+  }
+  function asRanges(_x3, _x4) {
+    return _asRanges.apply(this, arguments);
+  }
+  function _asRanges() {
+    _asRanges = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(items, token) {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            return _context3.abrupt("return", async.map(items, function (range) {
+              return new Range(range.start.line, range.start.character, range.end.line, range.end.character);
+            }, token));
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return _asRanges.apply(this, arguments);
+  }
+  function asDiagnosticSeverity(value) {
+    if (value === undefined || value === null) {
+      return DiagnosticSeverity.Error;
+    }
+    switch (value) {
+      case ls.DiagnosticSeverity.Error:
+        return DiagnosticSeverity.Error;
+      case ls.DiagnosticSeverity.Warning:
+        return DiagnosticSeverity.Warning;
+      case ls.DiagnosticSeverity.Information:
+        return DiagnosticSeverity.Information;
+      case ls.DiagnosticSeverity.Hint:
+        return DiagnosticSeverity.Hint;
+    }
+    return DiagnosticSeverity.Error;
+  }
+  function asHoverContent(value) {
+    if (Is.string(value)) {
+      return asMarkdownString(value);
+    } else if (CodeBlock.is(value)) {
+      var result = asMarkdownString();
+      return result.appendCodeblock(value.value, value.language);
+    } else if (Array.isArray(value)) {
+      var _result = [];
+      var _iterator3 = _createForOfIteratorHelper(value),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var element = _step3.value;
+          var _item = asMarkdownString();
+          if (CodeBlock.is(element)) {
+            _item.appendCodeblock(element.value, element.language);
+          } else {
+            _item.appendMarkdown(element);
+          }
+          _result.push(_item);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return _result;
+    } else {
+      return asMarkdownString(value);
+    }
+  }
+  function asDocumentation(value) {
+    if (Is.string(value)) {
+      return value;
+    } else {
+      switch (value.kind) {
+        case ls.MarkupKind.Markdown:
+          return asMarkdownString(value.value);
+        case ls.MarkupKind.PlainText:
+          return value.value;
+        default:
+          return "Unsupported Markup content received. Kind is: ".concat(value.kind);
+      }
+    }
+  }
+  function asMarkdownString(value) {
+    var result;
+    if (value === undefined || typeof value === 'string') {
+      result = new MarkdownString(value);
+    } else {
+      switch (value.kind) {
+        case ls.MarkupKind.Markdown:
+          result = new MarkdownString(value.value);
+          break;
+        case ls.MarkupKind.PlainText:
+          result = new MarkdownString();
+          result.appendText(value.value);
+          break;
+        default:
+          result = new MarkdownString();
+          result.appendText("Unsupported Markup content received. Kind is: ".concat(value.kind));
+          break;
+      }
+    }
+    result.isTrusted = trustMarkdown;
+    result.supportHtml = supportHtml;
+    return result;
+  }
+  function asHover(hover) {
+    if (!hover) {
+      return undefined;
+    }
+    return new Hover(asHoverContent(hover.contents), asRange(hover.range));
+  }
+  function asCompletionResult(_x5, _x6, _x7) {
+    return _asCompletionResult.apply(this, arguments);
+  }
+  function _asCompletionResult() {
+    _asCompletionResult = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(value, allCommitCharacters, token) {
+      var list, _getCompletionItemDef, defaultRange, commitCharacters, converted;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            if (value) {
+              _context4.next = 2;
+              break;
+            }
+            return _context4.abrupt("return", undefined);
+          case 2:
+            if (!Array.isArray(value)) {
+              _context4.next = 4;
+              break;
+            }
+            return _context4.abrupt("return", async.map(value, function (item) {
+              return asCompletionItem(item, allCommitCharacters);
+            }, token));
+          case 4:
+            list = value;
+            _getCompletionItemDef = getCompletionItemDefaults(list, allCommitCharacters), defaultRange = _getCompletionItemDef.defaultRange, commitCharacters = _getCompletionItemDef.commitCharacters;
+            _context4.next = 8;
+            return async.map(list.items, function (item) {
+              var _list$itemDefaults3, _list$itemDefaults4, _list$itemDefaults5;
+              return asCompletionItem(item, commitCharacters, defaultRange, (_list$itemDefaults3 = list.itemDefaults) === null || _list$itemDefaults3 === void 0 ? void 0 : _list$itemDefaults3.insertTextMode, (_list$itemDefaults4 = list.itemDefaults) === null || _list$itemDefaults4 === void 0 ? void 0 : _list$itemDefaults4.insertTextFormat, (_list$itemDefaults5 = list.itemDefaults) === null || _list$itemDefaults5 === void 0 ? void 0 : _list$itemDefaults5.data);
+            }, token);
+          case 8:
+            converted = _context4.sent;
+            return _context4.abrupt("return", new CompletionList(converted, list.isIncomplete));
+          case 10:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }));
+    return _asCompletionResult.apply(this, arguments);
+  }
+  function getCompletionItemDefaults(list, allCommitCharacters) {
+    var _list$itemDefaults, _list$itemDefaults$co, _list$itemDefaults2;
+    var rangeDefaults = (_list$itemDefaults = list.itemDefaults) === null || _list$itemDefaults === void 0 ? void 0 : _list$itemDefaults.editRange;
+    var commitCharacters = (_list$itemDefaults$co = (_list$itemDefaults2 = list.itemDefaults) === null || _list$itemDefaults2 === void 0 ? void 0 : _list$itemDefaults2.commitCharacters) !== null && _list$itemDefaults$co !== void 0 ? _list$itemDefaults$co : allCommitCharacters;
+    return ls.Range.is(rangeDefaults) ? {
+      defaultRange: asRange(rangeDefaults),
+      commitCharacters: commitCharacters
+    } : rangeDefaults !== undefined ? {
+      defaultRange: {
+        inserting: asRange(rangeDefaults.insert),
+        replacing: asRange(rangeDefaults.replace)
+      },
+      commitCharacters: commitCharacters
+    } : {
+      defaultRange: undefined,
+      commitCharacters: commitCharacters
+    };
+  }
+  function asCompletionItemKind(value) {
+    // Protocol item kind is 1 based, codes item kind is zero based.
+    if (ls.CompletionItemKind.Text <= value && value <= ls.CompletionItemKind.TypeParameter) {
+      return [value - 1, undefined];
+    }
+    return [CompletionItemKind.Text, value];
+  }
+  function asCompletionItemTag(tag) {
+    switch (tag) {
+      case ls.CompletionItemTag.Deprecated:
+        return CompletionItemTag.Deprecated;
+    }
+    return undefined;
+  }
+  function asCompletionItemTags(tags) {
+    if (tags === undefined || tags === null) {
+      return [];
+    }
+    var result = [];
+    var _iterator4 = _createForOfIteratorHelper(tags),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _tag2 = _step4.value;
+        var converted = asCompletionItemTag(_tag2);
+        if (converted !== undefined) {
+          result.push(converted);
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    return result;
+  }
+  function asCompletionItem(item, defaultCommitCharacters, defaultRange, defaultInsertTextMode, defaultInsertTextFormat, defaultData) {
+    var _item$data, _item$insertTextMode;
+    var tags = asCompletionItemTags(item.tags);
+    var label = asCompletionItemLabel(item);
+    var result = new ProtocolCompletionItem(label);
+    if (item.detail) {
+      result.detail = item.detail;
+    }
+    if (item.documentation) {
+      result.documentation = asDocumentation(item.documentation);
+      result.documentationFormat = Is.string(item.documentation) ? '$string' : item.documentation.kind;
+    }
+    if (item.filterText) {
+      result.filterText = item.filterText;
+    }
+    var insertText = asCompletionInsertText(item, defaultRange, defaultInsertTextFormat);
+    if (insertText) {
+      result.insertText = insertText.text;
+      result.range = insertText.range;
+      result.fromEdit = insertText.fromEdit;
+    }
+    if (Is.number(item.kind)) {
+      var _asCompletionItemKind = asCompletionItemKind(item.kind),
+        _asCompletionItemKind2 = _slicedToArray(_asCompletionItemKind, 2),
+        itemKind = _asCompletionItemKind2[0],
+        original = _asCompletionItemKind2[1];
+      result.kind = itemKind;
+      if (original) {
+        result.originalItemKind = original;
+      }
+    }
+    if (item.sortText) {
+      result.sortText = item.sortText;
+    }
+    if (item.additionalTextEdits) {
+      result.additionalTextEdits = asTextEditsSync(item.additionalTextEdits);
+    }
+    var commitCharacters = item.commitCharacters !== undefined ? Is.stringArray(item.commitCharacters) ? item.commitCharacters : undefined : defaultCommitCharacters;
+    if (commitCharacters) {
+      result.commitCharacters = commitCharacters.slice();
+    }
+    if (item.command) {
+      result.command = asCommand(item.command);
+    }
+    if (item.deprecated === true || item.deprecated === false) {
+      result.deprecated = item.deprecated;
+      if (item.deprecated === true) {
+        tags.push(CompletionItemTag.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 : defaultData;
+    if (data !== undefined) {
+      result.data = data;
+    }
+    if (tags.length > 0) {
+      result.tags = tags;
+    }
+    var insertTextMode = (_item$insertTextMode = item.insertTextMode) !== null && _item$insertTextMode !== void 0 ? _item$insertTextMode : defaultInsertTextMode;
+    if (insertTextMode !== undefined) {
+      result.insertTextMode = insertTextMode;
+      if (insertTextMode === ls.InsertTextMode.asIs) {
+        result.keepWhitespace = true;
+      }
+    }
+    return result;
+  }
+  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;
+    }
+  }
+  function asCompletionInsertText(item, defaultRange, defaultInsertTextFormat) {
+    var _item$insertTextForma;
+    var insertTextFormat = (_item$insertTextForma = item.insertTextFormat) !== null && _item$insertTextForma !== void 0 ? _item$insertTextForma : defaultInsertTextFormat;
+    if (item.textEdit !== undefined || defaultRange !== undefined) {
+      var _item$textEditText;
+      var _ref = item.textEdit !== undefined ? 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];
+      if (insertTextFormat === ls.InsertTextFormat.Snippet) {
+        return {
+          text: new SnippetString(newText),
+          range: range,
+          fromEdit: true
+        };
+      } else {
+        return {
+          text: newText,
+          range: range,
+          fromEdit: true
+        };
+      }
+    } else if (item.insertText) {
+      if (insertTextFormat === ls.InsertTextFormat.Snippet) {
+        return {
+          text: new SnippetString(item.insertText),
+          fromEdit: false
+        };
+      } else {
+        return {
+          text: item.insertText,
+          fromEdit: false
+        };
+      }
+    } else {
+      return undefined;
+    }
+  }
+  function getCompletionRangeAndText(value) {
+    if (ls.InsertReplaceEdit.is(value)) {
+      return [{
+        inserting: asRange(value.insert),
+        replacing: asRange(value.replace)
+      }, value.newText];
+    } else {
+      return [asRange(value.range), value.newText];
+    }
+  }
+  function asTextEdit(edit) {
+    if (!edit) {
+      return undefined;
+    }
+    return new TextEdit(asRange(edit.range), edit.newText);
+  }
+  function asTextEdits(_x8, _x9) {
+    return _asTextEdits.apply(this, arguments);
+  }
+  function _asTextEdits() {
+    _asTextEdits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(items, token) {
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            if (items) {
+              _context5.next = 2;
+              break;
+            }
+            return _context5.abrupt("return", undefined);
+          case 2:
+            return _context5.abrupt("return", async.map(items, asTextEdit, token));
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }));
+    return _asTextEdits.apply(this, arguments);
+  }
+  function asTextEditsSync(items) {
+    if (!items) {
+      return undefined;
+    }
+    var result = new Array(items.length);
+    for (var i = 0; i < items.length; i++) {
+      result[i] = asTextEdit(items[i]);
+    }
+    return result;
+  }
+  function asSignatureHelp(_x10, _x11) {
+    return _asSignatureHelp.apply(this, arguments);
+  }
+  function _asSignatureHelp() {
+    _asSignatureHelp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(item, token) {
+      var result;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            if (item) {
+              _context6.next = 2;
+              break;
+            }
+            return _context6.abrupt("return", undefined);
+          case 2:
+            result = new SignatureHelp();
+            if (Is.number(item.activeSignature)) {
+              result.activeSignature = item.activeSignature;
+            } else {
+              // activeSignature was optional in the past
+              result.activeSignature = 0;
+            }
+            if (Is.number(item.activeParameter)) {
+              result.activeParameter = item.activeParameter;
+            } else if (item.activeParameter === null) {
+              result.activeParameter = -1;
+            } else {
+              // activeParameter was optional in the past
+              result.activeParameter = 0;
+            }
+            if (!item.signatures) {
+              _context6.next = 9;
+              break;
+            }
+            _context6.next = 8;
+            return asSignatureInformations(item.signatures, token);
+          case 8:
+            result.signatures = _context6.sent;
+          case 9:
+            return _context6.abrupt("return", result);
+          case 10:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }));
+    return _asSignatureHelp.apply(this, arguments);
+  }
+  function asSignatureInformations(_x12, _x13) {
+    return _asSignatureInformations.apply(this, arguments);
+  }
+  function _asSignatureInformations() {
+    _asSignatureInformations = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(items, token) {
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            return _context7.abrupt("return", async.mapAsync(items, asSignatureInformation, token));
+          case 1:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    }));
+    return _asSignatureInformations.apply(this, arguments);
+  }
+  function asSignatureInformation(_x14, _x15) {
+    return _asSignatureInformation.apply(this, arguments);
+  }
+  function _asSignatureInformation() {
+    _asSignatureInformation = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(item, token) {
+      var result, _item$activeParameter;
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            result = new SignatureInformation(item.label);
+            if (item.documentation !== undefined) {
+              result.documentation = asDocumentation(item.documentation);
+            }
+            if (!(item.parameters !== undefined)) {
+              _context8.next = 6;
+              break;
+            }
+            _context8.next = 5;
+            return asParameterInformations(item.parameters, token);
+          case 5:
+            result.parameters = _context8.sent;
+          case 6:
+            if (item.activeParameter !== undefined) {
+              result.activeParameter = (_item$activeParameter = item.activeParameter) !== null && _item$activeParameter !== void 0 ? _item$activeParameter : -1;
+            }
+            return _context8.abrupt("return", result);
+          case 8:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    }));
+    return _asSignatureInformation.apply(this, arguments);
+  }
+  function asParameterInformations(items, token) {
+    return async.map(items, asParameterInformation, token);
+  }
+  function asParameterInformation(item) {
+    var result = new ParameterInformation(item.label);
+    if (item.documentation) {
+      result.documentation = asDocumentation(item.documentation);
+    }
+    return result;
+  }
+  function asLocation(item) {
+    return item ? new Location(_uriConverter(item.uri), asRange(item.range)) : undefined;
+  }
+  function asDeclarationResult(_x16, _x17) {
+    return _asDeclarationResult.apply(this, arguments);
+  }
+  function _asDeclarationResult() {
+    _asDeclarationResult = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(item, token) {
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            if (item) {
+              _context9.next = 2;
+              break;
+            }
+            return _context9.abrupt("return", undefined);
+          case 2:
+            return _context9.abrupt("return", asLocationResult(item, token));
+          case 3:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    }));
+    return _asDeclarationResult.apply(this, arguments);
+  }
+  function asDefinitionResult(_x18, _x19) {
+    return _asDefinitionResult.apply(this, arguments);
+  }
+  function _asDefinitionResult() {
+    _asDefinitionResult = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(item, token) {
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            if (item) {
+              _context10.next = 2;
+              break;
+            }
+            return _context10.abrupt("return", undefined);
+          case 2:
+            return _context10.abrupt("return", asLocationResult(item, token));
+          case 3:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    }));
+    return _asDefinitionResult.apply(this, arguments);
+  }
+  function asLocationLink(item) {
+    if (!item) {
+      return undefined;
+    }
+    var result = {
+      targetUri: _uriConverter(item.targetUri),
+      targetRange: asRange(item.targetRange),
+      // See issue: https://github.com/Microsoft/vscode/issues/58649
+      originSelectionRange: asRange(item.originSelectionRange),
+      targetSelectionRange: asRange(item.targetSelectionRange)
+    };
+    if (!result.targetSelectionRange) {
+      throw new Error("targetSelectionRange must not be undefined or null");
+    }
+    return result;
+  }
+  function asLocationResult(_x20, _x21) {
+    return _asLocationResult.apply(this, arguments);
+  }
+  function _asLocationResult() {
+    _asLocationResult = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(item, token) {
+      var links, locations;
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            if (item) {
+              _context11.next = 2;
+              break;
+            }
+            return _context11.abrupt("return", undefined);
+          case 2:
+            if (!Is.array(item)) {
+              _context11.next = 16;
+              break;
+            }
+            if (!(item.length === 0)) {
+              _context11.next = 7;
+              break;
+            }
+            return _context11.abrupt("return", []);
+          case 7:
+            if (!ls.LocationLink.is(item[0])) {
+              _context11.next = 12;
+              break;
+            }
+            links = item;
+            return _context11.abrupt("return", async.map(links, asLocationLink, token));
+          case 12:
+            locations = item;
+            return _context11.abrupt("return", async.map(locations, asLocation, token));
+          case 14:
+            _context11.next = 21;
+            break;
+          case 16:
+            if (!ls.LocationLink.is(item)) {
+              _context11.next = 20;
+              break;
+            }
+            return _context11.abrupt("return", [asLocationLink(item)]);
+          case 20:
+            return _context11.abrupt("return", asLocation(item));
+          case 21:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    }));
+    return _asLocationResult.apply(this, arguments);
+  }
+  function asReferences(_x22, _x23) {
+    return _asReferences.apply(this, arguments);
+  }
+  function _asReferences() {
+    _asReferences = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(values, token) {
+      return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            if (values) {
+              _context12.next = 2;
+              break;
+            }
+            return _context12.abrupt("return", undefined);
+          case 2:
+            return _context12.abrupt("return", async.map(values, asLocation, token));
+          case 3:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    }));
+    return _asReferences.apply(this, arguments);
+  }
+  function asDocumentHighlights(_x24, _x25) {
+    return _asDocumentHighlights.apply(this, arguments);
+  }
+  function _asDocumentHighlights() {
+    _asDocumentHighlights = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(values, token) {
+      return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            if (values) {
+              _context13.next = 2;
+              break;
+            }
+            return _context13.abrupt("return", undefined);
+          case 2:
+            return _context13.abrupt("return", async.map(values, asDocumentHighlight, token));
+          case 3:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    }));
+    return _asDocumentHighlights.apply(this, arguments);
+  }
+  function asDocumentHighlight(item) {
+    var result = new DocumentHighlight(asRange(item.range));
+    if (Is.number(item.kind)) {
+      result.kind = asDocumentHighlightKind(item.kind);
+    }
+    return result;
+  }
+  function asDocumentHighlightKind(item) {
+    switch (item) {
+      case ls.DocumentHighlightKind.Text:
+        return DocumentHighlightKind.Text;
+      case ls.DocumentHighlightKind.Read:
+        return DocumentHighlightKind.Read;
+      case ls.DocumentHighlightKind.Write:
+        return DocumentHighlightKind.Write;
+    }
+    return DocumentHighlightKind.Text;
+  }
+  function asSymbolInformations(_x26, _x27) {
+    return _asSymbolInformations.apply(this, arguments);
+  }
+  function _asSymbolInformations() {
+    _asSymbolInformations = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14(values, token) {
+      return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            if (values) {
+              _context14.next = 2;
+              break;
+            }
+            return _context14.abrupt("return", undefined);
+          case 2:
+            return _context14.abrupt("return", async.map(values, asSymbolInformation, token));
+          case 3:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14);
+    }));
+    return _asSymbolInformations.apply(this, arguments);
+  }
+  function asSymbolKind(item) {
+    if (item <= ls.SymbolKind.TypeParameter) {
+      // Symbol kind is one based in the protocol and zero based in
+      return item - 1;
+    }
+    return SymbolKind.Property;
+  }
+  function asSymbolTag(value) {
+    switch (value) {
+      case ls.SymbolTag.Deprecated:
+        return SymbolTag.Deprecated;
+      default:
+        return undefined;
+    }
+  }
+  function asSymbolTags(items) {
+    if (items === undefined || items === null) {
+      return undefined;
+    }
+    var result = [];
+    var _iterator5 = _createForOfIteratorHelper(items),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _item2 = _step5.value;
+        var converted = asSymbolTag(_item2);
+        if (converted !== undefined) {
+          result.push(converted);
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    return result.length === 0 ? undefined : result;
+  }
+  function asSymbolInformation(item) {
+    var _item$containerName, _item$containerName2;
+    var data = item.data;
+    var location = item.location;
+    var result = location.range === undefined || data !== undefined ? new WorkspaceSymbol(item.name, asSymbolKind(item.kind), (_item$containerName = item.containerName) !== null && _item$containerName !== void 0 ? _item$containerName : '', location.range === undefined ? _uriConverter(location.uri) : new Location(_uriConverter(item.location.uri), asRange(location.range)), data) : new SymbolInformation(item.name, asSymbolKind(item.kind), (_item$containerName2 = item.containerName) !== null && _item$containerName2 !== void 0 ? _item$containerName2 : '', new Location(_uriConverter(item.location.uri), asRange(location.range)));
+    fillTags(result, item);
+    return result;
+  }
+  function asDocumentSymbols(_x28, _x29) {
+    return _asDocumentSymbols.apply(this, arguments);
+  }
+  function _asDocumentSymbols() {
+    _asDocumentSymbols = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(values, token) {
+      return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            if (!(values === undefined || values === null)) {
+              _context15.next = 2;
+              break;
+            }
+            return _context15.abrupt("return", undefined);
+          case 2:
+            return _context15.abrupt("return", async.map(values, asDocumentSymbol, token));
+          case 3:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15);
+    }));
+    return _asDocumentSymbols.apply(this, arguments);
+  }
+  function asDocumentSymbol(value) {
+    var result = new DocumentSymbol(value.name, value.detail || '', asSymbolKind(value.kind), asRange(value.range), asRange(value.selectionRange));
+    fillTags(result, value);
+    if (value.children !== undefined && value.children.length > 0) {
+      var children = [];
+      var _iterator6 = _createForOfIteratorHelper(value.children),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var child = _step6.value;
+          children.push(asDocumentSymbol(child));
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      result.children = children;
+    }
+    return result;
+  }
+  function fillTags(result, value) {
+    result.tags = asSymbolTags(value.tags);
+    if (value.deprecated) {
+      if (!result.tags) {
+        result.tags = [SymbolTag.Deprecated];
+      } else {
+        if (!result.tags.includes(SymbolTag.Deprecated)) {
+          result.tags = result.tags.concat(SymbolTag.Deprecated);
+        }
+      }
+    }
+  }
+  function asCommand(item) {
+    var result = {
+      title: item.title,
+      command: item.command
+    };
+    if (item.tooltip) {
+      result.tooltip = item.tooltip;
+    }
+    if (item.arguments) {
+      result.arguments = item.arguments;
+    }
+    return result;
+  }
+  function asCommands(_x30, _x31) {
+    return _asCommands.apply(this, arguments);
+  }
+  function _asCommands() {
+    _asCommands = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(items, token) {
+      return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            if (items) {
+              _context16.next = 2;
+              break;
+            }
+            return _context16.abrupt("return", undefined);
+          case 2:
+            return _context16.abrupt("return", async.map(items, asCommand, token));
+          case 3:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16);
+    }));
+    return _asCommands.apply(this, arguments);
+  }
+  var kindMapping = new Map();
+  kindMapping.set(ls.CodeActionKind.Empty, CodeActionKind.Empty);
+  kindMapping.set(ls.CodeActionKind.QuickFix, CodeActionKind.QuickFix);
+  kindMapping.set(ls.CodeActionKind.Refactor, CodeActionKind.Refactor);
+  kindMapping.set(ls.CodeActionKind.RefactorExtract, CodeActionKind.RefactorExtract);
+  kindMapping.set(ls.CodeActionKind.RefactorInline, CodeActionKind.RefactorInline);
+  kindMapping.set(ls.CodeActionKind.RefactorRewrite, CodeActionKind.RefactorRewrite);
+  kindMapping.set(ls.CodeActionKind.Source, CodeActionKind.Source);
+  kindMapping.set(ls.CodeActionKind.SourceOrganizeImports, CodeActionKind.SourceOrganizeImports);
+  function asCodeActionKind(item) {
+    if (item === undefined || item === null) {
+      return undefined;
+    }
+    var result = kindMapping.get(item);
+    if (result) {
+      return result;
+    }
+    var parts = item.split('.');
+    result = CodeActionKind.Empty;
+    var _iterator7 = _createForOfIteratorHelper(parts),
+      _step7;
+    try {
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        var part = _step7.value;
+        result = result.append(part);
+      }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
+    }
+    return result;
+  }
+  function asCodeActionKinds(items) {
+    if (items === undefined || items === null) {
+      return undefined;
+    }
+    return items.map(function (kind) {
+      return asCodeActionKind(kind);
+    });
+  }
+  function asCodeActionDocumentations(items) {
+    if (items === undefined || items === null) {
+      return undefined;
+    }
+    return items.map(function (doc) {
+      return {
+        kind: asCodeActionKind(doc.kind),
+        command: asCommand(doc.command)
+      };
+    });
+  }
+  function asCodeAction(_x32, _x33) {
+    return _asCodeAction.apply(this, arguments);
+  }
+  function _asCodeAction() {
+    _asCodeAction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17(item, token) {
+      var result;
+      return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
+          case 0:
+            if (!(item === undefined || item === null)) {
+              _context17.next = 2;
+              break;
+            }
+            return _context17.abrupt("return", undefined);
+          case 2:
+            result = new ProtocolCodeAction(item.title, item.data);
+            if (item.kind !== undefined) {
+              result.kind = asCodeActionKind(item.kind);
+            }
+            if (item.diagnostics !== undefined) {
+              result.diagnostics = asDiagnosticsSync(item.diagnostics);
+            }
+            if (!(item.edit !== undefined)) {
+              _context17.next = 9;
+              break;
+            }
+            _context17.next = 8;
+            return asWorkspaceEdit(item.edit, token);
+          case 8:
+            result.edit = _context17.sent;
+          case 9:
+            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 _context17.abrupt("return", result);
+          case 13:
+          case "end":
+            return _context17.stop();
+        }
+      }, _callee17);
+    }));
+    return _asCodeAction.apply(this, arguments);
+  }
+  function asCodeActionResult(items, token) {
+    return async.mapAsync(items, /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(item) {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!ls.Command.is(item)) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", asCommand(item));
+            case 4:
+              return _context.abrupt("return", asCodeAction(item, token));
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x34) {
+        return _ref3.apply(this, arguments);
+      };
+    }(), token);
+  }
+  function asCodeLens(item) {
+    if (!item) {
+      return undefined;
+    }
+    var result = new ProtocolCodeLens(asRange(item.range));
+    if (item.command) {
+      result.command = asCommand(item.command);
+    }
+    if (item.data !== undefined && item.data !== null) {
+      result.data = item.data;
+    }
+    return result;
+  }
+  function asCodeLenses(_x35, _x36) {
+    return _asCodeLenses.apply(this, arguments);
+  }
+  function _asCodeLenses() {
+    _asCodeLenses = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18(items, token) {
+      return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
+          case 0:
+            if (items) {
+              _context18.next = 2;
+              break;
+            }
+            return _context18.abrupt("return", undefined);
+          case 2:
+            return _context18.abrupt("return", async.map(items, asCodeLens, token));
+          case 3:
+          case "end":
+            return _context18.stop();
+        }
+      }, _callee18);
+    }));
+    return _asCodeLenses.apply(this, arguments);
+  }
+  function asWorkspaceEdit(_x37, _x38) {
+    return _asWorkspaceEdit.apply(this, arguments);
+  }
+  function _asWorkspaceEdit() {
+    _asWorkspaceEdit = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19(item, token) {
+      var sharedMetadata, changeAnnotations, asMetadata, result, documentChanges, changes;
+      return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
+          case 0:
+            if (item) {
+              _context19.next = 2;
+              break;
+            }
+            return _context19.abrupt("return", undefined);
+          case 2:
+            sharedMetadata = new Map();
+            if (!(item.changeAnnotations !== undefined)) {
+              _context19.next = 7;
+              break;
+            }
+            changeAnnotations = item.changeAnnotations;
+            _context19.next = 7;
+            return async.forEach(Object.keys(changeAnnotations), function (key) {
+              var metaData = asWorkspaceEditEntryMetadata(changeAnnotations[key]);
+              sharedMetadata.set(key, metaData);
+            }, token);
+          case 7:
+            asMetadata = function asMetadata(annotation) {
+              if (annotation === undefined) {
+                return undefined;
+              } else {
+                return sharedMetadata.get(annotation);
+              }
+            };
+            result = new WorkspaceEdit();
+            if (!item.documentChanges) {
+              _context19.next = 15;
+              break;
+            }
+            documentChanges = item.documentChanges;
+            _context19.next = 13;
+            return async.forEach(documentChanges, function (change) {
+              if (ls.CreateFile.is(change)) {
+                result.createFile(_uriConverter(change.uri), change.options, asMetadata(change.annotationId));
+              } else if (ls.RenameFile.is(change)) {
+                result.renameFile(_uriConverter(change.oldUri), _uriConverter(change.newUri), change.options, asMetadata(change.annotationId));
+              } else if (ls.DeleteFile.is(change)) {
+                result.deleteFile(_uriConverter(change.uri), change.options, asMetadata(change.annotationId));
+              } else if (ls.TextDocumentEdit.is(change)) {
+                var uri = _uriConverter(change.textDocument.uri);
+                var _iterator8 = _createForOfIteratorHelper(change.edits),
+                  _step8;
+                try {
+                  for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                    var _edit = _step8.value;
+                    if (ls.AnnotatedTextEdit.is(_edit)) {
+                      result.replace(uri, asRange(_edit.range), _edit.newText, asMetadata(_edit.annotationId));
+                    } else {
+                      result.replace(uri, asRange(_edit.range), _edit.newText);
+                    }
+                  }
+                } catch (err) {
+                  _iterator8.e(err);
+                } finally {
+                  _iterator8.f();
+                }
+              } else {
+                throw new Error("Unknown workspace edit change received:\n".concat(JSON.stringify(change, undefined, 4)));
+              }
+            }, token);
+          case 13:
+            _context19.next = 19;
+            break;
+          case 15:
+            if (!item.changes) {
+              _context19.next = 19;
+              break;
+            }
+            changes = item.changes;
+            _context19.next = 19;
+            return async.forEach(Object.keys(changes), function (key) {
+              result.set(_uriConverter(key), asTextEditsSync(changes[key]));
+            }, token);
+          case 19:
+            return _context19.abrupt("return", result);
+          case 20:
+          case "end":
+            return _context19.stop();
+        }
+      }, _callee19);
+    }));
+    return _asWorkspaceEdit.apply(this, arguments);
+  }
+  function asWorkspaceEditEntryMetadata(annotation) {
+    if (annotation === undefined) {
+      return undefined;
+    }
+    return {
+      label: annotation.label,
+      needsConfirmation: !!annotation.needsConfirmation,
+      description: annotation.description
+    };
+  }
+  function asDocumentLink(item) {
+    var range = asRange(item.range);
+    var target = item.target ? asUri(item.target) : undefined;
+    // target must be optional in DocumentLink
+    var link = new ProtocolDocumentLink(range, target);
+    if (item.tooltip !== undefined) {
+      link.tooltip = item.tooltip;
+    }
+    if (item.data !== undefined && item.data !== null) {
+      link.data = item.data;
+    }
+    return link;
+  }
+  function asDocumentLinks(_x39, _x40) {
+    return _asDocumentLinks.apply(this, arguments);
+  }
+  function _asDocumentLinks() {
+    _asDocumentLinks = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20(items, token) {
+      return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+        while (1) switch (_context20.prev = _context20.next) {
+          case 0:
+            if (items) {
+              _context20.next = 2;
+              break;
+            }
+            return _context20.abrupt("return", undefined);
+          case 2:
+            return _context20.abrupt("return", async.map(items, asDocumentLink, token));
+          case 3:
+          case "end":
+            return _context20.stop();
+        }
+      }, _callee20);
+    }));
+    return _asDocumentLinks.apply(this, arguments);
+  }
+  function asColor(color) {
+    return new Color(color.red, color.green, color.blue, color.alpha);
+  }
+  function asColorInformation(ci) {
+    return new ColorInformation(asRange(ci.range), asColor(ci.color));
+  }
+  function asColorInformations(_x41, _x42) {
+    return _asColorInformations.apply(this, arguments);
+  }
+  function _asColorInformations() {
+    _asColorInformations = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(colorInformation, token) {
+      return _regeneratorRuntime().wrap(function _callee21$(_context21) {
+        while (1) switch (_context21.prev = _context21.next) {
+          case 0:
+            if (colorInformation) {
+              _context21.next = 2;
+              break;
+            }
+            return _context21.abrupt("return", undefined);
+          case 2:
+            return _context21.abrupt("return", async.map(colorInformation, asColorInformation, token));
+          case 3:
+          case "end":
+            return _context21.stop();
+        }
+      }, _callee21);
+    }));
+    return _asColorInformations.apply(this, arguments);
+  }
+  function asColorPresentation(cp) {
+    var presentation = new ColorPresentation(cp.label);
+    presentation.additionalTextEdits = asTextEditsSync(cp.additionalTextEdits);
+    if (cp.textEdit) {
+      presentation.textEdit = asTextEdit(cp.textEdit);
+    }
+    return presentation;
+  }
+  function asColorPresentations(_x43, _x44) {
+    return _asColorPresentations.apply(this, arguments);
+  }
+  function _asColorPresentations() {
+    _asColorPresentations = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(colorPresentations, token) {
+      return _regeneratorRuntime().wrap(function _callee22$(_context22) {
+        while (1) switch (_context22.prev = _context22.next) {
+          case 0:
+            if (colorPresentations) {
+              _context22.next = 2;
+              break;
+            }
+            return _context22.abrupt("return", undefined);
+          case 2:
+            return _context22.abrupt("return", async.map(colorPresentations, asColorPresentation, token));
+          case 3:
+          case "end":
+            return _context22.stop();
+        }
+      }, _callee22);
+    }));
+    return _asColorPresentations.apply(this, arguments);
+  }
+  function asFoldingRangeKind(kind) {
+    if (kind) {
+      switch (kind) {
+        case ls.FoldingRangeKind.Comment:
+          return FoldingRangeKind.Comment;
+        case ls.FoldingRangeKind.Imports:
+          return FoldingRangeKind.Imports;
+        case ls.FoldingRangeKind.Region:
+          return FoldingRangeKind.Region;
+      }
+    }
+    return undefined;
+  }
+  function asFoldingRange(r) {
+    return new FoldingRange(r.startLine, r.endLine, asFoldingRangeKind(r.kind));
+  }
+  function asFoldingRanges(_x45, _x46) {
+    return _asFoldingRanges.apply(this, arguments);
+  }
+  function _asFoldingRanges() {
+    _asFoldingRanges = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23(foldingRanges, token) {
+      return _regeneratorRuntime().wrap(function _callee23$(_context23) {
+        while (1) switch (_context23.prev = _context23.next) {
+          case 0:
+            if (foldingRanges) {
+              _context23.next = 2;
+              break;
+            }
+            return _context23.abrupt("return", undefined);
+          case 2:
+            return _context23.abrupt("return", async.map(foldingRanges, asFoldingRange, token));
+          case 3:
+          case "end":
+            return _context23.stop();
+        }
+      }, _callee23);
+    }));
+    return _asFoldingRanges.apply(this, arguments);
+  }
+  function asSelectionRange(selectionRange) {
+    return new SelectionRange(asRange(selectionRange.range), selectionRange.parent ? asSelectionRange(selectionRange.parent) : undefined);
+  }
+  function asSelectionRanges(_x47, _x48) {
+    return _asSelectionRanges.apply(this, arguments);
+  }
+  function _asSelectionRanges() {
+    _asSelectionRanges = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee24(selectionRanges, token) {
+      return _regeneratorRuntime().wrap(function _callee24$(_context24) {
+        while (1) switch (_context24.prev = _context24.next) {
+          case 0:
+            if (Array.isArray(selectionRanges)) {
+              _context24.next = 2;
+              break;
+            }
+            return _context24.abrupt("return", []);
+          case 2:
+            return _context24.abrupt("return", async.map(selectionRanges, asSelectionRange, token));
+          case 3:
+          case "end":
+            return _context24.stop();
+        }
+      }, _callee24);
+    }));
+    return _asSelectionRanges.apply(this, arguments);
+  }
+  function asInlineValue(inlineValue) {
+    if (ls.InlineValueText.is(inlineValue)) {
+      return new InlineValueText(asRange(inlineValue.range), inlineValue.text);
+    } else if (ls.InlineValueVariableLookup.is(inlineValue)) {
+      return new InlineValueVariableLookup(asRange(inlineValue.range), inlineValue.variableName, inlineValue.caseSensitiveLookup);
+    } else {
+      return new InlineValueEvaluatableExpression(asRange(inlineValue.range), inlineValue.expression);
+    }
+  }
+  function asInlineValues(_x49, _x50) {
+    return _asInlineValues.apply(this, arguments);
+  }
+  function _asInlineValues() {
+    _asInlineValues = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee25(inlineValues, token) {
+      return _regeneratorRuntime().wrap(function _callee25$(_context25) {
+        while (1) switch (_context25.prev = _context25.next) {
+          case 0:
+            if (Array.isArray(inlineValues)) {
+              _context25.next = 2;
+              break;
+            }
+            return _context25.abrupt("return", []);
+          case 2:
+            return _context25.abrupt("return", async.map(inlineValues, asInlineValue, token));
+          case 3:
+          case "end":
+            return _context25.stop();
+        }
+      }, _callee25);
+    }));
+    return _asInlineValues.apply(this, arguments);
+  }
+  function asInlayHint(_x51, _x52) {
+    return _asInlayHint.apply(this, arguments);
+  }
+  function _asInlayHint() {
+    _asInlayHint = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26(value, token) {
+      var label, result;
+      return _regeneratorRuntime().wrap(function _callee26$(_context26) {
+        while (1) switch (_context26.prev = _context26.next) {
+          case 0:
+            if (!(typeof value.label === 'string')) {
+              _context26.next = 4;
+              break;
+            }
+            _context26.t0 = value.label;
+            _context26.next = 7;
+            break;
+          case 4:
+            _context26.next = 6;
+            return async.map(value.label, asInlayHintLabelPart, token);
+          case 6:
+            _context26.t0 = _context26.sent;
+          case 7:
+            label = _context26.t0;
+            result = new ProtocolInlayHint(asPosition(value.position), label);
+            if (value.kind !== undefined) {
+              result.kind = value.kind;
+            }
+            if (!(value.textEdits !== undefined)) {
+              _context26.next = 14;
+              break;
+            }
+            _context26.next = 13;
+            return asTextEdits(value.textEdits, token);
+          case 13:
+            result.textEdits = _context26.sent;
+          case 14:
+            if (value.tooltip !== undefined) {
+              result.tooltip = asTooltip(value.tooltip);
+            }
+            if (value.paddingLeft !== undefined) {
+              result.paddingLeft = value.paddingLeft;
+            }
+            if (value.paddingRight !== undefined) {
+              result.paddingRight = value.paddingRight;
+            }
+            if (value.data !== undefined) {
+              result.data = value.data;
+            }
+            return _context26.abrupt("return", result);
+          case 19:
+          case "end":
+            return _context26.stop();
+        }
+      }, _callee26);
+    }));
+    return _asInlayHint.apply(this, arguments);
+  }
+  function asInlayHintLabelPart(part) {
+    var result = new InlayHintLabelPart(part.value);
+    if (part.location !== undefined) {
+      result.location = asLocation(part.location);
+    }
+    if (part.tooltip !== undefined) {
+      result.tooltip = asTooltip(part.tooltip);
+    }
+    if (part.command !== undefined) {
+      result.command = asCommand(part.command);
+    }
+    return result;
+  }
+  function asTooltip(value) {
+    if (typeof value === 'string') {
+      return value;
+    }
+    return asMarkdownString(value);
+  }
+  function asInlayHints(_x53, _x54) {
+    return _asInlayHints.apply(this, arguments);
+  } //----- call hierarchy
+  function _asInlayHints() {
+    _asInlayHints = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee27(values, token) {
+      return _regeneratorRuntime().wrap(function _callee27$(_context27) {
+        while (1) switch (_context27.prev = _context27.next) {
+          case 0:
+            if (Array.isArray(values)) {
+              _context27.next = 2;
+              break;
+            }
+            return _context27.abrupt("return", undefined);
+          case 2:
+            return _context27.abrupt("return", async.mapAsync(values, asInlayHint, token));
+          case 3:
+          case "end":
+            return _context27.stop();
+        }
+      }, _callee27);
+    }));
+    return _asInlayHints.apply(this, arguments);
+  }
+  function asCallHierarchyItem(item) {
+    if (item === null) {
+      return undefined;
+    }
+    var result = new ProtocolCallHierarchyItem(asSymbolKind(item.kind), item.name, item.detail || '', asUri(item.uri), asRange(item.range), asRange(item.selectionRange), item.data);
+    if (item.tags !== undefined) {
+      result.tags = asSymbolTags(item.tags);
+    }
+    return result;
+  }
+  function asCallHierarchyItems(_x55, _x56) {
+    return _asCallHierarchyItems.apply(this, arguments);
+  }
+  function _asCallHierarchyItems() {
+    _asCallHierarchyItems = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28(items, token) {
+      return _regeneratorRuntime().wrap(function _callee28$(_context28) {
+        while (1) switch (_context28.prev = _context28.next) {
+          case 0:
+            if (!(items === null)) {
+              _context28.next = 2;
+              break;
+            }
+            return _context28.abrupt("return", undefined);
+          case 2:
+            return _context28.abrupt("return", async.map(items, asCallHierarchyItem, token));
+          case 3:
+          case "end":
+            return _context28.stop();
+        }
+      }, _callee28);
+    }));
+    return _asCallHierarchyItems.apply(this, arguments);
+  }
+  function asCallHierarchyIncomingCall(_x57, _x58) {
+    return _asCallHierarchyIncomingCall.apply(this, arguments);
+  }
+  function _asCallHierarchyIncomingCall() {
+    _asCallHierarchyIncomingCall = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee29(item, token) {
+      return _regeneratorRuntime().wrap(function _callee29$(_context29) {
+        while (1) switch (_context29.prev = _context29.next) {
+          case 0:
+            _context29.t0 = CallHierarchyIncomingCall;
+            _context29.t1 = asCallHierarchyItem(item.from);
+            _context29.next = 4;
+            return asRanges(item.fromRanges, token);
+          case 4:
+            _context29.t2 = _context29.sent;
+            return _context29.abrupt("return", new _context29.t0(_context29.t1, _context29.t2));
+          case 6:
+          case "end":
+            return _context29.stop();
+        }
+      }, _callee29);
+    }));
+    return _asCallHierarchyIncomingCall.apply(this, arguments);
+  }
+  function asCallHierarchyIncomingCalls(_x59, _x60) {
+    return _asCallHierarchyIncomingCalls.apply(this, arguments);
+  }
+  function _asCallHierarchyIncomingCalls() {
+    _asCallHierarchyIncomingCalls = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee30(items, token) {
+      return _regeneratorRuntime().wrap(function _callee30$(_context30) {
+        while (1) switch (_context30.prev = _context30.next) {
+          case 0:
+            if (!(items === null)) {
+              _context30.next = 2;
+              break;
+            }
+            return _context30.abrupt("return", undefined);
+          case 2:
+            return _context30.abrupt("return", async.mapAsync(items, asCallHierarchyIncomingCall, token));
+          case 3:
+          case "end":
+            return _context30.stop();
+        }
+      }, _callee30);
+    }));
+    return _asCallHierarchyIncomingCalls.apply(this, arguments);
+  }
+  function asCallHierarchyOutgoingCall(_x61, _x62) {
+    return _asCallHierarchyOutgoingCall.apply(this, arguments);
+  }
+  function _asCallHierarchyOutgoingCall() {
+    _asCallHierarchyOutgoingCall = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee31(item, token) {
+      return _regeneratorRuntime().wrap(function _callee31$(_context31) {
+        while (1) switch (_context31.prev = _context31.next) {
+          case 0:
+            _context31.t0 = CallHierarchyOutgoingCall;
+            _context31.t1 = asCallHierarchyItem(item.to);
+            _context31.next = 4;
+            return asRanges(item.fromRanges, token);
+          case 4:
+            _context31.t2 = _context31.sent;
+            return _context31.abrupt("return", new _context31.t0(_context31.t1, _context31.t2));
+          case 6:
+          case "end":
+            return _context31.stop();
+        }
+      }, _callee31);
+    }));
+    return _asCallHierarchyOutgoingCall.apply(this, arguments);
+  }
+  function asCallHierarchyOutgoingCalls(_x63, _x64) {
+    return _asCallHierarchyOutgoingCalls.apply(this, arguments);
+  } //----- semantic tokens
+  function _asCallHierarchyOutgoingCalls() {
+    _asCallHierarchyOutgoingCalls = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee32(items, token) {
+      return _regeneratorRuntime().wrap(function _callee32$(_context32) {
+        while (1) switch (_context32.prev = _context32.next) {
+          case 0:
+            if (!(items === null)) {
+              _context32.next = 2;
+              break;
+            }
+            return _context32.abrupt("return", undefined);
+          case 2:
+            return _context32.abrupt("return", async.mapAsync(items, asCallHierarchyOutgoingCall, token));
+          case 3:
+          case "end":
+            return _context32.stop();
+        }
+      }, _callee32);
+    }));
+    return _asCallHierarchyOutgoingCalls.apply(this, arguments);
+  }
+  function asSemanticTokens(_x65, _x66) {
+    return _asSemanticTokens.apply(this, arguments);
+  }
+  function _asSemanticTokens() {
+    _asSemanticTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee33(value, _token) {
+      return _regeneratorRuntime().wrap(function _callee33$(_context33) {
+        while (1) switch (_context33.prev = _context33.next) {
+          case 0:
+            if (!(value === undefined || value === null)) {
+              _context33.next = 2;
+              break;
+            }
+            return _context33.abrupt("return", undefined);
+          case 2:
+            return _context33.abrupt("return", new SemanticTokens(new Uint32Array(value.data), value.resultId));
+          case 3:
+          case "end":
+            return _context33.stop();
+        }
+      }, _callee33);
+    }));
+    return _asSemanticTokens.apply(this, arguments);
+  }
+  function asSemanticTokensEdit(value) {
+    return new SemanticTokensEdit(value.start, value.deleteCount, value.data !== undefined ? new Uint32Array(value.data) : undefined);
+  }
+  function asSemanticTokensEdits(_x67, _x68) {
+    return _asSemanticTokensEdits.apply(this, arguments);
+  }
+  function _asSemanticTokensEdits() {
+    _asSemanticTokensEdits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee34(value, _token) {
+      return _regeneratorRuntime().wrap(function _callee34$(_context34) {
+        while (1) switch (_context34.prev = _context34.next) {
+          case 0:
+            if (!(value === undefined || value === null)) {
+              _context34.next = 2;
+              break;
+            }
+            return _context34.abrupt("return", undefined);
+          case 2:
+            return _context34.abrupt("return", new SemanticTokensEdits(value.edits.map(asSemanticTokensEdit), value.resultId));
+          case 3:
+          case "end":
+            return _context34.stop();
+        }
+      }, _callee34);
+    }));
+    return _asSemanticTokensEdits.apply(this, arguments);
+  }
+  function asSemanticTokensLegend(value) {
+    return value;
+  }
+  function asLinkedEditingRanges(_x69, _x70) {
+    return _asLinkedEditingRanges.apply(this, arguments);
+  }
+  function _asLinkedEditingRanges() {
+    _asLinkedEditingRanges = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee35(value, token) {
+      return _regeneratorRuntime().wrap(function _callee35$(_context35) {
+        while (1) switch (_context35.prev = _context35.next) {
+          case 0:
+            if (!(value === null || value === undefined)) {
+              _context35.next = 2;
+              break;
+            }
+            return _context35.abrupt("return", undefined);
+          case 2:
+            _context35.t0 = LinkedEditingRanges;
+            _context35.next = 5;
+            return asRanges(value.ranges, token);
+          case 5:
+            _context35.t1 = _context35.sent;
+            _context35.t2 = asRegularExpression(value.wordPattern);
+            return _context35.abrupt("return", new _context35.t0(_context35.t1, _context35.t2));
+          case 8:
+          case "end":
+            return _context35.stop();
+        }
+      }, _callee35);
+    }));
+    return _asLinkedEditingRanges.apply(this, arguments);
+  }
+  function asRegularExpression(value) {
+    if (value === null || value === undefined) {
+      return undefined;
+    }
+    return new RegExp(value);
+  }
+
+  //------ Type Hierarchy
+
+  function asTypeHierarchyItem(item) {
+    if (item === null) {
+      return undefined;
+    }
+    var result = new ProtocolTypeHierarchyItem(asSymbolKind(item.kind), item.name, item.detail || '', asUri(item.uri), asRange(item.range), asRange(item.selectionRange), item.data);
+    if (item.tags !== undefined) {
+      result.tags = asSymbolTags(item.tags);
+    }
+    return result;
+  }
+  function asTypeHierarchyItems(_x71, _x72) {
+    return _asTypeHierarchyItems.apply(this, arguments);
+  }
+  function _asTypeHierarchyItems() {
+    _asTypeHierarchyItems = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee36(items, token) {
+      return _regeneratorRuntime().wrap(function _callee36$(_context36) {
+        while (1) switch (_context36.prev = _context36.next) {
+          case 0:
+            if (!(items === null)) {
+              _context36.next = 2;
+              break;
+            }
+            return _context36.abrupt("return", undefined);
+          case 2:
+            return _context36.abrupt("return", async.map(items, asTypeHierarchyItem, token));
+          case 3:
+          case "end":
+            return _context36.stop();
+        }
+      }, _callee36);
+    }));
+    return _asTypeHierarchyItems.apply(this, arguments);
+  }
+  function asGlobPattern(pattern) {
+    if (Is.string(pattern)) {
+      return pattern;
+    }
+    if (ls.RelativePattern.is(pattern)) {
+      if (ls.URI.is(pattern.baseUri)) {
+        return new RelativePattern(asUri(pattern.baseUri), pattern.pattern);
+      } else if (ls.WorkspaceFolder.is(pattern.baseUri)) {
+        var workspaceFolder = workspace.getWorkspaceFolder(asUri(pattern.baseUri.uri));
+        return workspaceFolder !== undefined ? new RelativePattern(workspaceFolder, pattern.pattern) : undefined;
+      }
+    }
+    return undefined;
+  }
+  function asInlineCompletionResult(_x73, _x74) {
+    return _asInlineCompletionResult.apply(this, arguments);
+  }
+  function _asInlineCompletionResult() {
+    _asInlineCompletionResult = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee37(value, token) {
+      var list, converted;
+      return _regeneratorRuntime().wrap(function _callee37$(_context37) {
+        while (1) switch (_context37.prev = _context37.next) {
+          case 0:
+            if (value) {
+              _context37.next = 2;
+              break;
+            }
+            return _context37.abrupt("return", undefined);
+          case 2:
+            if (!Array.isArray(value)) {
+              _context37.next = 4;
+              break;
+            }
+            return _context37.abrupt("return", async.map(value, function (item) {
+              return asInlineCompletionItem(item);
+            }, token));
+          case 4:
+            list = value;
+            _context37.next = 7;
+            return async.map(list.items, function (item) {
+              return asInlineCompletionItem(item);
+            }, token);
+          case 7:
+            converted = _context37.sent;
+            return _context37.abrupt("return", new InlineCompletionList(converted));
+          case 9:
+          case "end":
+            return _context37.stop();
+        }
+      }, _callee37);
+    }));
+    return _asInlineCompletionResult.apply(this, arguments);
+  }
+  function asInlineCompletionItem(item) {
+    var insertText;
+    if (typeof item.insertText === 'string') {
+      insertText = item.insertText;
+    } else {
+      insertText = new SnippetString(item.insertText.value).value;
+    }
+    var command = undefined;
+    if (item.command) {
+      command = asCommand(item.command);
+    }
+    var inlineCompletionItem = new InlineCompletionItem(insertText, asRange(item.range), command);
+    if (item.filterText) {
+      inlineCompletionItem.filterText = item.filterText;
+    }
+    return inlineCompletionItem;
+  }
+
+  // new
+
+  function asTextDcouemnt(value) {
+    return {
+      uri: URI.parse(value.uri)
+    };
+  }
+  return {
+    asUri: asUri,
+    asDocumentSelector: asDocumentSelector,
+    asDiagnostics: asDiagnostics,
+    asDiagnostic: asDiagnostic,
+    asRange: asRange,
+    asRanges: asRanges,
+    asPosition: asPosition,
+    asDiagnosticSeverity: asDiagnosticSeverity,
+    asDiagnosticTag: asDiagnosticTag,
+    asHover: asHover,
+    asCompletionResult: asCompletionResult,
+    asCompletionItem: asCompletionItem,
+    asTextEdit: asTextEdit,
+    asTextEdits: asTextEdits,
+    asSignatureHelp: asSignatureHelp,
+    asSignatureInformations: asSignatureInformations,
+    asSignatureInformation: asSignatureInformation,
+    asParameterInformations: asParameterInformations,
+    asParameterInformation: asParameterInformation,
+    asDeclarationResult: asDeclarationResult,
+    asDefinitionResult: asDefinitionResult,
+    asLocation: asLocation,
+    asReferences: asReferences,
+    asDocumentHighlights: asDocumentHighlights,
+    asDocumentHighlight: asDocumentHighlight,
+    asDocumentHighlightKind: asDocumentHighlightKind,
+    asSymbolKind: asSymbolKind,
+    asSymbolTag: asSymbolTag,
+    asSymbolTags: asSymbolTags,
+    asSymbolInformations: asSymbolInformations,
+    asSymbolInformation: asSymbolInformation,
+    asDocumentSymbols: asDocumentSymbols,
+    asDocumentSymbol: asDocumentSymbol,
+    asCommand: asCommand,
+    asCommands: asCommands,
+    asCodeAction: asCodeAction,
+    asCodeActionKind: asCodeActionKind,
+    asCodeActionKinds: asCodeActionKinds,
+    asCodeActionDocumentations: asCodeActionDocumentations,
+    asCodeActionResult: asCodeActionResult,
+    asCodeLens: asCodeLens,
+    asCodeLenses: asCodeLenses,
+    asWorkspaceEdit: asWorkspaceEdit,
+    asDocumentLink: asDocumentLink,
+    asDocumentLinks: asDocumentLinks,
+    asFoldingRangeKind: asFoldingRangeKind,
+    asFoldingRange: asFoldingRange,
+    asFoldingRanges: asFoldingRanges,
+    asColor: asColor,
+    asColorInformation: asColorInformation,
+    asColorInformations: asColorInformations,
+    asColorPresentation: asColorPresentation,
+    asColorPresentations: asColorPresentations,
+    asSelectionRange: asSelectionRange,
+    asSelectionRanges: asSelectionRanges,
+    asInlineValue: asInlineValue,
+    asInlineValues: asInlineValues,
+    asInlayHint: asInlayHint,
+    asInlayHints: asInlayHints,
+    asSemanticTokensLegend: asSemanticTokensLegend,
+    asSemanticTokens: asSemanticTokens,
+    asSemanticTokensEdit: asSemanticTokensEdit,
+    asSemanticTokensEdits: asSemanticTokensEdits,
+    asCallHierarchyItem: asCallHierarchyItem,
+    asCallHierarchyItems: asCallHierarchyItems,
+    asCallHierarchyIncomingCall: asCallHierarchyIncomingCall,
+    asCallHierarchyIncomingCalls: asCallHierarchyIncomingCalls,
+    asCallHierarchyOutgoingCall: asCallHierarchyOutgoingCall,
+    asCallHierarchyOutgoingCalls: asCallHierarchyOutgoingCalls,
+    asLinkedEditingRanges: asLinkedEditingRanges,
+    asTypeHierarchyItem: asTypeHierarchyItem,
+    asTypeHierarchyItems: asTypeHierarchyItems,
+    asGlobPattern: asGlobPattern,
+    asInlineCompletionResult: asInlineCompletionResult,
+    asInlineCompletionItem: asInlineCompletionItem,
+    // new
+    asTextDcouemnt: asTextDcouemnt
+  };
+}