@difizen/libro-language-client 0.1.18

package/es/common/client.js

@@ -0,0 +1,2731 @@
+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 _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 _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 _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 _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; }
+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 _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 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 _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 _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-this-alias */
+/* eslint-disable promise/always-return */
+/* eslint-disable promise/catch-or-return */
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { RAL, ResponseError, MessageReader, MessageWriter, Trace, TraceFormat, Emitter, createProtocolConnection, RegistrationRequest, UnregistrationRequest, InitializeRequest, TextDocumentSyncKind, InitializedNotification, ShutdownRequest, ExitNotification, LogMessageNotification, MessageType, ShowMessageNotification, ShowMessageRequest, TelemetryEventNotification, DidChangeTextDocumentNotification, DidChangeWatchedFilesNotification, PublishDiagnosticsNotification, ApplyWorkspaceEditRequest, TextDocumentEdit, ResourceOperationKind, FailureHandlingKind, DiagnosticTag, LSPErrorCodes, ShowDocumentRequest, WorkDoneProgress, SemanticTokensRequest, SemanticTokensRangeRequest, SemanticTokensDeltaRequest, DidOpenTextDocumentNotification, PositionEncodingKind, NotebookDocumentSyncRegistrationType, ErrorCodes, CodeLensResolveRequest, CompletionResolveRequest, CodeActionResolveRequest, InlayHintResolveRequest, DocumentLinkResolveRequest, WorkspaceSymbolResolveRequest, CancellationToken as ProtocolCancellationToken } from '@difizen/vscode-languageserver-protocol';
+import { CallHierarchyFeature } from "./callHierarchy.js";
+import { CodeActionFeature } from "./codeAction.js";
+import * as c2p from "./codeConverter.js";
+import { CodeLensFeature } from "./codeLens.js";
+import { ColorProviderFeature } from "./colorProvider.js";
+import { CompletionItemFeature } from "./completion.js";
+import { ConfigurationFeature, SyncConfigurationFeature } from "./configuration.js";
+import { DeclarationFeature } from "./declaration.js";
+import { DefinitionFeature } from "./definition.js";
+import { DiagnosticFeature } from "./diagnostic.js";
+import { DocumentHighlightFeature } from "./documentHighlight.js";
+import { DocumentLinkFeature } from "./documentLink.js";
+import { DocumentSymbolFeature } from "./documentSymbol.js";
+import { ExecuteCommandFeature } from "./executeCommand.js";
+import { DynamicFeature, ensure, LSPCancellationError } from "./features.js";
+import { DidCreateFilesFeature, DidDeleteFilesFeature, DidRenameFilesFeature, WillCreateFilesFeature, WillDeleteFilesFeature, WillRenameFilesFeature } from "./fileOperations.js";
+import { FileSystemWatcherFeature } from "./fileSystemWatcher.js";
+import { FoldingRangeFeature } from "./foldingRange.js";
+import { DocumentFormattingFeature, DocumentOnTypeFormattingFeature, DocumentRangeFormattingFeature } from "./formatting.js";
+import { HoverFeature } from "./hover.js";
+import { ImplementationFeature } from "./implementation.js";
+import { InlayHintsFeature } from "./inlayHint.js";
+import { InlineCompletionItemFeature } from "./inlineCompletion.js";
+import { InlineValueFeature } from "./inlineValue.js";
+import { LinkedEditingFeature } from "./linkedEditingRange.js";
+import { NotebookDocumentSyncFeature } from "./notebook.js";
+import { ProgressFeature } from "./progress.js";
+import { ProgressPart } from "./progressPart.js";
+import * as p2c from "./protocolConverter.js";
+import { ReferencesFeature } from "./reference.js";
+import { RenameFeature } from "./rename.js";
+import { SelectionRangeFeature } from "./selectionRange.js";
+import { SemanticTokensFeature } from "./semanticTokens.js";
+import { SignatureHelpFeature } from "./signatureHelp.js";
+import { DidChangeTextDocumentFeature, DidCloseTextDocumentFeature, DidOpenTextDocumentFeature, DidSaveTextDocumentFeature, WillSaveFeature, WillSaveWaitUntilFeature } from "./textSynchronization.js";
+import { TypeDefinitionFeature } from "./typeDefinition.js";
+import { TypeHierarchyFeature } from "./typeHierarchy.js";
+import { Delayer, Semaphore } from "./utils/async.js";
+import * as Is from "./utils/is.js";
+import * as UUID from "./utils/uuid.js";
+import { Uri, version as VSCodeVersion, CancellationError, CancellationTokenSource, workspace as Workspace, window as Window, env as Env, languages as Languages } from "./vscodeAdaptor/vscodeAdaptor.js";
+import { WorkspaceFoldersFeature } from "./workspaceFolder.js";
+import { WorkspaceSymbolFeature } from "./workspaceSymbol.js";
+/**
+ * Controls when the output channel is revealed.
+ */
+export var RevealOutputChannelOn = /*#__PURE__*/function (RevealOutputChannelOn) {
+  RevealOutputChannelOn[RevealOutputChannelOn["Debug"] = 0] = "Debug";
+  RevealOutputChannelOn[RevealOutputChannelOn["Info"] = 1] = "Info";
+  RevealOutputChannelOn[RevealOutputChannelOn["Warn"] = 2] = "Warn";
+  RevealOutputChannelOn[RevealOutputChannelOn["Error"] = 3] = "Error";
+  RevealOutputChannelOn[RevealOutputChannelOn["Never"] = 4] = "Never";
+  return RevealOutputChannelOn;
+}({});
+
+/**
+ * A handler that is invoked when the initialization of the server failed.
+ */
+
+/**
+ * An action to be performed when the connection is producing errors.
+ */
+export var ErrorAction = /*#__PURE__*/function (ErrorAction) {
+  ErrorAction[ErrorAction["Continue"] = 1] = "Continue";
+  ErrorAction[ErrorAction["Shutdown"] = 2] = "Shutdown";
+  return ErrorAction;
+}({});
+/**
+ * An action to be performed when the connection to a server got closed.
+ */
+export var CloseAction = /*#__PURE__*/function (CloseAction) {
+  CloseAction[CloseAction["DoNotRestart"] = 1] = "DoNotRestart";
+  CloseAction[CloseAction["Restart"] = 2] = "Restart";
+  return CloseAction;
+}({});
+
+/**
+ * A plugable error handler that is invoked when the connection is either
+ * producing errors or got closed.
+ */
+
+/**
+ * Signals in which state the language client is in.
+ */
+export var State = /*#__PURE__*/function (State) {
+  State[State["Stopped"] = 1] = "Stopped";
+  State[State["Starting"] = 3] = "Starting";
+  State[State["Running"] = 2] = "Running";
+  return State;
+}({});
+
+/**
+ * An event signaling a state change.
+ */
+
+export var SuspendMode = /*#__PURE__*/function (SuspendMode) {
+  SuspendMode["off"] = "off";
+  SuspendMode["on"] = "on";
+  return SuspendMode;
+}({});
+
+// A general middleware is applied to both requests and notifications
+
+/**
+ * The Middleware lets extensions intercept the request and notifications send and received
+ * from the server
+ */
+
+// type TestOptions = {
+// 	$testMode?: boolean;
+// };
+var ResolvedClientOptions;
+(function (_ResolvedClientOptions) {
+  function sanitizeIsTrusted(isTrusted) {
+    if (isTrusted === undefined || isTrusted === null) {
+      return false;
+    }
+    if (typeof isTrusted === 'boolean' || _typeof(isTrusted) === 'object' && isTrusted !== null && Is.stringArray(isTrusted.enabledCommands)) {
+      return isTrusted;
+    }
+    return false;
+  }
+  _ResolvedClientOptions.sanitizeIsTrusted = sanitizeIsTrusted;
+})(ResolvedClientOptions || (ResolvedClientOptions = {}));
+var DefaultErrorHandler = /*#__PURE__*/function () {
+  function DefaultErrorHandler(client, maxRestartCount) {
+    _classCallCheck(this, DefaultErrorHandler);
+    this.client = client;
+    this.maxRestartCount = maxRestartCount;
+    this.restarts = [];
+  }
+  _createClass(DefaultErrorHandler, [{
+    key: "error",
+    value: function error(_error, _message, count) {
+      if (count && count <= 3) {
+        return {
+          action: ErrorAction.Continue
+        };
+      }
+      return {
+        action: ErrorAction.Shutdown
+      };
+    }
+  }, {
+    key: "closed",
+    value: function closed() {
+      this.restarts.push(Date.now());
+      if (this.restarts.length <= this.maxRestartCount) {
+        return {
+          action: CloseAction.Restart
+        };
+      } else {
+        var diff = this.restarts[this.restarts.length - 1] - this.restarts[0];
+        if (diff <= 3 * 60 * 1000) {
+          return {
+            action: CloseAction.DoNotRestart,
+            message: "The ".concat(this.client.name, " server crashed ").concat(this.maxRestartCount + 1, " times in the last 3 minutes. The server will not be restarted. See the output for more information.")
+          };
+        } else {
+          this.restarts.shift();
+          return {
+            action: CloseAction.Restart
+          };
+        }
+      }
+    }
+  }]);
+  return DefaultErrorHandler;
+}();
+var ClientState = /*#__PURE__*/function (ClientState) {
+  ClientState["Initial"] = "initial";
+  ClientState["Starting"] = "starting";
+  ClientState["StartFailed"] = "startFailed";
+  ClientState["Running"] = "running";
+  ClientState["Stopping"] = "stopping";
+  ClientState["Stopped"] = "stopped";
+  return ClientState;
+}(ClientState || {});
+export var MessageTransports;
+(function (_MessageTransports) {
+  function is(value) {
+    var candidate = value;
+    return candidate && MessageReader.is(value.reader) && MessageWriter.is(value.writer);
+  }
+  _MessageTransports.is = is;
+})(MessageTransports || (MessageTransports = {}));
+export var BaseLanguageClient = /*#__PURE__*/function () {
+  function BaseLanguageClient(id, name, clientOptions) {
+    var _clientOptions$docume,
+      _clientOptions$synchr,
+      _clientOptions$output,
+      _clientOptions$reveal,
+      _clientOptions$stdioE,
+      _clientOptions$errorH,
+      _clientOptions$connec,
+      _clientOptions$middle,
+      _clientOptions$diagno,
+      _clientOptions$notebo,
+      _this = this;
+    _classCallCheck(this, BaseLanguageClient);
+    // private _idleStart: number | undefined;
+    this._traceFormat = TraceFormat.Text;
+    this._diagnosticQueue = new Map();
+    this._diagnosticQueueState = {
+      state: 'idle'
+    };
+    this._features = [];
+    this._dynamicFeatures = new Map();
+    this.workspaceEditLock = new Semaphore(1);
+    this._id = id;
+    this._name = name;
+    clientOptions = clientOptions || {};
+    var markdown = {
+      isTrusted: false,
+      supportHtml: false
+    };
+    if (clientOptions.markdown !== undefined) {
+      markdown.isTrusted = ResolvedClientOptions.sanitizeIsTrusted(clientOptions.markdown.isTrusted);
+      markdown.supportHtml = clientOptions.markdown.supportHtml === true;
+    }
+
+    // const defaultInterval = (clientOptions as TestOptions).$testMode ? 50 : 60000;
+
+    this._clientOptions = {
+      documentSelector: (_clientOptions$docume = clientOptions.documentSelector) !== null && _clientOptions$docume !== void 0 ? _clientOptions$docume : [],
+      synchronize: (_clientOptions$synchr = clientOptions.synchronize) !== null && _clientOptions$synchr !== void 0 ? _clientOptions$synchr : {},
+      diagnosticCollectionName: clientOptions.diagnosticCollectionName,
+      outputChannelName: (_clientOptions$output = clientOptions.outputChannelName) !== null && _clientOptions$output !== void 0 ? _clientOptions$output : this._name,
+      revealOutputChannelOn: (_clientOptions$reveal = clientOptions.revealOutputChannelOn) !== null && _clientOptions$reveal !== void 0 ? _clientOptions$reveal : RevealOutputChannelOn.Error,
+      stdioEncoding: (_clientOptions$stdioE = clientOptions.stdioEncoding) !== null && _clientOptions$stdioE !== void 0 ? _clientOptions$stdioE : 'utf8',
+      initializationOptions: clientOptions.initializationOptions,
+      initializationFailedHandler: clientOptions.initializationFailedHandler,
+      progressOnInitialization: !!clientOptions.progressOnInitialization,
+      errorHandler: (_clientOptions$errorH = clientOptions.errorHandler) !== null && _clientOptions$errorH !== void 0 ? _clientOptions$errorH : this.createDefaultErrorHandler((_clientOptions$connec = clientOptions.connectionOptions) === null || _clientOptions$connec === void 0 ? void 0 : _clientOptions$connec.maxRestartCount),
+      middleware: (_clientOptions$middle = clientOptions.middleware) !== null && _clientOptions$middle !== void 0 ? _clientOptions$middle : {},
+      uriConverters: clientOptions.uriConverters,
+      workspaceFolder: clientOptions.workspaceFolder,
+      connectionOptions: clientOptions.connectionOptions,
+      markdown: markdown,
+      // suspend: {
+      // 	mode: clientOptions.suspend?.mode ?? SuspendMode.off,
+      // 	callback: clientOptions.suspend?.callback ?? (() => Promise.resolve(true)),
+      // 	interval: clientOptions.suspend?.interval ? Math.max(clientOptions.suspend.interval, defaultInterval) : defaultInterval
+      // },
+      diagnosticPullOptions: (_clientOptions$diagno = clientOptions.diagnosticPullOptions) !== null && _clientOptions$diagno !== void 0 ? _clientOptions$diagno : {
+        onChange: true,
+        onSave: false
+      },
+      notebookDocumentOptions: (_clientOptions$notebo = clientOptions.notebookDocumentOptions) !== null && _clientOptions$notebo !== void 0 ? _clientOptions$notebo : {}
+    };
+    this._clientOptions.synchronize = this._clientOptions.synchronize || {};
+    this._state = ClientState.Initial;
+    this._ignoredRegistrations = new Set();
+    this._listeners = [];
+    this._notificationHandlers = new Map();
+    this._pendingNotificationHandlers = new Map();
+    this._notificationDisposables = new Map();
+    this._requestHandlers = new Map();
+    this._pendingRequestHandlers = new Map();
+    this._requestDisposables = new Map();
+    this._progressHandlers = new Map();
+    this._pendingProgressHandlers = new Map();
+    this._progressDisposables = new Map();
+    this._connection = undefined;
+    // this._idleStart = undefined;
+    this._initializeResult = undefined;
+    if (clientOptions.outputChannel) {
+      this._outputChannel = clientOptions.outputChannel;
+      this._disposeOutputChannel = false;
+    } else {
+      this._outputChannel = undefined;
+      this._disposeOutputChannel = true;
+    }
+    this._traceOutputChannel = clientOptions.traceOutputChannel;
+    this._diagnostics = undefined;
+    this._pendingOpenNotifications = new Set();
+    this._pendingChangeSemaphore = new Semaphore(1);
+    this._pendingChangeDelayer = new Delayer(250);
+    this._fileEvents = [];
+    this._fileEventDelayer = new Delayer(250);
+    this._onStop = undefined;
+    this._telemetryEmitter = new Emitter();
+    this._stateChangeEmitter = new Emitter();
+    this._trace = Trace.Off;
+    this._tracer = {
+      log: function log(messageOrDataObject, data) {
+        if (Is.string(messageOrDataObject)) {
+          _this.logTrace(messageOrDataObject, data);
+        } else {
+          _this.logObjectTrace(messageOrDataObject);
+        }
+      }
+    };
+    this._c2p = c2p.createConverter(clientOptions.uriConverters ? clientOptions.uriConverters.code2Protocol : undefined);
+    this._p2c = p2c.createConverter(clientOptions.uriConverters ? clientOptions.uriConverters.protocol2Code : undefined, this._clientOptions.markdown.isTrusted, this._clientOptions.markdown.supportHtml);
+    this._syncedDocuments = new Map();
+    this.registerBuiltinFeatures();
+  }
+  _createClass(BaseLanguageClient, [{
+    key: "name",
+    get: function get() {
+      return this._name;
+    }
+  }, {
+    key: "middleware",
+    get: function get() {
+      var _this$_clientOptions$;
+      return (_this$_clientOptions$ = this._clientOptions.middleware) !== null && _this$_clientOptions$ !== void 0 ? _this$_clientOptions$ : Object.create(null);
+    }
+  }, {
+    key: "clientOptions",
+    get: function get() {
+      return this._clientOptions;
+    }
+  }, {
+    key: "protocol2CodeConverter",
+    get: function get() {
+      return this._p2c;
+    }
+  }, {
+    key: "code2ProtocolConverter",
+    get: function get() {
+      return this._c2p;
+    }
+  }, {
+    key: "onTelemetry",
+    get: function get() {
+      return this._telemetryEmitter.event;
+    }
+  }, {
+    key: "onDidChangeState",
+    get: function get() {
+      return this._stateChangeEmitter.event;
+    }
+  }, {
+    key: "outputChannel",
+    get: function get() {
+      if (!this._outputChannel) {
+        this._outputChannel = Window.createOutputChannel(this._clientOptions.outputChannelName ? this._clientOptions.outputChannelName : this._name);
+      }
+      return this._outputChannel;
+    }
+  }, {
+    key: "traceOutputChannel",
+    get: function get() {
+      if (this._traceOutputChannel) {
+        return this._traceOutputChannel;
+      }
+      return this.outputChannel;
+    }
+  }, {
+    key: "diagnostics",
+    get: function get() {
+      return this._diagnostics;
+    }
+  }, {
+    key: "state",
+    get: function get() {
+      return this.getPublicState();
+    }
+  }, {
+    key: "$state",
+    get: function get() {
+      return this._state;
+    },
+    set: function set(value) {
+      var oldState = this.getPublicState();
+      this._state = value;
+      var newState = this.getPublicState();
+      if (newState !== oldState) {
+        this._stateChangeEmitter.fire({
+          oldState: oldState,
+          newState: newState
+        });
+      }
+    }
+  }, {
+    key: "getPublicState",
+    value: function getPublicState() {
+      switch (this.$state) {
+        case ClientState.Starting:
+          return State.Starting;
+        case ClientState.Running:
+          return State.Running;
+        default:
+          return State.Stopped;
+      }
+    }
+  }, {
+    key: "initializeResult",
+    get: function get() {
+      return this._initializeResult;
+    }
+  }, {
+    key: "sendRequest",
+    value: function () {
+      var _sendRequest2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(type) {
+        var _this$_clientOptions$2;
+        var connection,
+          param,
+          token,
+          _len,
+          params,
+          _key,
+          _sendRequest,
+          _args = arguments;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!(this.$state === ClientState.StartFailed || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped)) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return", Promise.reject(new ResponseError(ErrorCodes.ConnectionInactive, "Client is not running")));
+            case 2:
+              _context.next = 4;
+              return this.$start();
+            case 4:
+              connection = _context.sent;
+              if (!(this._didChangeTextDocumentFeature.syncKind === TextDocumentSyncKind.Full)) {
+                _context.next = 8;
+                break;
+              }
+              _context.next = 8;
+              return this.sendPendingFullTextDocumentChanges(connection);
+            case 8:
+              param = undefined;
+              token = undefined; // Separate cancellation tokens from other parameters for a better client interface
+              for (_len = _args.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+                params[_key - 1] = _args[_key];
+              }
+              if (params.length === 1) {
+                // CancellationToken is an interface, so we need to check if the first param complies to it
+                if (ProtocolCancellationToken.is(params[0])) {
+                  token = params[0];
+                } else {
+                  param = params[0];
+                }
+              } else if (params.length === 2) {
+                param = params[0];
+                token = params[1];
+              }
+              if (!(token !== undefined && token.isCancellationRequested)) {
+                _context.next = 14;
+                break;
+              }
+              return _context.abrupt("return", Promise.reject(new ResponseError(LSPErrorCodes.RequestCancelled, 'Request got cancelled')));
+            case 14:
+              _sendRequest = (_this$_clientOptions$2 = this._clientOptions.middleware) === null || _this$_clientOptions$2 === void 0 ? void 0 : _this$_clientOptions$2.sendRequest;
+              if (!(_sendRequest !== undefined)) {
+                _context.next = 19;
+                break;
+              }
+              return _context.abrupt("return", _sendRequest(type, param, token, function (type, param, token) {
+                var params = [];
+
+                // Add the parameters if there are any
+                if (param !== undefined) {
+                  params.push(param);
+                }
+
+                // Add the cancellation token if there is one
+                if (token !== undefined) {
+                  params.push(token);
+                }
+                return connection.sendRequest.apply(connection, [type].concat(params));
+              }));
+            case 19:
+              return _context.abrupt("return", connection.sendRequest.apply(connection, [type].concat(params)));
+            case 20:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function sendRequest(_x) {
+        return _sendRequest2.apply(this, arguments);
+      }
+      return sendRequest;
+    }()
+  }, {
+    key: "onRequest",
+    value: function onRequest(type, handler) {
+      var _this2 = this;
+      var method = typeof type === 'string' ? type : type.method;
+      this._requestHandlers.set(method, handler);
+      var connection = this.activeConnection();
+      var disposable;
+      if (connection !== undefined) {
+        this._requestDisposables.set(method, connection.onRequest(type, handler));
+        disposable = {
+          dispose: function dispose() {
+            var disposable = _this2._requestDisposables.get(method);
+            if (disposable !== undefined) {
+              disposable.dispose();
+              _this2._requestDisposables.delete(method);
+            }
+          }
+        };
+      } else {
+        this._pendingRequestHandlers.set(method, handler);
+        disposable = {
+          dispose: function dispose() {
+            _this2._pendingRequestHandlers.delete(method);
+            var disposable = _this2._requestDisposables.get(method);
+            if (disposable !== undefined) {
+              disposable.dispose();
+              _this2._requestDisposables.delete(method);
+            }
+          }
+        };
+      }
+      return {
+        dispose: function dispose() {
+          _this2._requestHandlers.delete(method);
+          disposable.dispose();
+        }
+      };
+    }
+  }, {
+    key: "sendNotification",
+    value: function () {
+      var _sendNotification2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(type, params) {
+        var _this$_clientOptions$3;
+        var needsPendingFullTextDocumentSync, openNotification, connection, _sendNotification;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!(this.$state === ClientState.StartFailed || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped)) {
+                _context2.next = 2;
+                break;
+              }
+              return _context2.abrupt("return", Promise.reject(new ResponseError(ErrorCodes.ConnectionInactive, "Client is not running")));
+            case 2:
+              needsPendingFullTextDocumentSync = this._didChangeTextDocumentFeature.syncKind === TextDocumentSyncKind.Full;
+              if (needsPendingFullTextDocumentSync && typeof type !== 'string' && type.method === DidOpenTextDocumentNotification.method) {
+                openNotification = params === null || params === void 0 ? void 0 : params.textDocument.uri;
+                this._pendingOpenNotifications.add(openNotification);
+              }
+              // Ensure we have a connection before we force the document sync.
+              _context2.next = 6;
+              return this.$start();
+            case 6:
+              connection = _context2.sent;
+              if (!needsPendingFullTextDocumentSync) {
+                _context2.next = 10;
+                break;
+              }
+              _context2.next = 10;
+              return this.sendPendingFullTextDocumentChanges(connection);
+            case 10:
+              // We need to remove the pending open notification before we actually
+              // send the notification over the connection. Otherwise there could be
+              // a request coming in that although the open notification got already put
+              // onto the wire will ignore pending document changes.
+              //
+              // Since the code path of connection.sendNotification is actually sync
+              // until the message is handed of to the writer and the writer as a semaphore
+              // lock with a capacity of 1 no additional async scheduling can happen until
+              // the message is actually handed of.
+              if (openNotification !== undefined) {
+                this._pendingOpenNotifications.delete(openNotification);
+              }
+              _sendNotification = (_this$_clientOptions$3 = this._clientOptions.middleware) === null || _this$_clientOptions$3 === void 0 ? void 0 : _this$_clientOptions$3.sendNotification;
+              return _context2.abrupt("return", _sendNotification ? _sendNotification(type, connection.sendNotification.bind(connection), params) : connection.sendNotification(type, params));
+            case 13:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function sendNotification(_x2, _x3) {
+        return _sendNotification2.apply(this, arguments);
+      }
+      return sendNotification;
+    }()
+  }, {
+    key: "onNotification",
+    value: function onNotification(type, handler) {
+      var _this3 = this;
+      var method = typeof type === 'string' ? type : type.method;
+      this._notificationHandlers.set(method, handler);
+      var connection = this.activeConnection();
+      var disposable;
+      if (connection !== undefined) {
+        this._notificationDisposables.set(method, connection.onNotification(type, handler));
+        disposable = {
+          dispose: function dispose() {
+            var disposable = _this3._notificationDisposables.get(method);
+            if (disposable !== undefined) {
+              disposable.dispose();
+              _this3._notificationDisposables.delete(method);
+            }
+          }
+        };
+      } else {
+        this._pendingNotificationHandlers.set(method, handler);
+        disposable = {
+          dispose: function dispose() {
+            _this3._pendingNotificationHandlers.delete(method);
+            var disposable = _this3._notificationDisposables.get(method);
+            if (disposable !== undefined) {
+              disposable.dispose();
+              _this3._notificationDisposables.delete(method);
+            }
+          }
+        };
+      }
+      return {
+        dispose: function dispose() {
+          _this3._notificationHandlers.delete(method);
+          disposable.dispose();
+        }
+      };
+    }
+  }, {
+    key: "sendProgress",
+    value: function () {
+      var _sendProgress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(type, token, value) {
+        var connection;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!(this.$state === ClientState.StartFailed || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped)) {
+                _context3.next = 2;
+                break;
+              }
+              return _context3.abrupt("return", Promise.reject(new ResponseError(ErrorCodes.ConnectionInactive, "Client is not running")));
+            case 2:
+              _context3.prev = 2;
+              _context3.next = 5;
+              return this.$start();
+            case 5:
+              connection = _context3.sent;
+              return _context3.abrupt("return", connection.sendProgress(type, token, value));
+            case 9:
+              _context3.prev = 9;
+              _context3.t0 = _context3["catch"](2);
+              this.error("Sending progress for token ".concat(token, " failed."), _context3.t0);
+              throw _context3.t0;
+            case 13:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[2, 9]]);
+      }));
+      function sendProgress(_x4, _x5, _x6) {
+        return _sendProgress.apply(this, arguments);
+      }
+      return sendProgress;
+    }()
+  }, {
+    key: "onProgress",
+    value: function onProgress(type, token, handler) {
+      var _this$_clientOptions$4,
+        _this4 = this;
+      this._progressHandlers.set(token, {
+        type: type,
+        handler: handler
+      });
+      var connection = this.activeConnection();
+      var disposable;
+      var handleWorkDoneProgress = (_this$_clientOptions$4 = this._clientOptions.middleware) === null || _this$_clientOptions$4 === void 0 ? void 0 : _this$_clientOptions$4.handleWorkDoneProgress;
+      var realHandler = WorkDoneProgress.is(type) && handleWorkDoneProgress !== undefined ? function (params) {
+        handleWorkDoneProgress(token, params, function () {
+          return handler(params);
+        });
+      } : handler;
+      if (connection !== undefined) {
+        this._progressDisposables.set(token, connection.onProgress(type, token, realHandler));
+        disposable = {
+          dispose: function dispose() {
+            var disposable = _this4._progressDisposables.get(token);
+            if (disposable !== undefined) {
+              disposable.dispose();
+              _this4._progressDisposables.delete(token);
+            }
+          }
+        };
+      } else {
+        this._pendingProgressHandlers.set(token, {
+          type: type,
+          handler: handler
+        });
+        disposable = {
+          dispose: function dispose() {
+            _this4._pendingProgressHandlers.delete(token);
+            var disposable = _this4._progressDisposables.get(token);
+            if (disposable !== undefined) {
+              disposable.dispose();
+              _this4._progressDisposables.delete(token);
+            }
+          }
+        };
+      }
+      return {
+        dispose: function dispose() {
+          _this4._progressHandlers.delete(token);
+          disposable.dispose();
+        }
+      };
+    }
+  }, {
+    key: "createDefaultErrorHandler",
+    value: function createDefaultErrorHandler(maxRestartCount) {
+      if (maxRestartCount !== undefined && maxRestartCount < 0) {
+        throw new Error("Invalid maxRestartCount: ".concat(maxRestartCount));
+      }
+      return new DefaultErrorHandler(this, maxRestartCount !== null && maxRestartCount !== void 0 ? maxRestartCount : 4);
+    }
+  }, {
+    key: "setTrace",
+    value: function () {
+      var _setTrace = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(value) {
+        var connection;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              this._trace = value;
+              connection = this.activeConnection();
+              if (!(connection !== undefined)) {
+                _context4.next = 5;
+                break;
+              }
+              _context4.next = 5;
+              return connection.trace(this._trace, this._tracer, {
+                sendNotification: false,
+                traceFormat: this._traceFormat
+              });
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function setTrace(_x7) {
+        return _setTrace.apply(this, arguments);
+      }
+      return setTrace;
+    }()
+  }, {
+    key: "data2String",
+    value: function data2String(data) {
+      if (data instanceof ResponseError) {
+        var responseError = data;
+        return "  Message: ".concat(responseError.message, "\n  Code: ").concat(responseError.code, " ").concat(responseError.data ? '\n' + responseError.data.toString() : '');
+      }
+      if (data instanceof Error) {
+        if (Is.string(data.stack)) {
+          return data.stack;
+        }
+        return data.message;
+      }
+      if (Is.string(data)) {
+        return data;
+      }
+      return data.toString();
+    }
+  }, {
+    key: "debug",
+    value: function debug(message, data) {
+      var showNotification = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      this.logOutputMessage(MessageType.Debug, RevealOutputChannelOn.Debug, 'Debug', message, data, showNotification);
+    }
+  }, {
+    key: "info",
+    value: function info(message, data) {
+      var showNotification = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      this.logOutputMessage(MessageType.Info, RevealOutputChannelOn.Info, 'Info', message, data, showNotification);
+    }
+  }, {
+    key: "warn",
+    value: function warn(message, data) {
+      var showNotification = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      this.logOutputMessage(MessageType.Warning, RevealOutputChannelOn.Warn, 'Warn', message, data, showNotification);
+    }
+  }, {
+    key: "error",
+    value: function error(message, data) {
+      var showNotification = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      this.logOutputMessage(MessageType.Error, RevealOutputChannelOn.Error, 'Error', message, data, showNotification);
+    }
+  }, {
+    key: "logOutputMessage",
+    value: function logOutputMessage(type, reveal, name, message, data, showNotification) {
+      this.outputChannel.appendLine("[".concat(name.padEnd(5), " - ").concat(new Date().toLocaleTimeString(), "] ").concat(message));
+      if (data !== null && data !== undefined) {
+        this.outputChannel.appendLine(this.data2String(data));
+      }
+      if (showNotification === 'force' || showNotification && this._clientOptions.revealOutputChannelOn <= reveal) {
+        this.showNotificationMessage(type, message);
+      }
+    }
+  }, {
+    key: "showNotificationMessage",
+    value: function showNotificationMessage(type, message) {
+      var _message2,
+        _this5 = this;
+      message = (_message2 = message) !== null && _message2 !== void 0 ? _message2 : 'A request has failed. See the output for more information.';
+      var messageFunc = type === MessageType.Error ? Window.showErrorMessage : type === MessageType.Warning ? Window.showWarningMessage : Window.showInformationMessage;
+      void messageFunc(message, 'Go to output').then(function (selection) {
+        if (selection !== undefined) {
+          _this5.outputChannel.show(true);
+        }
+      });
+    }
+  }, {
+    key: "logTrace",
+    value: function logTrace(message, data) {
+      this.traceOutputChannel.appendLine("[Trace - ".concat(new Date().toLocaleTimeString(), "] ").concat(message));
+      if (data) {
+        this.traceOutputChannel.appendLine(this.data2String(data));
+      }
+    }
+  }, {
+    key: "logObjectTrace",
+    value: function logObjectTrace(data) {
+      if (data.isLSPMessage && data.type) {
+        this.traceOutputChannel.append("[LSP   - ".concat(new Date().toLocaleTimeString(), "] "));
+      } else {
+        this.traceOutputChannel.append("[Trace - ".concat(new Date().toLocaleTimeString(), "] "));
+      }
+      if (data) {
+        this.traceOutputChannel.appendLine("".concat(JSON.stringify(data)));
+      }
+    }
+  }, {
+    key: "needsStart",
+    value: function needsStart() {
+      return this.$state === ClientState.Initial || this.$state === ClientState.Stopping || this.$state === ClientState.Stopped;
+    }
+  }, {
+    key: "needsStop",
+    value: function needsStop() {
+      return this.$state === ClientState.Starting || this.$state === ClientState.Running;
+    }
+  }, {
+    key: "activeConnection",
+    value: function activeConnection() {
+      return this.$state === ClientState.Running && this._connection !== undefined ? this._connection : undefined;
+    }
+  }, {
+    key: "isRunning",
+    value: function isRunning() {
+      return this.$state === ClientState.Running;
+    }
+  }, {
+    key: "start",
+    value: function () {
+      var _start = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+        var _this6 = this;
+        var _this$createOnStartPr, _this$createOnStartPr2, promise, resolve, reject, _iterator, _step, _step$value, _method, _handler, _iterator2, _step2, _step2$value, _method2, _handler2, _iterator3, _step3, _step3$value, _token, data, connection;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              if (!(this._disposed === 'disposing' || this._disposed === 'disposed')) {
+                _context7.next = 2;
+                break;
+              }
+              throw new Error("Client got disposed and can't be restarted.");
+            case 2:
+              if (!(this.$state === ClientState.Stopping)) {
+                _context7.next = 4;
+                break;
+              }
+              throw new Error("Client is currently stopping. Can only restart a full stopped client");
+            case 4:
+              if (!(this._onStart !== undefined)) {
+                _context7.next = 6;
+                break;
+              }
+              return _context7.abrupt("return", this._onStart);
+            case 6:
+              _this$createOnStartPr = this.createOnStartPromise(), _this$createOnStartPr2 = _slicedToArray(_this$createOnStartPr, 3), promise = _this$createOnStartPr2[0], resolve = _this$createOnStartPr2[1], reject = _this$createOnStartPr2[2];
+              this._onStart = promise;
+
+              // If we restart then the diagnostics collection is reused.
+              if (this._diagnostics === undefined) {
+                this._diagnostics = this._clientOptions.diagnosticCollectionName ? Languages.createDiagnosticCollection(this._clientOptions.diagnosticCollectionName) : Languages.createDiagnosticCollection();
+              }
+
+              // When we start make all buffer handlers pending so that they
+              // get added.
+              _iterator = _createForOfIteratorHelper(this._notificationHandlers);
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  _step$value = _slicedToArray(_step.value, 2), _method = _step$value[0], _handler = _step$value[1];
+                  if (!this._pendingNotificationHandlers.has(_method)) {
+                    this._pendingNotificationHandlers.set(_method, _handler);
+                  }
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              _iterator2 = _createForOfIteratorHelper(this._requestHandlers);
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  _step2$value = _slicedToArray(_step2.value, 2), _method2 = _step2$value[0], _handler2 = _step2$value[1];
+                  if (!this._pendingRequestHandlers.has(_method2)) {
+                    this._pendingRequestHandlers.set(_method2, _handler2);
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+              _iterator3 = _createForOfIteratorHelper(this._progressHandlers);
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  _step3$value = _slicedToArray(_step3.value, 2), _token = _step3$value[0], data = _step3$value[1];
+                  if (!this._pendingProgressHandlers.has(_token)) {
+                    this._pendingProgressHandlers.set(_token, data);
+                  }
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+              this.$state = ClientState.Starting;
+              _context7.prev = 16;
+              _context7.next = 19;
+              return this.createConnection();
+            case 19:
+              connection = _context7.sent;
+              connection.onNotification(LogMessageNotification.type, function (message) {
+                switch (message.type) {
+                  case MessageType.Error:
+                    _this6.error(message.message, undefined, false);
+                    break;
+                  case MessageType.Warning:
+                    _this6.warn(message.message, undefined, false);
+                    break;
+                  case MessageType.Info:
+                    _this6.info(message.message, undefined, false);
+                    break;
+                  case MessageType.Debug:
+                    _this6.debug(message.message, undefined, false);
+                    break;
+                  default:
+                    _this6.outputChannel.appendLine(message.message);
+                }
+              });
+              connection.onNotification(ShowMessageNotification.type, function (message) {
+                switch (message.type) {
+                  case MessageType.Error:
+                    void Window.showErrorMessage(message.message);
+                    break;
+                  case MessageType.Warning:
+                    void Window.showWarningMessage(message.message);
+                    break;
+                  case MessageType.Info:
+                    void Window.showInformationMessage(message.message);
+                    break;
+                  default:
+                    void Window.showInformationMessage(message.message);
+                }
+              });
+              connection.onRequest(ShowMessageRequest.type, function (params) {
+                var messageFunc;
+                switch (params.type) {
+                  case MessageType.Error:
+                    messageFunc = Window.showErrorMessage;
+                    break;
+                  case MessageType.Warning:
+                    messageFunc = Window.showWarningMessage;
+                    break;
+                  case MessageType.Info:
+                    messageFunc = Window.showInformationMessage;
+                    break;
+                  default:
+                    messageFunc = Window.showInformationMessage;
+                }
+                var actions = params.actions || [];
+                return messageFunc.apply(void 0, [params.message].concat(_toConsumableArray(actions)));
+              });
+              connection.onNotification(TelemetryEventNotification.type, function (data) {
+                _this6._telemetryEmitter.fire(data);
+              });
+              connection.onRequest(ShowDocumentRequest.type, /*#__PURE__*/function () {
+                var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(params) {
+                  var _this6$_clientOptions;
+                  var showDocument, middleware;
+                  return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+                    while (1) switch (_context6.prev = _context6.next) {
+                      case 0:
+                        showDocument = /*#__PURE__*/function () {
+                          var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(params) {
+                            var uri, success, options;
+                            return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+                              while (1) switch (_context5.prev = _context5.next) {
+                                case 0:
+                                  uri = _this6.protocol2CodeConverter.asUri(params.uri);
+                                  _context5.prev = 1;
+                                  if (!(params.external === true)) {
+                                    _context5.next = 9;
+                                    break;
+                                  }
+                                  _context5.next = 5;
+                                  return Env.openExternal(uri);
+                                case 5:
+                                  success = _context5.sent;
+                                  return _context5.abrupt("return", {
+                                    success: success
+                                  });
+                                case 9:
+                                  options = {};
+                                  if (params.selection !== undefined) {
+                                    options.selection = _this6.protocol2CodeConverter.asRange(params.selection);
+                                  }
+                                  if (params.takeFocus === undefined || params.takeFocus === false) {
+                                    options.preserveFocus = true;
+                                  } else if (params.takeFocus === true) {
+                                    options.preserveFocus = false;
+                                  }
+                                  _context5.next = 14;
+                                  return Window.showTextDocument(uri, options);
+                                case 14:
+                                  return _context5.abrupt("return", {
+                                    success: true
+                                  });
+                                case 15:
+                                  _context5.next = 20;
+                                  break;
+                                case 17:
+                                  _context5.prev = 17;
+                                  _context5.t0 = _context5["catch"](1);
+                                  return _context5.abrupt("return", {
+                                    success: false
+                                  });
+                                case 20:
+                                case "end":
+                                  return _context5.stop();
+                              }
+                            }, _callee5, null, [[1, 17]]);
+                          }));
+                          return function showDocument(_x9) {
+                            return _ref2.apply(this, arguments);
+                          };
+                        }();
+                        middleware = (_this6$_clientOptions = _this6._clientOptions.middleware.window) === null || _this6$_clientOptions === void 0 ? void 0 : _this6$_clientOptions.showDocument;
+                        if (!(middleware !== undefined)) {
+                          _context6.next = 6;
+                          break;
+                        }
+                        return _context6.abrupt("return", middleware(params, showDocument));
+                      case 6:
+                        return _context6.abrupt("return", showDocument(params));
+                      case 7:
+                      case "end":
+                        return _context6.stop();
+                    }
+                  }, _callee6);
+                }));
+                return function (_x8) {
+                  return _ref.apply(this, arguments);
+                };
+              }());
+              connection.listen();
+              _context7.next = 28;
+              return this.initialize(connection);
+            case 28:
+              resolve();
+              _context7.next = 36;
+              break;
+            case 31:
+              _context7.prev = 31;
+              _context7.t0 = _context7["catch"](16);
+              this.$state = ClientState.StartFailed;
+              this.error("".concat(this._name, " client: couldn't create connection to server."), _context7.t0, 'force');
+              reject(_context7.t0);
+            case 36:
+              return _context7.abrupt("return", this._onStart);
+            case 37:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[16, 31]]);
+      }));
+      function start() {
+        return _start.apply(this, arguments);
+      }
+      return start;
+    }()
+  }, {
+    key: "createOnStartPromise",
+    value: function createOnStartPromise() {
+      var resolve;
+      var reject;
+      var promise = new Promise(function (_resolve, _reject) {
+        resolve = _resolve;
+        reject = _reject;
+      });
+      return [promise, resolve, reject];
+    }
+  }, {
+    key: "initialize",
+    value: function () {
+      var _initialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(connection) {
+        var initOption, _ref3, _ref4, rootPath, workspaceFolders, initParams, _token2, part, result;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              this.refreshTrace(connection, false);
+              initOption = this._clientOptions.initializationOptions; // If the client is locked to a workspace folder use it. In this case the workspace folder
+              // feature is not registered and we need to initialize the value here.
+              _ref3 = this._clientOptions.workspaceFolder !== undefined ? [this._clientOptions.workspaceFolder.uri.fsPath, [{
+                uri: this._c2p.asUri(this._clientOptions.workspaceFolder.uri),
+                name: this._clientOptions.workspaceFolder.name
+              }]] : [this._clientGetRootPath(), null], _ref4 = _slicedToArray(_ref3, 2), rootPath = _ref4[0], workspaceFolders = _ref4[1];
+              initParams = {
+                processId: null,
+                clientInfo: {
+                  name: Env.appName,
+                  version: VSCodeVersion
+                },
+                locale: this.getLocale(),
+                rootPath: rootPath ? rootPath : null,
+                rootUri: rootPath ? this._c2p.asUri(Uri.file(rootPath)) : null,
+                capabilities: this.computeClientCapabilities(),
+                initializationOptions: Is.func(initOption) ? initOption() : initOption,
+                trace: Trace.toString(this._trace),
+                workspaceFolders: workspaceFolders
+              };
+              this.fillInitializeParams(initParams);
+              if (!this._clientOptions.progressOnInitialization) {
+                _context8.next = 23;
+                break;
+              }
+              _token2 = UUID.generateUuid();
+              part = new ProgressPart(connection, _token2);
+              initParams.workDoneToken = _token2;
+              _context8.prev = 9;
+              _context8.next = 12;
+              return this.doInitialize(connection, initParams);
+            case 12:
+              result = _context8.sent;
+              part.done();
+              return _context8.abrupt("return", result);
+            case 17:
+              _context8.prev = 17;
+              _context8.t0 = _context8["catch"](9);
+              part.cancel();
+              throw _context8.t0;
+            case 21:
+              _context8.next = 24;
+              break;
+            case 23:
+              return _context8.abrupt("return", this.doInitialize(connection, initParams));
+            case 24:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[9, 17]]);
+      }));
+      function initialize(_x10) {
+        return _initialize.apply(this, arguments);
+      }
+      return initialize;
+    }()
+  }, {
+    key: "doInitialize",
+    value: function () {
+      var _doInitialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(connection, initParams) {
+        var _this7 = this;
+        var result, textDocumentSyncOptions, _iterator4, _step4, _step4$value, _method3, _handler3, _iterator5, _step5, _step5$value, _method4, _handler4, _iterator6, _step6, _step6$value, _token3, data;
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.prev = 0;
+              _context9.next = 3;
+              return connection.initialize(initParams);
+            case 3:
+              result = _context9.sent;
+              if (!(result.capabilities.positionEncoding !== undefined && result.capabilities.positionEncoding !== PositionEncodingKind.UTF16)) {
+                _context9.next = 6;
+                break;
+              }
+              throw new Error("Unsupported position encoding (".concat(result.capabilities.positionEncoding, ") received from server ").concat(this.name));
+            case 6:
+              this._initializeResult = result;
+              this.$state = ClientState.Running;
+              textDocumentSyncOptions = undefined;
+              if (Is.number(result.capabilities.textDocumentSync)) {
+                if (result.capabilities.textDocumentSync === TextDocumentSyncKind.None) {
+                  textDocumentSyncOptions = {
+                    openClose: false,
+                    change: TextDocumentSyncKind.None,
+                    save: undefined
+                  };
+                } else {
+                  textDocumentSyncOptions = {
+                    openClose: true,
+                    change: result.capabilities.textDocumentSync,
+                    save: {
+                      includeText: false
+                    }
+                  };
+                }
+              } else if (result.capabilities.textDocumentSync !== undefined && result.capabilities.textDocumentSync !== null) {
+                textDocumentSyncOptions = result.capabilities.textDocumentSync;
+              }
+              this._capabilities = Object.assign({}, result.capabilities, {
+                resolvedTextDocumentSync: textDocumentSyncOptions
+              });
+              connection.onNotification(PublishDiagnosticsNotification.type, function (params) {
+                return _this7.handleDiagnostics(params);
+              });
+              connection.onRequest(RegistrationRequest.type, function (params) {
+                return _this7.handleRegistrationRequest(params);
+              });
+              // See https://github.com/Microsoft/vscode-languageserver-node/issues/199
+              connection.onRequest('client/registerFeature', function (params) {
+                return _this7.handleRegistrationRequest(params);
+              });
+              connection.onRequest(UnregistrationRequest.type, function (params) {
+                return _this7.handleUnregistrationRequest(params);
+              });
+              // See https://github.com/Microsoft/vscode-languageserver-node/issues/199
+              connection.onRequest('client/unregisterFeature', function (params) {
+                return _this7.handleUnregistrationRequest(params);
+              });
+              connection.onRequest(ApplyWorkspaceEditRequest.type, function (params) {
+                return _this7.handleApplyWorkspaceEdit(params);
+              });
+
+              // Add pending notification, request and progress handlers.
+              _iterator4 = _createForOfIteratorHelper(this._pendingNotificationHandlers);
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  _step4$value = _slicedToArray(_step4.value, 2), _method3 = _step4$value[0], _handler3 = _step4$value[1];
+                  this._notificationDisposables.set(_method3, connection.onNotification(_method3, _handler3));
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+              this._pendingNotificationHandlers.clear();
+              _iterator5 = _createForOfIteratorHelper(this._pendingRequestHandlers);
+              try {
+                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                  _step5$value = _slicedToArray(_step5.value, 2), _method4 = _step5$value[0], _handler4 = _step5$value[1];
+                  this._requestDisposables.set(_method4, connection.onRequest(_method4, _handler4));
+                }
+              } catch (err) {
+                _iterator5.e(err);
+              } finally {
+                _iterator5.f();
+              }
+              this._pendingRequestHandlers.clear();
+              _iterator6 = _createForOfIteratorHelper(this._pendingProgressHandlers);
+              try {
+                for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                  _step6$value = _slicedToArray(_step6.value, 2), _token3 = _step6$value[0], data = _step6$value[1];
+                  this._progressDisposables.set(_token3, connection.onProgress(data.type, _token3, data.handler));
+                }
+              } catch (err) {
+                _iterator6.e(err);
+              } finally {
+                _iterator6.f();
+              }
+              this._pendingProgressHandlers.clear();
+
+              // if (this._clientOptions.suspend.mode !== SuspendMode.off) {
+              // 	this._idleInterval =  RAL().timer.setInterval(() => this.checkSuspend(), this._clientOptions.suspend.interval);
+              // }
+              _context9.next = 28;
+              return connection.sendNotification(InitializedNotification.type, {});
+            case 28:
+              this.hookFileEvents(connection);
+              this.hookConfigurationChanged(connection);
+              this.initializeFeatures(connection);
+              return _context9.abrupt("return", result);
+            case 34:
+              _context9.prev = 34;
+              _context9.t0 = _context9["catch"](0);
+              if (this._clientOptions.initializationFailedHandler) {
+                if (this._clientOptions.initializationFailedHandler(_context9.t0)) {
+                  void this.initialize(connection);
+                } else {
+                  void this.stop();
+                }
+              } else if (_context9.t0 instanceof ResponseError && _context9.t0.data && _context9.t0.data.retry) {
+                void Window.showErrorMessage(_context9.t0.message, {
+                  title: 'Retry',
+                  id: 'retry'
+                }).then(function (item) {
+                  if (item && item.id === 'retry') {
+                    void _this7.initialize(connection);
+                  } else {
+                    void _this7.stop();
+                  }
+                });
+              } else {
+                if (_context9.t0 && _context9.t0.message) {
+                  void Window.showErrorMessage(_context9.t0.message);
+                }
+                this.error('Server initialization failed.', _context9.t0);
+                void this.stop();
+              }
+              throw _context9.t0;
+            case 38:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this, [[0, 34]]);
+      }));
+      function doInitialize(_x11, _x12) {
+        return _doInitialize.apply(this, arguments);
+      }
+      return doInitialize;
+    }()
+  }, {
+    key: "_clientGetRootPath",
+    value: function _clientGetRootPath() {
+      var folders = Workspace.workspaceFolders;
+      if (!folders || folders.length === 0) {
+        return undefined;
+      }
+      var folder = folders[0];
+      if (folder.uri.scheme === 'file') {
+        return folder.uri.fsPath;
+      }
+      return undefined;
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      var timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2000;
+      // Wait 2 seconds on stop
+      return this.shutdown('stop', timeout);
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      var timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2000;
+      try {
+        this._disposed = 'disposing';
+        return this.stop(timeout);
+      } finally {
+        this._disposed = 'disposed';
+      }
+    }
+  }, {
+    key: "shutdown",
+    value: function () {
+      var _shutdown = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(mode, timeout) {
+        var _this8 = this;
+        var connection, tp, shutdown;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              if (!(this.$state === ClientState.Stopped || this.$state === ClientState.Initial)) {
+                _context11.next = 2;
+                break;
+              }
+              return _context11.abrupt("return");
+            case 2:
+              if (!(this.$state === ClientState.Stopping)) {
+                _context11.next = 8;
+                break;
+              }
+              if (!(this._onStop !== undefined)) {
+                _context11.next = 7;
+                break;
+              }
+              return _context11.abrupt("return", this._onStop);
+            case 7:
+              throw new Error("Client ".concat(this.name, " is stopping but no stop promise available."));
+            case 8:
+              connection = this.activeConnection(); // We can't stop a client that is not running (e.g. has no connection). Especially not
+              // on that us starting since it can't be correctly synchronized.
+              if (!(connection === undefined || this.$state !== ClientState.Running)) {
+                _context11.next = 11;
+                break;
+              }
+              throw new Error("Client ".concat(this.name, " is not running and can't be stopped. It's current state is: ").concat(this.$state));
+            case 11:
+              this._initializeResult = undefined;
+              this.$state = ClientState.Stopping;
+              this.cleanUp(mode);
+
+              // eslint-disable-next-line promise/param-names
+              tp = new Promise(function (c) {
+                RAL().timer.setTimeout(c, timeout);
+              });
+              shutdown = function () {
+                var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(connection) {
+                  return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+                    while (1) switch (_context10.prev = _context10.next) {
+                      case 0:
+                        _context10.next = 2;
+                        return connection.shutdown();
+                      case 2:
+                        _context10.next = 4;
+                        return connection.exit();
+                      case 4:
+                        return _context10.abrupt("return", connection);
+                      case 5:
+                      case "end":
+                        return _context10.stop();
+                    }
+                  }, _callee10);
+                }));
+                return function (_x15) {
+                  return _ref5.apply(this, arguments);
+                };
+              }()(connection);
+              return _context11.abrupt("return", this._onStop = Promise.race([tp, shutdown]).then(function (connection) {
+                // The connection won the race with the timeout.
+                if (connection !== undefined) {
+                  connection.end();
+                  connection.dispose();
+                } else {
+                  _this8.error("Stopping server timed out", undefined, false);
+                  throw new Error("Stopping the server timed out");
+                }
+              }, function (error) {
+                _this8.error("Stopping server failed", error, false);
+                throw error;
+              }).finally(function () {
+                _this8.$state = ClientState.Stopped;
+                mode === 'stop' && _this8.cleanUpChannel();
+                _this8._onStart = undefined;
+                _this8._onStop = undefined;
+                _this8._connection = undefined;
+                _this8._ignoredRegistrations.clear();
+              }));
+            case 17:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function shutdown(_x13, _x14) {
+        return _shutdown.apply(this, arguments);
+      }
+      return shutdown;
+    }()
+  }, {
+    key: "cleanUp",
+    value: function cleanUp(mode) {
+      // purge outstanding file events.
+      this._fileEvents = [];
+      this._fileEventDelayer.cancel();
+      var disposables = this._listeners.splice(0, this._listeners.length);
+      var _iterator7 = _createForOfIteratorHelper(disposables),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var disposable = _step7.value;
+          disposable.dispose();
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      if (this._syncedDocuments) {
+        this._syncedDocuments.clear();
+      }
+      // Clear features in reverse order;
+      var _iterator8 = _createForOfIteratorHelper(Array.from(this._features.entries()).map(function (entry) {
+          return entry[1];
+        }).reverse()),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var feature = _step8.value;
+          feature.clear();
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+      if (mode === 'stop' && this._diagnostics !== undefined) {
+        this._diagnostics.dispose();
+        this._diagnostics = undefined;
+      }
+      if (this._idleInterval !== undefined) {
+        this._idleInterval.dispose();
+        this._idleInterval = undefined;
+      }
+      // this._idleStart = undefined;
+    }
+  }, {
+    key: "cleanUpChannel",
+    value: function cleanUpChannel() {
+      if (this._outputChannel !== undefined && this._disposeOutputChannel) {
+        this._outputChannel.dispose();
+        this._outputChannel = undefined;
+      }
+    }
+  }, {
+    key: "notifyFileEvent",
+    value: function notifyFileEvent(event) {
+      var _this$clientOptions$m;
+      var client = this;
+      function didChangeWatchedFile(_x16) {
+        return _didChangeWatchedFile.apply(this, arguments);
+      }
+      function _didChangeWatchedFile() {
+        _didChangeWatchedFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(event) {
+          return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+            while (1) switch (_context13.prev = _context13.next) {
+              case 0:
+                client._fileEvents.push(event);
+                return _context13.abrupt("return", client._fileEventDelayer.trigger( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+                  return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                    while (1) switch (_context12.prev = _context12.next) {
+                      case 0:
+                        _context12.next = 2;
+                        return client.sendNotification(DidChangeWatchedFilesNotification.type, {
+                          changes: client._fileEvents
+                        });
+                      case 2:
+                        client._fileEvents = [];
+                      case 3:
+                      case "end":
+                        return _context12.stop();
+                    }
+                  }, _callee12);
+                }))));
+              case 2:
+              case "end":
+                return _context13.stop();
+            }
+          }, _callee13);
+        }));
+        return _didChangeWatchedFile.apply(this, arguments);
+      }
+      var workSpaceMiddleware = (_this$clientOptions$m = this.clientOptions.middleware) === null || _this$clientOptions$m === void 0 ? void 0 : _this$clientOptions$m.workspace;
+      (workSpaceMiddleware !== null && workSpaceMiddleware !== void 0 && workSpaceMiddleware.didChangeWatchedFile ? workSpaceMiddleware.didChangeWatchedFile(event, didChangeWatchedFile) : didChangeWatchedFile(event)).catch(function (error) {
+        client.error("Notify file events failed.", error);
+      });
+    }
+  }, {
+    key: "sendPendingFullTextDocumentChanges",
+    value: function () {
+      var _sendPendingFullTextDocumentChanges = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(connection) {
+        var _this9 = this;
+        return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              return _context15.abrupt("return", this._pendingChangeSemaphore.lock( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
+                var changes, _iterator9, _step9, document, _params;
+                return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+                  while (1) switch (_context14.prev = _context14.next) {
+                    case 0:
+                      _context14.prev = 0;
+                      changes = _this9._didChangeTextDocumentFeature.getPendingDocumentChanges(_this9._pendingOpenNotifications);
+                      if (!(changes.length === 0)) {
+                        _context14.next = 4;
+                        break;
+                      }
+                      return _context14.abrupt("return");
+                    case 4:
+                      _iterator9 = _createForOfIteratorHelper(changes);
+                      _context14.prev = 5;
+                      _iterator9.s();
+                    case 7:
+                      if ((_step9 = _iterator9.n()).done) {
+                        _context14.next = 15;
+                        break;
+                      }
+                      document = _step9.value;
+                      _params = _this9.code2ProtocolConverter.asChangeTextDocumentParams(document); // We await the send and not the delivery since it is more or less the same for
+                      // notifications.
+                      _context14.next = 12;
+                      return connection.sendNotification(DidChangeTextDocumentNotification.type, _params);
+                    case 12:
+                      _this9._didChangeTextDocumentFeature.notificationSent(document, DidChangeTextDocumentNotification.type, _params);
+                    case 13:
+                      _context14.next = 7;
+                      break;
+                    case 15:
+                      _context14.next = 20;
+                      break;
+                    case 17:
+                      _context14.prev = 17;
+                      _context14.t0 = _context14["catch"](5);
+                      _iterator9.e(_context14.t0);
+                    case 20:
+                      _context14.prev = 20;
+                      _iterator9.f();
+                      return _context14.finish(20);
+                    case 23:
+                      _context14.next = 29;
+                      break;
+                    case 25:
+                      _context14.prev = 25;
+                      _context14.t1 = _context14["catch"](0);
+                      _this9.error("Sending pending changes failed", _context14.t1, false);
+                      throw _context14.t1;
+                    case 29:
+                    case "end":
+                      return _context14.stop();
+                  }
+                }, _callee14, null, [[0, 25], [5, 17, 20, 23]]);
+              }))));
+            case 1:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function sendPendingFullTextDocumentChanges(_x17) {
+        return _sendPendingFullTextDocumentChanges.apply(this, arguments);
+      }
+      return sendPendingFullTextDocumentChanges;
+    }()
+  }, {
+    key: "triggerPendingChangeDelivery",
+    value: function triggerPendingChangeDelivery() {
+      var _this10 = this;
+      this._pendingChangeDelayer.trigger( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16() {
+        var connection;
+        return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              connection = _this10.activeConnection();
+              if (!(connection === undefined)) {
+                _context16.next = 4;
+                break;
+              }
+              _this10.triggerPendingChangeDelivery();
+              return _context16.abrupt("return");
+            case 4:
+              _context16.next = 6;
+              return _this10.sendPendingFullTextDocumentChanges(connection);
+            case 6:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16);
+      }))).catch(function (error) {
+        return _this10.error("Delivering pending changes failed", error, false);
+      });
+    }
+  }, {
+    key: "handleDiagnostics",
+    value: function handleDiagnostics(params) {
+      if (!this._diagnostics) {
+        return;
+      }
+      var key = params.uri;
+      if (this._diagnosticQueueState.state === 'busy' && this._diagnosticQueueState.document === key) {
+        // Cancel the active run;
+        this._diagnosticQueueState.tokenSource.cancel();
+      }
+      this._diagnosticQueue.set(params.uri, params.diagnostics);
+      this.triggerDiagnosticQueue();
+    }
+  }, {
+    key: "triggerDiagnosticQueue",
+    value: function triggerDiagnosticQueue() {
+      var _this11 = this;
+      RAL().timer.setImmediate(function () {
+        _this11.workDiagnosticQueue();
+      });
+    }
+  }, {
+    key: "workDiagnosticQueue",
+    value: function workDiagnosticQueue() {
+      var _this12 = this;
+      if (this._diagnosticQueueState.state === 'busy') {
+        return;
+      }
+      var next = this._diagnosticQueue.entries().next();
+      if (next.done === true) {
+        // Nothing in the queue
+        return;
+      }
+      var _next$value = _slicedToArray(next.value, 2),
+        document = _next$value[0],
+        diagnostics = _next$value[1];
+      this._diagnosticQueue.delete(document);
+      var tokenSource = new CancellationTokenSource();
+      this._diagnosticQueueState = {
+        state: 'busy',
+        document: document,
+        tokenSource: tokenSource
+      };
+      this._p2c.asDiagnostics(diagnostics, tokenSource.token).then(function (converted) {
+        if (!tokenSource.token.isCancellationRequested) {
+          var _uri = _this12._p2c.asUri(document);
+          var middleware = _this12.clientOptions.middleware;
+          if (middleware.handleDiagnostics) {
+            middleware.handleDiagnostics(_uri, converted, function (uri, diagnostics) {
+              return _this12.setDiagnostics(uri, diagnostics);
+            });
+          } else {
+            _this12.setDiagnostics(_uri, converted);
+          }
+        }
+      }).catch(function (error) {
+        _this12.error("Processing diagnostic queue failed.", error);
+      }).finally(function () {
+        _this12._diagnosticQueueState = {
+          state: 'idle'
+        };
+        _this12.triggerDiagnosticQueue();
+      });
+    }
+  }, {
+    key: "setDiagnostics",
+    value: function setDiagnostics(uri, diagnostics) {
+      if (!this._diagnostics) {
+        return;
+      }
+      this._diagnostics.set(uri, diagnostics);
+    }
+  }, {
+    key: "getLocale",
+    value: function getLocale() {
+      return Env.language;
+    }
+  }, {
+    key: "$start",
+    value: function () {
+      var _$start = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
+        var connection;
+        return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              if (!(this.$state === ClientState.StartFailed)) {
+                _context17.next = 2;
+                break;
+              }
+              throw new Error("Previous start failed. Can't restart server.");
+            case 2:
+              _context17.next = 4;
+              return this.start();
+            case 4:
+              connection = this.activeConnection();
+              if (!(connection === undefined)) {
+                _context17.next = 7;
+                break;
+              }
+              throw new Error("Starting server failed");
+            case 7:
+              return _context17.abrupt("return", connection);
+            case 8:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function $start() {
+        return _$start.apply(this, arguments);
+      }
+      return $start;
+    }()
+  }, {
+    key: "createConnection",
+    value: function () {
+      var _createConnection2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
+        var _this13 = this;
+        var errorHandler, closeHandler, transports;
+        return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              errorHandler = function errorHandler(error, message, count) {
+                _this13.handleConnectionError(error, message, count).catch(function (error) {
+                  return _this13.error("Handling connection error failed", error);
+                });
+              };
+              closeHandler = function closeHandler() {
+                _this13.handleConnectionClosed().catch(function (error) {
+                  return _this13.error("Handling connection close failed", error);
+                });
+              };
+              _context18.next = 4;
+              return this.createMessageTransports(this._clientOptions.stdioEncoding || 'utf8');
+            case 4:
+              transports = _context18.sent;
+              this._connection = _createConnection(transports.reader, transports.writer, errorHandler, closeHandler, this._clientOptions.connectionOptions);
+              return _context18.abrupt("return", this._connection);
+            case 7:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function createConnection() {
+        return _createConnection2.apply(this, arguments);
+      }
+      return createConnection;
+    }()
+  }, {
+    key: "handleConnectionClosed",
+    value: function () {
+      var _handleConnectionClosed = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
+        var _this14 = this;
+        var handlerResult, _handlerResult$messag, _handlerResult$messag2;
+        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              if (!(this.$state === ClientState.Stopped)) {
+                _context19.next = 2;
+                break;
+              }
+              return _context19.abrupt("return");
+            case 2:
+              try {
+                if (this._connection !== undefined) {
+                  this._connection.dispose();
+                }
+              } catch (error) {
+                // Disposing a connection could fail if error cases.
+              }
+              handlerResult = {
+                action: CloseAction.DoNotRestart
+              };
+              if (!(this.$state !== ClientState.Stopping)) {
+                _context19.next = 13;
+                break;
+              }
+              _context19.prev = 5;
+              _context19.next = 8;
+              return this._clientOptions.errorHandler.closed();
+            case 8:
+              handlerResult = _context19.sent;
+              _context19.next = 13;
+              break;
+            case 11:
+              _context19.prev = 11;
+              _context19.t0 = _context19["catch"](5);
+            case 13:
+              this._connection = undefined;
+              if (handlerResult.action === CloseAction.DoNotRestart) {
+                this.error((_handlerResult$messag = handlerResult.message) !== null && _handlerResult$messag !== void 0 ? _handlerResult$messag : 'Connection to server got closed. Server will not be restarted.', undefined, handlerResult.handled === true ? false : 'force');
+                this.cleanUp('stop');
+                if (this.$state === ClientState.Starting) {
+                  this.$state = ClientState.StartFailed;
+                } else {
+                  this.$state = ClientState.Stopped;
+                }
+                this._onStop = Promise.resolve();
+                this._onStart = undefined;
+              } else if (handlerResult.action === CloseAction.Restart) {
+                this.info((_handlerResult$messag2 = handlerResult.message) !== null && _handlerResult$messag2 !== void 0 ? _handlerResult$messag2 : 'Connection to server got closed. Server will restart.', !handlerResult.handled);
+                this.cleanUp('restart');
+                this.$state = ClientState.Initial;
+                this._onStop = Promise.resolve();
+                this._onStart = undefined;
+                this.start().catch(function (error) {
+                  return _this14.error("Restarting server failed", error, 'force');
+                });
+              }
+            case 15:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this, [[5, 11]]);
+      }));
+      function handleConnectionClosed() {
+        return _handleConnectionClosed.apply(this, arguments);
+      }
+      return handleConnectionClosed;
+    }()
+  }, {
+    key: "handleConnectionError",
+    value: function () {
+      var _handleConnectionError = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20(error, message, count) {
+        var _this15 = this;
+        var handlerResult, _handlerResult$messag3, _handlerResult$messag4;
+        return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              _context20.next = 2;
+              return this._clientOptions.errorHandler.error(error, message, count);
+            case 2:
+              handlerResult = _context20.sent;
+              if (handlerResult.action === ErrorAction.Shutdown) {
+                this.error((_handlerResult$messag3 = handlerResult.message) !== null && _handlerResult$messag3 !== void 0 ? _handlerResult$messag3 : "Client ".concat(this._name, ": connection to server is erroring.\n").concat(error.message, "\nShutting down server."), undefined, handlerResult.handled === true ? false : 'force');
+                this.stop().catch(function (error) {
+                  _this15.error("Stopping server failed", error, false);
+                });
+              } else {
+                this.error((_handlerResult$messag4 = handlerResult.message) !== null && _handlerResult$messag4 !== void 0 ? _handlerResult$messag4 : "Client ".concat(this._name, ": connection to server is erroring.\n").concat(error.message), undefined, handlerResult.handled === true ? false : 'force');
+              }
+            case 4:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20, this);
+      }));
+      function handleConnectionError(_x18, _x19, _x20) {
+        return _handleConnectionError.apply(this, arguments);
+      }
+      return handleConnectionError;
+    }()
+  }, {
+    key: "hookConfigurationChanged",
+    value: function hookConfigurationChanged(connection) {
+      var _this16 = this;
+      this._listeners.push(Workspace.onDidChangeConfiguration(function () {
+        _this16.refreshTrace(connection, true);
+      }));
+    }
+  }, {
+    key: "refreshTrace",
+    value: function refreshTrace(connection) {
+      var _this17 = this;
+      var sendNotification = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var config = Workspace.getConfiguration(this._id);
+      var trace = Trace.Off;
+      var traceFormat = TraceFormat.Text;
+      if (config) {
+        var traceConfig = config.get('trace.server', 'off');
+        if (typeof traceConfig === 'string') {
+          trace = Trace.fromString(traceConfig);
+        } else {
+          trace = Trace.fromString(config.get('trace.server.verbosity', 'off'));
+          traceFormat = TraceFormat.fromString(config.get('trace.server.format', 'text'));
+        }
+      }
+      this._trace = trace;
+      this._traceFormat = traceFormat;
+      connection.trace(this._trace, this._tracer, {
+        sendNotification: sendNotification,
+        traceFormat: this._traceFormat
+      }).catch(function (error) {
+        _this17.error("Updating trace failed with error", error, false);
+      });
+    }
+  }, {
+    key: "hookFileEvents",
+    value: function hookFileEvents(_connection) {
+      var fileEvents = this._clientOptions.synchronize.fileEvents;
+      if (!fileEvents) {
+        return;
+      }
+      var watchers;
+      if (Is.array(fileEvents)) {
+        watchers = fileEvents;
+      } else {
+        watchers = [fileEvents];
+      }
+      if (!watchers) {
+        return;
+      }
+      this._dynamicFeatures.get(DidChangeWatchedFilesNotification.type.method).registerRaw(UUID.generateUuid(), watchers);
+    }
+  }, {
+    key: "registerFeatures",
+    value: function registerFeatures(features) {
+      var _iterator10 = _createForOfIteratorHelper(features),
+        _step10;
+      try {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var feature = _step10.value;
+          this.registerFeature(feature);
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+    }
+  }, {
+    key: "registerFeature",
+    value: function registerFeature(feature) {
+      this._features.push(feature);
+      if (DynamicFeature.is(feature)) {
+        var registrationType = feature.registrationType;
+        this._dynamicFeatures.set(registrationType.method, feature);
+      }
+    }
+  }, {
+    key: "getFeature",
+    value: function getFeature(request) {
+      return this._dynamicFeatures.get(request);
+    }
+  }, {
+    key: "hasDedicatedTextSynchronizationFeature",
+    value: function hasDedicatedTextSynchronizationFeature(textDocument) {
+      var feature = this.getFeature(NotebookDocumentSyncRegistrationType.method);
+      if (feature === undefined || !(feature instanceof NotebookDocumentSyncFeature)) {
+        return false;
+      }
+      return feature.handles(textDocument);
+    }
+  }, {
+    key: "registerBuiltinFeatures",
+    value: function registerBuiltinFeatures() {
+      var _this18 = this;
+      var pendingFullTextDocumentChanges = new Map();
+      this.registerFeature(new ConfigurationFeature(this));
+      this.registerFeature(new DidOpenTextDocumentFeature(this, this._syncedDocuments));
+      this._didChangeTextDocumentFeature = new DidChangeTextDocumentFeature(this, pendingFullTextDocumentChanges);
+      this._didChangeTextDocumentFeature.onPendingChangeAdded(function () {
+        _this18.triggerPendingChangeDelivery();
+      });
+      this.registerFeature(this._didChangeTextDocumentFeature);
+      this.registerFeature(new WillSaveFeature(this));
+      this.registerFeature(new WillSaveWaitUntilFeature(this));
+      this.registerFeature(new DidSaveTextDocumentFeature(this));
+      this.registerFeature(new DidCloseTextDocumentFeature(this, this._syncedDocuments, pendingFullTextDocumentChanges));
+      this.registerFeature(new FileSystemWatcherFeature(this, function (event) {
+        return _this18.notifyFileEvent(event);
+      }));
+      this.registerFeature(new CompletionItemFeature(this));
+      this.registerFeature(new HoverFeature(this));
+      this.registerFeature(new SignatureHelpFeature(this));
+      this.registerFeature(new DefinitionFeature(this));
+      this.registerFeature(new ReferencesFeature(this));
+      this.registerFeature(new DocumentHighlightFeature(this));
+      this.registerFeature(new DocumentSymbolFeature(this));
+      this.registerFeature(new WorkspaceSymbolFeature(this));
+      this.registerFeature(new CodeActionFeature(this));
+      this.registerFeature(new CodeLensFeature(this));
+      this.registerFeature(new DocumentFormattingFeature(this));
+      this.registerFeature(new DocumentRangeFormattingFeature(this));
+      this.registerFeature(new DocumentOnTypeFormattingFeature(this));
+      this.registerFeature(new RenameFeature(this));
+      this.registerFeature(new DocumentLinkFeature(this));
+      this.registerFeature(new ExecuteCommandFeature(this));
+      this.registerFeature(new SyncConfigurationFeature(this));
+      this.registerFeature(new TypeDefinitionFeature(this));
+      this.registerFeature(new ImplementationFeature(this));
+      this.registerFeature(new ColorProviderFeature(this));
+      // We only register the workspace folder feature if the client is not locked
+      // to a specific workspace folder.
+      if (this.clientOptions.workspaceFolder === undefined) {
+        this.registerFeature(new WorkspaceFoldersFeature(this));
+      }
+      this.registerFeature(new FoldingRangeFeature(this));
+      this.registerFeature(new DeclarationFeature(this));
+      this.registerFeature(new SelectionRangeFeature(this));
+      this.registerFeature(new ProgressFeature(this));
+      this.registerFeature(new CallHierarchyFeature(this));
+      this.registerFeature(new SemanticTokensFeature(this));
+      this.registerFeature(new LinkedEditingFeature(this));
+      this.registerFeature(new DidCreateFilesFeature(this));
+      this.registerFeature(new DidRenameFilesFeature(this));
+      this.registerFeature(new DidDeleteFilesFeature(this));
+      this.registerFeature(new WillCreateFilesFeature(this));
+      this.registerFeature(new WillRenameFilesFeature(this));
+      this.registerFeature(new WillDeleteFilesFeature(this));
+      this.registerFeature(new TypeHierarchyFeature(this));
+      this.registerFeature(new InlineValueFeature(this));
+      this.registerFeature(new InlayHintsFeature(this));
+      this.registerFeature(new DiagnosticFeature(this));
+      this.registerFeature(new NotebookDocumentSyncFeature(this));
+    }
+  }, {
+    key: "registerProposedFeatures",
+    value: function registerProposedFeatures() {
+      this.registerFeatures(ProposedFeatures.createAll(this));
+    }
+  }, {
+    key: "fillInitializeParams",
+    value: function fillInitializeParams(params) {
+      var _iterator11 = _createForOfIteratorHelper(this._features),
+        _step11;
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var feature = _step11.value;
+          if (Is.func(feature.fillInitializeParams)) {
+            feature.fillInitializeParams(params);
+          }
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+    }
+  }, {
+    key: "computeClientCapabilities",
+    value: function computeClientCapabilities() {
+      var result = {};
+      ensure(result, 'workspace').applyEdit = true;
+      var workspaceEdit = ensure(ensure(result, 'workspace'), 'workspaceEdit');
+      workspaceEdit.documentChanges = true;
+      workspaceEdit.resourceOperations = [ResourceOperationKind.Create, ResourceOperationKind.Rename, ResourceOperationKind.Delete];
+      workspaceEdit.failureHandling = FailureHandlingKind.TextOnlyTransactional;
+      workspaceEdit.normalizesLineEndings = true;
+      workspaceEdit.changeAnnotationSupport = {
+        groupsOnLabel: true
+      };
+      var diagnostics = ensure(ensure(result, 'textDocument'), 'publishDiagnostics');
+      diagnostics.relatedInformation = true;
+      diagnostics.versionSupport = false;
+      diagnostics.tagSupport = {
+        valueSet: [DiagnosticTag.Unnecessary, DiagnosticTag.Deprecated]
+      };
+      diagnostics.codeDescriptionSupport = true;
+      diagnostics.dataSupport = true;
+      var windowCapabilities = ensure(result, 'window');
+      var showMessage = ensure(windowCapabilities, 'showMessage');
+      showMessage.messageActionItem = {
+        additionalPropertiesSupport: true
+      };
+      var showDocument = ensure(windowCapabilities, 'showDocument');
+      showDocument.support = true;
+      var generalCapabilities = ensure(result, 'general');
+      generalCapabilities.staleRequestSupport = {
+        cancel: true,
+        retryOnContentModified: Array.from(BaseLanguageClient.RequestsToCancelOnContentModified)
+      };
+      generalCapabilities.regularExpressions = {
+        engine: 'ECMAScript',
+        version: 'ES2020'
+      };
+      generalCapabilities.markdown = {
+        parser: 'marked',
+        version: '1.1.0'
+      };
+      generalCapabilities.positionEncodings = ['utf-16'];
+      if (this._clientOptions.markdown.supportHtml) {
+        generalCapabilities.markdown.allowedTags = ['ul', 'li', 'p', 'code', 'blockquote', 'ol', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'em', 'pre', 'table', 'thead', 'tbody', 'tr', 'th', 'td', 'div', 'del', 'a', 'strong', 'br', 'img', 'span'];
+      }
+      var _iterator12 = _createForOfIteratorHelper(this._features),
+        _step12;
+      try {
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          var feature = _step12.value;
+          feature.fillClientCapabilities(result);
+        }
+      } catch (err) {
+        _iterator12.e(err);
+      } finally {
+        _iterator12.f();
+      }
+      return result;
+    }
+  }, {
+    key: "initializeFeatures",
+    value: function initializeFeatures(_connection) {
+      var documentSelector = this._clientOptions.documentSelector;
+      var _iterator13 = _createForOfIteratorHelper(this._features),
+        _step13;
+      try {
+        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+          var feature = _step13.value;
+          if (Is.func(feature.preInitialize)) {
+            feature.preInitialize(this._capabilities, documentSelector);
+          }
+        }
+      } catch (err) {
+        _iterator13.e(err);
+      } finally {
+        _iterator13.f();
+      }
+      var _iterator14 = _createForOfIteratorHelper(this._features),
+        _step14;
+      try {
+        for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+          var _feature = _step14.value;
+          _feature.initialize(this._capabilities, documentSelector);
+        }
+      } catch (err) {
+        _iterator14.e(err);
+      } finally {
+        _iterator14.f();
+      }
+    }
+  }, {
+    key: "handleRegistrationRequest",
+    value: function () {
+      var _handleRegistrationRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(params) {
+        var _this$clientOptions$m2,
+          _this19 = this;
+        var middleware;
+        return _regeneratorRuntime().wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              middleware = (_this$clientOptions$m2 = this.clientOptions.middleware) === null || _this$clientOptions$m2 === void 0 ? void 0 : _this$clientOptions$m2.handleRegisterCapability;
+              if (!middleware) {
+                _context21.next = 5;
+                break;
+              }
+              return _context21.abrupt("return", middleware(params, function (nextParams) {
+                return _this19.doRegisterCapability(nextParams);
+              }));
+            case 5:
+              return _context21.abrupt("return", this.doRegisterCapability(params));
+            case 6:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21, this);
+      }));
+      function handleRegistrationRequest(_x21) {
+        return _handleRegistrationRequest.apply(this, arguments);
+      }
+      return handleRegistrationRequest;
+    }()
+  }, {
+    key: "doRegisterCapability",
+    value: function () {
+      var _doRegisterCapability = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(params) {
+        var _iterator15, _step15, registration, _iterator16, _step16, _registration$registe, _documentSelector, _registration, feature, options, data;
+        return _regeneratorRuntime().wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              if (this.isRunning()) {
+                _context22.next = 4;
+                break;
+              }
+              _iterator15 = _createForOfIteratorHelper(params.registrations);
+              try {
+                for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+                  registration = _step15.value;
+                  this._ignoredRegistrations.add(registration.id);
+                }
+              } catch (err) {
+                _iterator15.e(err);
+              } finally {
+                _iterator15.f();
+              }
+              return _context22.abrupt("return");
+            case 4:
+              _iterator16 = _createForOfIteratorHelper(params.registrations);
+              _context22.prev = 5;
+              _iterator16.s();
+            case 7:
+              if ((_step16 = _iterator16.n()).done) {
+                _context22.next = 24;
+                break;
+              }
+              _registration = _step16.value;
+              feature = this._dynamicFeatures.get(_registration.method);
+              if (!(feature === undefined)) {
+                _context22.next = 12;
+                break;
+              }
+              return _context22.abrupt("return", Promise.reject(new Error("No feature implementation for ".concat(_registration.method, " found. Registration failed."))));
+            case 12:
+              options = (_registration$registe = _registration.registerOptions) !== null && _registration$registe !== void 0 ? _registration$registe : {};
+              options.documentSelector = (_documentSelector = options.documentSelector) !== null && _documentSelector !== void 0 ? _documentSelector : this._clientOptions.documentSelector;
+              data = {
+                id: _registration.id,
+                registerOptions: options
+              };
+              _context22.prev = 15;
+              feature.register(data);
+              _context22.next = 22;
+              break;
+            case 19:
+              _context22.prev = 19;
+              _context22.t0 = _context22["catch"](15);
+              return _context22.abrupt("return", Promise.reject(_context22.t0));
+            case 22:
+              _context22.next = 7;
+              break;
+            case 24:
+              _context22.next = 29;
+              break;
+            case 26:
+              _context22.prev = 26;
+              _context22.t1 = _context22["catch"](5);
+              _iterator16.e(_context22.t1);
+            case 29:
+              _context22.prev = 29;
+              _iterator16.f();
+              return _context22.finish(29);
+            case 32:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22, this, [[5, 26, 29, 32], [15, 19]]);
+      }));
+      function doRegisterCapability(_x22) {
+        return _doRegisterCapability.apply(this, arguments);
+      }
+      return doRegisterCapability;
+    }()
+  }, {
+    key: "handleUnregistrationRequest",
+    value: function () {
+      var _handleUnregistrationRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23(params) {
+        var _this$clientOptions$m3,
+          _this20 = this;
+        var middleware;
+        return _regeneratorRuntime().wrap(function _callee23$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              middleware = (_this$clientOptions$m3 = this.clientOptions.middleware) === null || _this$clientOptions$m3 === void 0 ? void 0 : _this$clientOptions$m3.handleUnregisterCapability;
+              if (!middleware) {
+                _context23.next = 5;
+                break;
+              }
+              return _context23.abrupt("return", middleware(params, function (nextParams) {
+                return _this20.doUnregisterCapability(nextParams);
+              }));
+            case 5:
+              return _context23.abrupt("return", this.doUnregisterCapability(params));
+            case 6:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee23, this);
+      }));
+      function handleUnregistrationRequest(_x23) {
+        return _handleUnregistrationRequest.apply(this, arguments);
+      }
+      return handleUnregistrationRequest;
+    }()
+  }, {
+    key: "doUnregisterCapability",
+    value: function () {
+      var _doUnregisterCapability = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee24(params) {
+        var _iterator17, _step17, unregistration, feature;
+        return _regeneratorRuntime().wrap(function _callee24$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              _iterator17 = _createForOfIteratorHelper(params.unregisterations);
+              _context24.prev = 1;
+              _iterator17.s();
+            case 3:
+              if ((_step17 = _iterator17.n()).done) {
+                _context24.next = 13;
+                break;
+              }
+              unregistration = _step17.value;
+              if (!this._ignoredRegistrations.has(unregistration.id)) {
+                _context24.next = 7;
+                break;
+              }
+              return _context24.abrupt("continue", 11);
+            case 7:
+              feature = this._dynamicFeatures.get(unregistration.method);
+              if (feature) {
+                _context24.next = 10;
+                break;
+              }
+              return _context24.abrupt("return", Promise.reject(new Error("No feature implementation for ".concat(unregistration.method, " found. Unregistration failed."))));
+            case 10:
+              feature.unregister(unregistration.id);
+            case 11:
+              _context24.next = 3;
+              break;
+            case 13:
+              _context24.next = 18;
+              break;
+            case 15:
+              _context24.prev = 15;
+              _context24.t0 = _context24["catch"](1);
+              _iterator17.e(_context24.t0);
+            case 18:
+              _context24.prev = 18;
+              _iterator17.f();
+              return _context24.finish(18);
+            case 21:
+            case "end":
+              return _context24.stop();
+          }
+        }, _callee24, this, [[1, 15, 18, 21]]);
+      }));
+      function doUnregisterCapability(_x24) {
+        return _doUnregisterCapability.apply(this, arguments);
+      }
+      return doUnregisterCapability;
+    }()
+  }, {
+    key: "handleApplyWorkspaceEdit",
+    value: function () {
+      var _handleApplyWorkspaceEdit = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee25(params) {
+        var _this$clientOptions$m4,
+          _this21 = this;
+        var middleware, resultOrError;
+        return _regeneratorRuntime().wrap(function _callee25$(_context25) {
+          while (1) switch (_context25.prev = _context25.next) {
+            case 0:
+              middleware = (_this$clientOptions$m4 = this.clientOptions.middleware) === null || _this$clientOptions$m4 === void 0 || (_this$clientOptions$m4 = _this$clientOptions$m4.workspace) === null || _this$clientOptions$m4 === void 0 ? void 0 : _this$clientOptions$m4.handleApplyEdit;
+              if (!middleware) {
+                _context25.next = 10;
+                break;
+              }
+              _context25.next = 4;
+              return middleware(params, function (nextParams) {
+                return _this21.doHandleApplyWorkspaceEdit(nextParams);
+              });
+            case 4:
+              resultOrError = _context25.sent;
+              if (!(resultOrError instanceof ResponseError)) {
+                _context25.next = 7;
+                break;
+              }
+              return _context25.abrupt("return", Promise.reject(resultOrError));
+            case 7:
+              return _context25.abrupt("return", resultOrError);
+            case 10:
+              return _context25.abrupt("return", this.doHandleApplyWorkspaceEdit(params));
+            case 11:
+            case "end":
+              return _context25.stop();
+          }
+        }, _callee25, this);
+      }));
+      function handleApplyWorkspaceEdit(_x25) {
+        return _handleApplyWorkspaceEdit.apply(this, arguments);
+      }
+      return handleApplyWorkspaceEdit;
+    }()
+  }, {
+    key: "doHandleApplyWorkspaceEdit",
+    value: function () {
+      var _doHandleApplyWorkspaceEdit = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26(params) {
+        var _this22 = this;
+        var workspaceEdit, converted, openTextDocuments, versionMismatch, _iterator18, _step18, change, changeUri, _textDocument;
+        return _regeneratorRuntime().wrap(function _callee26$(_context26) {
+          while (1) switch (_context26.prev = _context26.next) {
+            case 0:
+              workspaceEdit = params.edit; // Make sure we convert workspace edits one after the other. Otherwise
+              // we might execute a workspace edit received first after we received another
+              // one since the conversion might race.
+              _context26.next = 3;
+              return this.workspaceEditLock.lock(function () {
+                return _this22._p2c.asWorkspaceEdit(workspaceEdit);
+              });
+            case 3:
+              converted = _context26.sent;
+              // This is some sort of workaround since the version check should be done by VS Code in the Workspace.applyEdit.
+              // However doing it here adds some safety since the server can lag more behind then an extension.
+              openTextDocuments = new Map();
+              Workspace.textDocuments.forEach(function (document) {
+                return openTextDocuments.set(document.uri.toString(), document);
+              });
+              versionMismatch = false;
+              if (!workspaceEdit.documentChanges) {
+                _context26.next = 29;
+                break;
+              }
+              _iterator18 = _createForOfIteratorHelper(workspaceEdit.documentChanges);
+              _context26.prev = 9;
+              _iterator18.s();
+            case 11:
+              if ((_step18 = _iterator18.n()).done) {
+                _context26.next = 21;
+                break;
+              }
+              change = _step18.value;
+              if (!(TextDocumentEdit.is(change) && change.textDocument.version && change.textDocument.version >= 0)) {
+                _context26.next = 19;
+                break;
+              }
+              changeUri = this._p2c.asUri(change.textDocument.uri).toString();
+              _textDocument = openTextDocuments.get(changeUri);
+              if (!(_textDocument && _textDocument.version !== change.textDocument.version)) {
+                _context26.next = 19;
+                break;
+              }
+              versionMismatch = true;
+              return _context26.abrupt("break", 21);
+            case 19:
+              _context26.next = 11;
+              break;
+            case 21:
+              _context26.next = 26;
+              break;
+            case 23:
+              _context26.prev = 23;
+              _context26.t0 = _context26["catch"](9);
+              _iterator18.e(_context26.t0);
+            case 26:
+              _context26.prev = 26;
+              _iterator18.f();
+              return _context26.finish(26);
+            case 29:
+              if (!versionMismatch) {
+                _context26.next = 31;
+                break;
+              }
+              return _context26.abrupt("return", Promise.resolve({
+                applied: false
+              }));
+            case 31:
+              return _context26.abrupt("return", Is.asPromise(Workspace.applyEdit(converted).then(function (value) {
+                return {
+                  applied: value
+                };
+              })));
+            case 32:
+            case "end":
+              return _context26.stop();
+          }
+        }, _callee26, this, [[9, 23, 26, 29]]);
+      }));
+      function doHandleApplyWorkspaceEdit(_x26) {
+        return _doHandleApplyWorkspaceEdit.apply(this, arguments);
+      }
+      return doHandleApplyWorkspaceEdit;
+    }()
+  }, {
+    key: "handleFailedRequest",
+    value: function handleFailedRequest(type, token, error, defaultValue) {
+      var showNotification = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+      // If we get a request cancel or a content modified don't log anything.
+      if (error instanceof ResponseError) {
+        // The connection got disposed while we were waiting for a response.
+        // Simply return the default value. Is the best we can do.
+        if (error.code === ErrorCodes.PendingResponseRejected || error.code === ErrorCodes.ConnectionInactive) {
+          return defaultValue;
+        }
+        if (error.code === LSPErrorCodes.RequestCancelled || error.code === LSPErrorCodes.ServerCancelled) {
+          if (token !== undefined && token.isCancellationRequested) {
+            return defaultValue;
+          } else {
+            if (error.data !== undefined) {
+              throw new LSPCancellationError(error.data);
+            } else {
+              throw new CancellationError();
+            }
+          }
+        } else if (error.code === LSPErrorCodes.ContentModified) {
+          if (BaseLanguageClient.RequestsToCancelOnContentModified.has(type.method) || BaseLanguageClient.CancellableResolveCalls.has(type.method)) {
+            throw new CancellationError();
+          } else {
+            return defaultValue;
+          }
+        }
+      }
+      this.error("Request ".concat(type.method, " failed."), error, showNotification);
+      throw error;
+    }
+
+    // private checkSuspend(): void {
+    // 	if (this.$state !== ClientState.Running) {
+    // 		return;
+    // 	}
+    // 	const connection = this.activeConnection();
+    // 	if (connection === undefined) {
+    // 		this._idleStart = undefined;
+    // 		return;
+    // 	}
+    // 	// Since the last idle start we sent a request. Cancel the idle counting.
+    // 	if (connection.hasPendingResponse() || (this._idleStart !== undefined && connection.lastUsed > this._idleStart)) {
+    // 		this._idleStart = undefined;
+    // 		return;
+    // 	}
+    // 	if (this.isIdle()) {
+    // 		const production = (this.clientOptions as TestOptions).$testMode !== true;
+    // 		// Only do this in production since in test cases we only have
+    // 		// 2000 ms to suspend.
+    // 		if (production) {
+    // 			if (this._idleStart === undefined) {
+    // 				this._idleStart = Date.now();
+    // 				return;
+    // 			}
+
+    // 			const interval = this._clientOptions.suspend.interval;
+    // 			const diff = Date.now() - this._idleStart;
+    // 			if (diff < interval * 3) {
+    // 				return;
+    // 			}
+    // 			if (diff > interval * 5) {
+    // 				// Avoid that we shutdown the server when a computer resumes from sleep.
+    // 				this._idleStart = undefined;
+    // 				return;
+    // 			}
+    // 		}
+
+    // 		this._idleStart = undefined;
+    // 		this.info(`Suspending server`);
+    // 		this._clientOptions.suspend.callback().then((approved) => {
+    // 			if (!approved) {
+    // 				this._idleStart = undefined;
+    // 				return;
+    // 			}
+    // 			return this.suspend().then(() => {
+    // 				this.info(`Server got suspended`);
+    // 			});
+    // 		}, (error) => {
+    // 			this.error(`Suspending server failed`, error, 'force');
+    // 		});
+    // 	} else {
+    // 		this._idleStart = undefined;
+    // 	}
+    // }
+
+    // private isIdle(): boolean {
+    // 	const suspendMode = this._clientOptions.suspend.mode;
+    // 	if (suspendMode === SuspendMode.off) {
+    // 		return false;
+    // 	}
+
+    // 	for (const feature of this._features) {
+    // 		const state = feature.getState();
+    // 		// 'static' feature don't depend on registrations. So they
+    // 		// can't block suspend
+    // 		if (state.kind === 'static') {
+    // 			continue;
+    // 		}
+    // 		// The feature has no registrations. So no blocking of the
+    // 		// suspend.
+    // 		if (!state.registrations) {
+    // 			continue;
+    // 		}
+
+    // 		if (state.kind === 'document' && state.matches === true) {
+    // 			return false;
+    // 		}
+    // 	}
+    // 	return true;
+    // }
+  }]);
+  return BaseLanguageClient;
+}();
+BaseLanguageClient.RequestsToCancelOnContentModified = new Set([SemanticTokensRequest.method, SemanticTokensRangeRequest.method, SemanticTokensDeltaRequest.method]);
+BaseLanguageClient.CancellableResolveCalls = new Set([CompletionResolveRequest.method, CodeLensResolveRequest.method, CodeActionResolveRequest.method, InlayHintResolveRequest.method, DocumentLinkResolveRequest.method, WorkspaceSymbolResolveRequest.method]);
+var ConsoleLogger = /*#__PURE__*/function () {
+  function ConsoleLogger() {
+    _classCallCheck(this, ConsoleLogger);
+  }
+  _createClass(ConsoleLogger, [{
+    key: "error",
+    value: function error(message) {
+      RAL().console.error(message);
+    }
+  }, {
+    key: "warn",
+    value: function warn(message) {
+      RAL().console.warn(message);
+    }
+  }, {
+    key: "info",
+    value: function info(message) {
+      RAL().console.info(message);
+    }
+  }, {
+    key: "log",
+    value: function log(message) {
+      RAL().console.log(message);
+    }
+  }]);
+  return ConsoleLogger;
+}();
+function _createConnection(input, output, errorHandler, closeHandler, options) {
+  var logger = new ConsoleLogger();
+  var connection = createProtocolConnection(input, output, logger, options);
+  connection.onError(function (data) {
+    errorHandler(data[0], data[1], data[2]);
+  });
+  connection.onClose(closeHandler);
+  var result = {
+    listen: function listen() {
+      return connection.listen();
+    },
+    sendRequest: connection.sendRequest,
+    onRequest: connection.onRequest,
+    hasPendingResponse: connection.hasPendingResponse,
+    sendNotification: connection.sendNotification,
+    onNotification: connection.onNotification,
+    onProgress: connection.onProgress,
+    sendProgress: connection.sendProgress,
+    trace: function trace(value, tracer, sendNotificationOrTraceOptions) {
+      var defaultTraceOptions = {
+        sendNotification: false,
+        traceFormat: TraceFormat.Text
+      };
+      if (sendNotificationOrTraceOptions === undefined) {
+        return connection.trace(value, tracer, defaultTraceOptions);
+      } else if (Is.boolean(sendNotificationOrTraceOptions)) {
+        return connection.trace(value, tracer, sendNotificationOrTraceOptions);
+      } else {
+        return connection.trace(value, tracer, sendNotificationOrTraceOptions);
+      }
+    },
+    initialize: function initialize(params) {
+      // This needs to return and MUST not be await to avoid any async
+      // scheduling. Otherwise messages might overtake each other.
+      return connection.sendRequest(InitializeRequest.type, params);
+    },
+    shutdown: function shutdown() {
+      // This needs to return and MUST not be await to avoid any async
+      // scheduling. Otherwise messages might overtake each other.
+      return connection.sendRequest(ShutdownRequest.type, undefined);
+    },
+    exit: function exit() {
+      // This needs to return and MUST not be await to avoid any async
+      // scheduling. Otherwise messages might overtake each other.
+      return connection.sendNotification(ExitNotification.type);
+    },
+    end: function end() {
+      return connection.end();
+    },
+    dispose: function dispose() {
+      return connection.dispose();
+    }
+  };
+  return result;
+}
+
+// Exporting proposed protocol.
+export var ProposedFeatures;
+(function (_ProposedFeatures) {
+  function createAll(_client) {
+    var result = [new InlineCompletionItemFeature(_client)];
+    return result;
+  }
+  _ProposedFeatures.createAll = createAll;
+})(ProposedFeatures || (ProposedFeatures = {}));