X-Git-Url: https://git.josue.xyz/?p=dotfiles%2F.git;a=blobdiff_plain;f=.config%2Fcoc%2Fextensions%2Fnode_modules%2Fcoc-tsserver%2Flib%2Findex.js;h=6851f7f235225f98ab82052a5a7b442cdb4a8b96;hp=94343820b12036175ff515782321d50011fd2c28;hb=3be0a9efc698a9570a44456009afc6014812625a;hpb=d2f432cc757f42f0318fdddcab8c00b240d47088

diff --git a/.config/coc/extensions/node_modules/coc-tsserver/lib/index.js b/.config/coc/extensions/node_modules/coc-tsserver/lib/index.js
index 94343820..6851f7f2 100644
--- a/.config/coc/extensions/node_modules/coc-tsserver/lib/index.js
+++ b/.config/coc/extensions/node_modules/coc-tsserver/lib/index.js
@@ -32,10 +32,353 @@ var __toModule = (module2) => {
   return __exportStar(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", {value: module2, enumerable: true}), module2);
 };
 
-// node_modules/vscode-jsonrpc/lib/is.js
+// node_modules/vscode-jsonrpc/lib/common/ral.js
+var require_ral = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  var _ral;
+  function RAL() {
+    if (_ral === void 0) {
+      throw new Error(`No runtime abstraction layer installed`);
+    }
+    return _ral;
+  }
+  (function(RAL2) {
+    function install(ral) {
+      if (ral === void 0) {
+        throw new Error(`No runtime abstraction layer provided`);
+      }
+      _ral = ral;
+    }
+    RAL2.install = install;
+  })(RAL || (RAL = {}));
+  exports2.default = RAL;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/disposable.js
+var require_disposable = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.Disposable = void 0;
+  var Disposable13;
+  (function(Disposable14) {
+    function create(func) {
+      return {
+        dispose: func
+      };
+    }
+    Disposable14.create = create;
+  })(Disposable13 = exports2.Disposable || (exports2.Disposable = {}));
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
+var require_messageBuffer = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.AbstractMessageBuffer = void 0;
+  var CR = 13;
+  var LF = 10;
+  var CRLF = "\r\n";
+  var AbstractMessageBuffer = class {
+    constructor(encoding = "utf-8") {
+      this._encoding = encoding;
+      this._chunks = [];
+      this._totalLength = 0;
+    }
+    get encoding() {
+      return this._encoding;
+    }
+    append(chunk) {
+      const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
+      this._chunks.push(toAppend);
+      this._totalLength += toAppend.byteLength;
+    }
+    tryReadHeaders() {
+      if (this._chunks.length === 0) {
+        return void 0;
+      }
+      let state = 0;
+      let chunkIndex = 0;
+      let offset = 0;
+      let chunkBytesRead = 0;
+      row:
+        while (chunkIndex < this._chunks.length) {
+          const chunk = this._chunks[chunkIndex];
+          offset = 0;
+          column:
+            while (offset < chunk.length) {
+              const value = chunk[offset];
+              switch (value) {
+                case CR:
+                  switch (state) {
+                    case 0:
+                      state = 1;
+                      break;
+                    case 2:
+                      state = 3;
+                      break;
+                    default:
+                      state = 0;
+                  }
+                  break;
+                case LF:
+                  switch (state) {
+                    case 1:
+                      state = 2;
+                      break;
+                    case 3:
+                      state = 4;
+                      offset++;
+                      break row;
+                    default:
+                      state = 0;
+                  }
+                  break;
+                default:
+                  state = 0;
+              }
+              offset++;
+            }
+          chunkBytesRead += chunk.byteLength;
+          chunkIndex++;
+        }
+      if (state !== 4) {
+        return void 0;
+      }
+      const buffer = this._read(chunkBytesRead + offset);
+      const result = new Map();
+      const headers = this.toString(buffer, "ascii").split(CRLF);
+      if (headers.length < 2) {
+        return result;
+      }
+      for (let i = 0; i < headers.length - 2; i++) {
+        const header = headers[i];
+        const index = header.indexOf(":");
+        if (index === -1) {
+          throw new Error("Message header must separate key and value using :");
+        }
+        const key = header.substr(0, index);
+        const value = header.substr(index + 1).trim();
+        result.set(key, value);
+      }
+      return result;
+    }
+    tryReadBody(length) {
+      if (this._totalLength < length) {
+        return void 0;
+      }
+      return this._read(length);
+    }
+    get numberOfBytes() {
+      return this._totalLength;
+    }
+    _read(byteCount) {
+      if (byteCount === 0) {
+        return this.emptyBuffer();
+      }
+      if (byteCount > this._totalLength) {
+        throw new Error(`Cannot read so many bytes!`);
+      }
+      if (this._chunks[0].byteLength === byteCount) {
+        const chunk = this._chunks[0];
+        this._chunks.shift();
+        this._totalLength -= byteCount;
+        return this.asNative(chunk);
+      }
+      if (this._chunks[0].byteLength > byteCount) {
+        const chunk = this._chunks[0];
+        const result2 = this.asNative(chunk, byteCount);
+        this._chunks[0] = chunk.slice(byteCount);
+        this._totalLength -= byteCount;
+        return result2;
+      }
+      const result = this.allocNative(byteCount);
+      let resultOffset = 0;
+      let chunkIndex = 0;
+      while (byteCount > 0) {
+        const chunk = this._chunks[chunkIndex];
+        if (chunk.byteLength > byteCount) {
+          const chunkPart = chunk.slice(0, byteCount);
+          result.set(chunkPart, resultOffset);
+          resultOffset += byteCount;
+          this._chunks[chunkIndex] = chunk.slice(byteCount);
+          this._totalLength -= byteCount;
+          byteCount -= byteCount;
+        } else {
+          result.set(chunk, resultOffset);
+          resultOffset += chunk.byteLength;
+          this._chunks.shift();
+          this._totalLength -= chunk.byteLength;
+          byteCount -= chunk.byteLength;
+        }
+      }
+      return result;
+    }
+  };
+  exports2.AbstractMessageBuffer = AbstractMessageBuffer;
+});
+
+// node_modules/vscode-jsonrpc/lib/node/ril.js
+var require_ril = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  var ral_1 = require_ral();
+  var util_1 = require("util");
+  var disposable_1 = require_disposable();
+  var messageBuffer_1 = require_messageBuffer();
+  var MessageBuffer = class extends messageBuffer_1.AbstractMessageBuffer {
+    constructor(encoding = "utf-8") {
+      super(encoding);
+    }
+    emptyBuffer() {
+      return MessageBuffer.emptyBuffer;
+    }
+    fromString(value, encoding) {
+      return Buffer.from(value, encoding);
+    }
+    toString(value, encoding) {
+      if (value instanceof Buffer) {
+        return value.toString(encoding);
+      } else {
+        return new util_1.TextDecoder(encoding).decode(value);
+      }
+    }
+    asNative(buffer, length) {
+      if (length === void 0) {
+        return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
+      } else {
+        return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
+      }
+    }
+    allocNative(length) {
+      return Buffer.allocUnsafe(length);
+    }
+  };
+  MessageBuffer.emptyBuffer = Buffer.allocUnsafe(0);
+  var ReadableStreamWrapper = class {
+    constructor(stream) {
+      this.stream = stream;
+    }
+    onClose(listener) {
+      this.stream.on("close", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("close", listener));
+    }
+    onError(listener) {
+      this.stream.on("error", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("error", listener));
+    }
+    onEnd(listener) {
+      this.stream.on("end", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("end", listener));
+    }
+    onData(listener) {
+      this.stream.on("data", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("data", listener));
+    }
+  };
+  var WritableStreamWrapper = class {
+    constructor(stream) {
+      this.stream = stream;
+    }
+    onClose(listener) {
+      this.stream.on("close", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("close", listener));
+    }
+    onError(listener) {
+      this.stream.on("error", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("error", listener));
+    }
+    onEnd(listener) {
+      this.stream.on("end", listener);
+      return disposable_1.Disposable.create(() => this.stream.off("end", listener));
+    }
+    write(data, encoding) {
+      return new Promise((resolve, reject) => {
+        const callback = (error) => {
+          if (error === void 0 || error === null) {
+            resolve();
+          } else {
+            reject(error);
+          }
+        };
+        if (typeof data === "string") {
+          this.stream.write(data, encoding, callback);
+        } else {
+          this.stream.write(data, callback);
+        }
+      });
+    }
+    end() {
+      this.stream.end();
+    }
+  };
+  var _ril = Object.freeze({
+    messageBuffer: Object.freeze({
+      create: (encoding) => new MessageBuffer(encoding)
+    }),
+    applicationJson: Object.freeze({
+      encoder: Object.freeze({
+        name: "application/json",
+        encode: (msg, options) => {
+          try {
+            return Promise.resolve(Buffer.from(JSON.stringify(msg, void 0, 0), options.charset));
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        }
+      }),
+      decoder: Object.freeze({
+        name: "application/json",
+        decode: (buffer, options) => {
+          try {
+            if (buffer instanceof Buffer) {
+              return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
+            } else {
+              return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
+            }
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        }
+      })
+    }),
+    stream: Object.freeze({
+      asReadableStream: (stream) => new ReadableStreamWrapper(stream),
+      asWritableStream: (stream) => new WritableStreamWrapper(stream)
+    }),
+    console,
+    timer: Object.freeze({
+      setTimeout(callback, ms, ...args) {
+        return setTimeout(callback, ms, ...args);
+      },
+      clearTimeout(handle) {
+        clearTimeout(handle);
+      },
+      setImmediate(callback, ...args) {
+        return setImmediate(callback, ...args);
+      },
+      clearImmediate(handle) {
+        clearImmediate(handle);
+      }
+    })
+  });
+  function RIL() {
+    return _ril;
+  }
+  (function(RIL2) {
+    function install() {
+      ral_1.default.install(_ril);
+    }
+    RIL2.install = install;
+  })(RIL || (RIL = {}));
+  exports2.default = RIL;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/is.js
 var require_is = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
   function boolean2(value) {
     return value === true || value === false;
   }
@@ -66,10 +409,11 @@ var require_is = __commonJS((exports2) => {
   exports2.stringArray = stringArray;
 });
 
-// node_modules/vscode-jsonrpc/lib/messages.js
+// node_modules/vscode-jsonrpc/lib/common/messages.js
 var require_messages = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.isResponseMessage = exports2.isNotificationMessage = exports2.isRequestMessage = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType = exports2.RequestType0 = exports2.AbstractMessageSignature = exports2.ParameterStructures = exports2.ResponseError = exports2.ErrorCodes = void 0;
   var is2 = require_is();
   var ErrorCodes;
   (function(ErrorCodes2) {
@@ -78,14 +422,14 @@ var require_messages = __commonJS((exports2) => {
     ErrorCodes2.MethodNotFound = -32601;
     ErrorCodes2.InvalidParams = -32602;
     ErrorCodes2.InternalError = -32603;
-    ErrorCodes2.serverErrorStart = -32099;
-    ErrorCodes2.serverErrorEnd = -32e3;
+    ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
+    ErrorCodes2.serverErrorStart = ErrorCodes2.jsonrpcReservedErrorRangeStart;
+    ErrorCodes2.MessageWriteError = -32099;
+    ErrorCodes2.MessageReadError = -32098;
     ErrorCodes2.ServerNotInitialized = -32002;
     ErrorCodes2.UnknownErrorCode = -32001;
-    ErrorCodes2.RequestCancelled = -32800;
-    ErrorCodes2.ContentModified = -32801;
-    ErrorCodes2.MessageWriteError = 1;
-    ErrorCodes2.MessageReadError = 2;
+    ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
+    ErrorCodes2.serverErrorEnd = ErrorCodes2.jsonrpcReservedErrorRangeEnd;
   })(ErrorCodes = exports2.ErrorCodes || (exports2.ErrorCodes = {}));
   var ResponseError = class extends Error {
     constructor(code, message, data) {
@@ -103,182 +447,202 @@ var require_messages = __commonJS((exports2) => {
     }
   };
   exports2.ResponseError = ResponseError;
-  var AbstractMessageType = class {
-    constructor(_method, _numberOfParams) {
-      this._method = _method;
-      this._numberOfParams = _numberOfParams;
+  var ParameterStructures = class {
+    constructor(kind) {
+      this.kind = kind;
     }
-    get method() {
-      return this._method;
+    static is(value) {
+      return value === ParameterStructures.auto || value === ParameterStructures.byName || value === ParameterStructures.byPosition;
+    }
+    toString() {
+      return this.kind;
     }
-    get numberOfParams() {
-      return this._numberOfParams;
+  };
+  exports2.ParameterStructures = ParameterStructures;
+  ParameterStructures.auto = new ParameterStructures("auto");
+  ParameterStructures.byPosition = new ParameterStructures("byPosition");
+  ParameterStructures.byName = new ParameterStructures("byName");
+  var AbstractMessageSignature = class {
+    constructor(method, numberOfParams) {
+      this.method = method;
+      this.numberOfParams = numberOfParams;
+    }
+    get parameterStructures() {
+      return ParameterStructures.auto;
     }
   };
-  exports2.AbstractMessageType = AbstractMessageType;
-  var RequestType0 = class extends AbstractMessageType {
+  exports2.AbstractMessageSignature = AbstractMessageSignature;
+  var RequestType0 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 0);
     }
   };
   exports2.RequestType0 = RequestType0;
-  var RequestType = class extends AbstractMessageType {
-    constructor(method) {
+  var RequestType = class extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
       super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
     }
   };
   exports2.RequestType = RequestType;
-  var RequestType1 = class extends AbstractMessageType {
-    constructor(method) {
+  var RequestType1 = class extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
       super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
     }
   };
   exports2.RequestType1 = RequestType1;
-  var RequestType2 = class extends AbstractMessageType {
+  var RequestType2 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 2);
     }
   };
   exports2.RequestType2 = RequestType2;
-  var RequestType3 = class extends AbstractMessageType {
+  var RequestType3 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 3);
     }
   };
   exports2.RequestType3 = RequestType3;
-  var RequestType4 = class extends AbstractMessageType {
+  var RequestType4 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 4);
     }
   };
   exports2.RequestType4 = RequestType4;
-  var RequestType5 = class extends AbstractMessageType {
+  var RequestType5 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 5);
     }
   };
   exports2.RequestType5 = RequestType5;
-  var RequestType6 = class extends AbstractMessageType {
+  var RequestType6 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 6);
     }
   };
   exports2.RequestType6 = RequestType6;
-  var RequestType7 = class extends AbstractMessageType {
+  var RequestType7 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 7);
     }
   };
   exports2.RequestType7 = RequestType7;
-  var RequestType8 = class extends AbstractMessageType {
+  var RequestType8 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 8);
     }
   };
   exports2.RequestType8 = RequestType8;
-  var RequestType9 = class extends AbstractMessageType {
+  var RequestType9 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 9);
     }
   };
   exports2.RequestType9 = RequestType9;
-  var NotificationType = class extends AbstractMessageType {
-    constructor(method) {
+  var NotificationType = class extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
       super(method, 1);
-      this._ = void 0;
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
     }
   };
   exports2.NotificationType = NotificationType;
-  var NotificationType0 = class extends AbstractMessageType {
+  var NotificationType0 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 0);
     }
   };
   exports2.NotificationType0 = NotificationType0;
-  var NotificationType1 = class extends AbstractMessageType {
-    constructor(method) {
+  var NotificationType1 = class extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
       super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
     }
   };
   exports2.NotificationType1 = NotificationType1;
-  var NotificationType2 = class extends AbstractMessageType {
+  var NotificationType2 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 2);
     }
   };
   exports2.NotificationType2 = NotificationType2;
-  var NotificationType3 = class extends AbstractMessageType {
+  var NotificationType3 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 3);
     }
   };
   exports2.NotificationType3 = NotificationType3;
-  var NotificationType4 = class extends AbstractMessageType {
+  var NotificationType4 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 4);
     }
   };
   exports2.NotificationType4 = NotificationType4;
-  var NotificationType5 = class extends AbstractMessageType {
+  var NotificationType5 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 5);
     }
   };
   exports2.NotificationType5 = NotificationType5;
-  var NotificationType6 = class extends AbstractMessageType {
+  var NotificationType6 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 6);
     }
   };
   exports2.NotificationType6 = NotificationType6;
-  var NotificationType7 = class extends AbstractMessageType {
+  var NotificationType7 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 7);
     }
   };
   exports2.NotificationType7 = NotificationType7;
-  var NotificationType8 = class extends AbstractMessageType {
+  var NotificationType8 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 8);
     }
   };
   exports2.NotificationType8 = NotificationType8;
-  var NotificationType9 = class extends AbstractMessageType {
+  var NotificationType9 = class extends AbstractMessageSignature {
     constructor(method) {
       super(method, 9);
     }
   };
   exports2.NotificationType9 = NotificationType9;
   function isRequestMessage(message) {
-    let candidate = message;
+    const candidate = message;
     return candidate && is2.string(candidate.method) && (is2.string(candidate.id) || is2.number(candidate.id));
   }
   exports2.isRequestMessage = isRequestMessage;
   function isNotificationMessage(message) {
-    let candidate = message;
+    const candidate = message;
     return candidate && is2.string(candidate.method) && message.id === void 0;
   }
   exports2.isNotificationMessage = isNotificationMessage;
   function isResponseMessage(message) {
-    let candidate = message;
+    const candidate = message;
     return candidate && (candidate.result !== void 0 || !!candidate.error) && (is2.string(candidate.id) || is2.number(candidate.id) || candidate.id === null);
   }
   exports2.isResponseMessage = isResponseMessage;
 });
 
-// node_modules/vscode-jsonrpc/lib/events.js
+// node_modules/vscode-jsonrpc/lib/common/events.js
 var require_events = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var Disposable12;
-  (function(Disposable13) {
-    function create(func) {
-      return {
-        dispose: func
-      };
-    }
-    Disposable13.create = create;
-  })(Disposable12 = exports2.Disposable || (exports2.Disposable = {}));
+  exports2.Emitter = exports2.Event = void 0;
+  var ral_1 = require_ral();
   var Event5;
   (function(Event6) {
     const _disposable = {dispose() {
@@ -303,8 +667,8 @@ var require_events = __commonJS((exports2) => {
       if (!this._callbacks) {
         return;
       }
-      var foundCallbackWithDifferentContext = false;
-      for (var i = 0, len = this._callbacks.length; i < len; i++) {
+      let foundCallbackWithDifferentContext = false;
+      for (let i = 0, len = this._callbacks.length; i < len; i++) {
         if (this._callbacks[i] === callback) {
           if (this._contexts[i] === context) {
             this._callbacks.splice(i, 1);
@@ -323,12 +687,12 @@ var require_events = __commonJS((exports2) => {
       if (!this._callbacks) {
         return [];
       }
-      var ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
-      for (var i = 0, len = callbacks.length; i < len; i++) {
+      const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+      for (let i = 0, len = callbacks.length; i < len; i++) {
         try {
           ret.push(callbacks[i].apply(contexts[i], args));
         } catch (e) {
-          console.error(e);
+          ral_1.default().console.error(e);
         }
       }
       return ret;
@@ -355,9 +719,11 @@ var require_events = __commonJS((exports2) => {
             this._options.onFirstListenerAdd(this);
           }
           this._callbacks.add(listener, thisArgs);
-          let result;
-          result = {
+          const result = {
             dispose: () => {
+              if (!this._callbacks) {
+                return;
+              }
               this._callbacks.remove(listener, thisArgs);
               result.dispose = Emitter6._noop;
               if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
@@ -390,82 +756,101 @@ var require_events = __commonJS((exports2) => {
   };
 });
 
-// node_modules/vscode-jsonrpc/lib/messageReader.js
-var require_messageReader = __commonJS((exports2) => {
+// node_modules/vscode-jsonrpc/lib/common/cancellation.js
+var require_cancellation = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var events_1 = require_events();
+  exports2.CancellationTokenSource = exports2.CancellationToken = void 0;
+  var ral_1 = require_ral();
   var Is = require_is();
-  var DefaultSize2 = 8192;
-  var CR = Buffer.from("\r", "ascii")[0];
-  var LF = Buffer.from("\n", "ascii")[0];
-  var CRLF = "\r\n";
-  var MessageBuffer = class {
-    constructor(encoding = "utf8") {
-      this.encoding = encoding;
-      this.index = 0;
-      this.buffer = Buffer.allocUnsafe(DefaultSize2);
+  var events_1 = require_events();
+  var CancellationToken20;
+  (function(CancellationToken21) {
+    CancellationToken21.None = Object.freeze({
+      isCancellationRequested: false,
+      onCancellationRequested: events_1.Event.None
+    });
+    CancellationToken21.Cancelled = Object.freeze({
+      isCancellationRequested: true,
+      onCancellationRequested: events_1.Event.None
+    });
+    function is2(value) {
+      const candidate = value;
+      return candidate && (candidate === CancellationToken21.None || candidate === CancellationToken21.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
     }
-    append(chunk) {
-      var toAppend = chunk;
-      if (typeof chunk === "string") {
-        var str = chunk;
-        var bufferLen = Buffer.byteLength(str, this.encoding);
-        toAppend = Buffer.allocUnsafe(bufferLen);
-        toAppend.write(str, 0, bufferLen, this.encoding);
-      }
-      if (this.buffer.length - this.index >= toAppend.length) {
-        toAppend.copy(this.buffer, this.index, 0, toAppend.length);
-      } else {
-        var newSize = (Math.ceil((this.index + toAppend.length) / DefaultSize2) + 1) * DefaultSize2;
-        if (this.index === 0) {
-          this.buffer = Buffer.allocUnsafe(newSize);
-          toAppend.copy(this.buffer, 0, 0, toAppend.length);
-        } else {
-          this.buffer = Buffer.concat([this.buffer.slice(0, this.index), toAppend], newSize);
+    CancellationToken21.is = is2;
+  })(CancellationToken20 = exports2.CancellationToken || (exports2.CancellationToken = {}));
+  var shortcutEvent = Object.freeze(function(callback, context) {
+    const handle = ral_1.default().timer.setTimeout(callback.bind(context), 0);
+    return {dispose() {
+      ral_1.default().timer.clearTimeout(handle);
+    }};
+  });
+  var MutableToken = class {
+    constructor() {
+      this._isCancelled = false;
+    }
+    cancel() {
+      if (!this._isCancelled) {
+        this._isCancelled = true;
+        if (this._emitter) {
+          this._emitter.fire(void 0);
+          this.dispose();
         }
       }
-      this.index += toAppend.length;
     }
-    tryReadHeaders() {
-      let result = void 0;
-      let current = 0;
-      while (current + 3 < this.index && (this.buffer[current] !== CR || this.buffer[current + 1] !== LF || this.buffer[current + 2] !== CR || this.buffer[current + 3] !== LF)) {
-        current++;
+    get isCancellationRequested() {
+      return this._isCancelled;
+    }
+    get onCancellationRequested() {
+      if (this._isCancelled) {
+        return shortcutEvent;
       }
-      if (current + 3 >= this.index) {
-        return result;
+      if (!this._emitter) {
+        this._emitter = new events_1.Emitter();
       }
-      result = Object.create(null);
-      let headers = this.buffer.toString("ascii", 0, current).split(CRLF);
-      headers.forEach((header) => {
-        let index = header.indexOf(":");
-        if (index === -1) {
-          throw new Error("Message header must separate key and value using :");
-        }
-        let key = header.substr(0, index);
-        let value = header.substr(index + 1).trim();
-        result[key] = value;
-      });
-      let nextStart = current + 4;
-      this.buffer = this.buffer.slice(nextStart);
-      this.index = this.index - nextStart;
-      return result;
+      return this._emitter.event;
     }
-    tryReadContent(length) {
-      if (this.index < length) {
-        return null;
+    dispose() {
+      if (this._emitter) {
+        this._emitter.dispose();
+        this._emitter = void 0;
       }
-      let result = this.buffer.toString(this.encoding, 0, length);
-      let nextStart = length;
-      this.buffer.copy(this.buffer, 0, nextStart);
-      this.index = this.index - nextStart;
-      return result;
     }
-    get numberOfBytes() {
-      return this.index;
+  };
+  var CancellationTokenSource4 = class {
+    get token() {
+      if (!this._token) {
+        this._token = new MutableToken();
+      }
+      return this._token;
+    }
+    cancel() {
+      if (!this._token) {
+        this._token = CancellationToken20.Cancelled;
+      } else {
+        this._token.cancel();
+      }
+    }
+    dispose() {
+      if (!this._token) {
+        this._token = CancellationToken20.None;
+      } else if (this._token instanceof MutableToken) {
+        this._token.dispose();
+      }
     }
   };
+  exports2.CancellationTokenSource = CancellationTokenSource4;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageReader.js
+var require_messageReader = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.ReadableStreamMessageReader = exports2.AbstractMessageReader = exports2.MessageReader = void 0;
+  var ral_1 = require_ral();
+  var Is = require_is();
+  var events_1 = require_events();
   var MessageReader;
   (function(MessageReader2) {
     function is2(value) {
@@ -511,12 +896,56 @@ var require_messageReader = __commonJS((exports2) => {
     }
   };
   exports2.AbstractMessageReader = AbstractMessageReader;
-  var StreamMessageReader = class extends AbstractMessageReader {
-    constructor(readable, encoding = "utf8") {
+  var ResolvedMessageReaderOptions;
+  (function(ResolvedMessageReaderOptions2) {
+    function fromOptions(options) {
+      var _a;
+      let charset;
+      let result;
+      let contentDecoder;
+      const contentDecoders = new Map();
+      let contentTypeDecoder;
+      const contentTypeDecoders = new Map();
+      if (options === void 0 || typeof options === "string") {
+        charset = options !== null && options !== void 0 ? options : "utf-8";
+      } else {
+        charset = (_a = options.charset) !== null && _a !== void 0 ? _a : "utf-8";
+        if (options.contentDecoder !== void 0) {
+          contentDecoder = options.contentDecoder;
+          contentDecoders.set(contentDecoder.name, contentDecoder);
+        }
+        if (options.contentDecoders !== void 0) {
+          for (const decoder of options.contentDecoders) {
+            contentDecoders.set(decoder.name, decoder);
+          }
+        }
+        if (options.contentTypeDecoder !== void 0) {
+          contentTypeDecoder = options.contentTypeDecoder;
+          contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+        }
+        if (options.contentTypeDecoders !== void 0) {
+          for (const decoder of options.contentTypeDecoders) {
+            contentTypeDecoders.set(decoder.name, decoder);
+          }
+        }
+      }
+      if (contentTypeDecoder === void 0) {
+        contentTypeDecoder = ral_1.default().applicationJson.decoder;
+        contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+      }
+      return {charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders};
+    }
+    ResolvedMessageReaderOptions2.fromOptions = fromOptions;
+  })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
+  var ReadableStreamMessageReader = class extends AbstractMessageReader {
+    constructor(readable, options) {
       super();
       this.readable = readable;
-      this.buffer = new MessageBuffer(encoding);
+      this.options = ResolvedMessageReaderOptions.fromOptions(options);
+      this.buffer = ral_1.default().messageBuffer.create(this.options.charset);
       this._partialMessageTimeout = 1e4;
+      this.nextMessageLength = -1;
+      this.messageToken = 0;
     }
     set partialMessageTimeout(timeout) {
       this._partialMessageTimeout = timeout;
@@ -529,45 +958,58 @@ var require_messageReader = __commonJS((exports2) => {
       this.messageToken = 0;
       this.partialMessageTimer = void 0;
       this.callback = callback;
-      this.readable.on("data", (data) => {
+      const result = this.readable.onData((data) => {
         this.onData(data);
       });
-      this.readable.on("error", (error) => this.fireError(error));
-      this.readable.on("close", () => this.fireClose());
+      this.readable.onError((error) => this.fireError(error));
+      this.readable.onClose(() => this.fireClose());
+      return result;
     }
     onData(data) {
       this.buffer.append(data);
       while (true) {
         if (this.nextMessageLength === -1) {
-          let headers = this.buffer.tryReadHeaders();
+          const headers = this.buffer.tryReadHeaders();
           if (!headers) {
             return;
           }
-          let contentLength = headers["Content-Length"];
+          const contentLength = headers.get("Content-Length");
           if (!contentLength) {
             throw new Error("Header must provide a Content-Length property.");
           }
-          let length = parseInt(contentLength);
+          const length = parseInt(contentLength);
           if (isNaN(length)) {
             throw new Error("Content-Length value must be a number.");
           }
           this.nextMessageLength = length;
         }
-        var msg = this.buffer.tryReadContent(this.nextMessageLength);
-        if (msg === null) {
+        const body = this.buffer.tryReadBody(this.nextMessageLength);
+        if (body === void 0) {
           this.setPartialMessageTimer();
           return;
         }
         this.clearPartialMessageTimer();
         this.nextMessageLength = -1;
-        this.messageToken++;
-        var json = JSON.parse(msg);
-        this.callback(json);
+        let p;
+        if (this.options.contentDecoder !== void 0) {
+          p = this.options.contentDecoder.decode(body);
+        } else {
+          p = Promise.resolve(body);
+        }
+        p.then((value) => {
+          this.options.contentTypeDecoder.decode(value, this.options).then((msg) => {
+            this.callback(msg);
+          }, (error) => {
+            this.fireError(error);
+          });
+        }, (error) => {
+          this.fireError(error);
+        });
       }
     }
     clearPartialMessageTimer() {
       if (this.partialMessageTimer) {
-        clearTimeout(this.partialMessageTimer);
+        ral_1.default().timer.clearTimeout(this.partialMessageTimer);
         this.partialMessageTimer = void 0;
       }
     }
@@ -576,7 +1018,7 @@ var require_messageReader = __commonJS((exports2) => {
       if (this._partialMessageTimeout <= 0) {
         return;
       }
-      this.partialMessageTimer = setTimeout((token, timeout) => {
+      this.partialMessageTimer = ral_1.default().timer.setTimeout((token, timeout) => {
         this.partialMessageTimer = void 0;
         if (token === this.messageToken) {
           this.firePartialMessage({messageToken: token, waitingTime: timeout});
@@ -585,34 +1027,84 @@ var require_messageReader = __commonJS((exports2) => {
       }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
     }
   };
-  exports2.StreamMessageReader = StreamMessageReader;
-  var IPCMessageReader = class extends AbstractMessageReader {
-    constructor(process2) {
-      super();
-      this.process = process2;
-      let eventEmitter = this.process;
-      eventEmitter.on("error", (error) => this.fireError(error));
-      eventEmitter.on("close", () => this.fireClose());
+  exports2.ReadableStreamMessageReader = ReadableStreamMessageReader;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/semaphore.js
+var require_semaphore = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.Semaphore = void 0;
+  var ral_1 = require_ral();
+  var Semaphore = class {
+    constructor(capacity = 1) {
+      if (capacity <= 0) {
+        throw new Error("Capacity must be greater than 0");
+      }
+      this._capacity = capacity;
+      this._active = 0;
+      this._waiting = [];
+    }
+    lock(thunk) {
+      return new Promise((resolve, reject) => {
+        this._waiting.push({thunk, resolve, reject});
+        this.runNext();
+      });
     }
-    listen(callback) {
-      this.process.on("message", callback);
+    get active() {
+      return this._active;
     }
-  };
-  exports2.IPCMessageReader = IPCMessageReader;
-  var SocketMessageReader = class extends StreamMessageReader {
-    constructor(socket, encoding = "utf-8") {
-      super(socket, encoding);
+    runNext() {
+      if (this._waiting.length === 0 || this._active === this._capacity) {
+        return;
+      }
+      ral_1.default().timer.setImmediate(() => this.doRunNext());
+    }
+    doRunNext() {
+      if (this._waiting.length === 0 || this._active === this._capacity) {
+        return;
+      }
+      const next = this._waiting.shift();
+      this._active++;
+      if (this._active > this._capacity) {
+        throw new Error(`To many thunks active`);
+      }
+      try {
+        const result = next.thunk();
+        if (result instanceof Promise) {
+          result.then((value) => {
+            this._active--;
+            next.resolve(value);
+            this.runNext();
+          }, (err) => {
+            this._active--;
+            next.reject(err);
+            this.runNext();
+          });
+        } else {
+          this._active--;
+          next.resolve(result);
+          this.runNext();
+        }
+      } catch (err) {
+        this._active--;
+        next.reject(err);
+        this.runNext();
+      }
     }
   };
-  exports2.SocketMessageReader = SocketMessageReader;
+  exports2.Semaphore = Semaphore;
 });
 
-// node_modules/vscode-jsonrpc/lib/messageWriter.js
+// node_modules/vscode-jsonrpc/lib/common/messageWriter.js
 var require_messageWriter = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var events_1 = require_events();
+  exports2.WriteableStreamMessageWriter = exports2.AbstractMessageWriter = exports2.MessageWriter = void 0;
+  var ral_1 = require_ral();
   var Is = require_is();
+  var semaphore_1 = require_semaphore();
+  var events_1 = require_events();
   var ContentLength2 = "Content-Length: ";
   var CRLF = "\r\n";
   var MessageWriter;
@@ -653,249 +1145,96 @@ var require_messageWriter = __commonJS((exports2) => {
     }
   };
   exports2.AbstractMessageWriter = AbstractMessageWriter;
-  var StreamMessageWriter = class extends AbstractMessageWriter {
-    constructor(writable, encoding = "utf8") {
+  var ResolvedMessageWriterOptions;
+  (function(ResolvedMessageWriterOptions2) {
+    function fromOptions(options) {
+      var _a, _b;
+      if (options === void 0 || typeof options === "string") {
+        return {charset: options !== null && options !== void 0 ? options : "utf-8", contentTypeEncoder: ral_1.default().applicationJson.encoder};
+      } else {
+        return {charset: (_a = options.charset) !== null && _a !== void 0 ? _a : "utf-8", contentEncoder: options.contentEncoder, contentTypeEncoder: (_b = options.contentTypeEncoder) !== null && _b !== void 0 ? _b : ral_1.default().applicationJson.encoder};
+      }
+    }
+    ResolvedMessageWriterOptions2.fromOptions = fromOptions;
+  })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
+  var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
+    constructor(writable, options) {
       super();
       this.writable = writable;
-      this.encoding = encoding;
+      this.options = ResolvedMessageWriterOptions.fromOptions(options);
       this.errorCount = 0;
-      this.writable.on("error", (error) => this.fireError(error));
-      this.writable.on("close", () => this.fireClose());
-    }
-    write(msg) {
-      let json = JSON.stringify(msg);
-      let contentLength = Buffer.byteLength(json, this.encoding);
-      let headers = [
-        ContentLength2,
-        contentLength.toString(),
-        CRLF,
-        CRLF
-      ];
-      try {
-        this.writable.write(headers.join(""), "ascii");
-        this.writable.write(json, this.encoding);
-        this.errorCount = 0;
-      } catch (error) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-      }
-    }
-  };
-  exports2.StreamMessageWriter = StreamMessageWriter;
-  var IPCMessageWriter = class extends AbstractMessageWriter {
-    constructor(process2) {
-      super();
-      this.process = process2;
-      this.errorCount = 0;
-      this.queue = [];
-      this.sending = false;
-      let eventEmitter = this.process;
-      eventEmitter.on("error", (error) => this.fireError(error));
-      eventEmitter.on("close", () => this.fireClose);
-    }
-    write(msg) {
-      if (!this.sending && this.queue.length === 0) {
-        this.doWriteMessage(msg);
-      } else {
-        this.queue.push(msg);
-      }
-    }
-    doWriteMessage(msg) {
-      try {
-        if (this.process.send) {
-          this.sending = true;
-          this.process.send(msg, void 0, void 0, (error) => {
-            this.sending = false;
-            if (error) {
-              this.errorCount++;
-              this.fireError(error, msg, this.errorCount);
-            } else {
-              this.errorCount = 0;
-            }
-            if (this.queue.length > 0) {
-              this.doWriteMessage(this.queue.shift());
-            }
-          });
-        }
-      } catch (error) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-      }
-    }
-  };
-  exports2.IPCMessageWriter = IPCMessageWriter;
-  var SocketMessageWriter = class extends AbstractMessageWriter {
-    constructor(socket, encoding = "utf8") {
-      super();
-      this.socket = socket;
-      this.queue = [];
-      this.sending = false;
-      this.encoding = encoding;
-      this.errorCount = 0;
-      this.socket.on("error", (error) => this.fireError(error));
-      this.socket.on("close", () => this.fireClose());
-    }
-    dispose() {
-      super.dispose();
-      this.socket.destroy();
-    }
-    write(msg) {
-      if (!this.sending && this.queue.length === 0) {
-        this.doWriteMessage(msg);
-      } else {
-        this.queue.push(msg);
-      }
-    }
-    doWriteMessage(msg) {
-      let json = JSON.stringify(msg);
-      let contentLength = Buffer.byteLength(json, this.encoding);
-      let headers = [
-        ContentLength2,
-        contentLength.toString(),
-        CRLF,
-        CRLF
-      ];
-      try {
-        this.sending = true;
-        this.socket.write(headers.join(""), "ascii", (error) => {
-          if (error) {
-            this.handleError(error, msg);
-          }
-          try {
-            this.socket.write(json, this.encoding, (error2) => {
-              this.sending = false;
-              if (error2) {
-                this.handleError(error2, msg);
-              } else {
-                this.errorCount = 0;
-              }
-              if (this.queue.length > 0) {
-                this.doWriteMessage(this.queue.shift());
-              }
-            });
-          } catch (error2) {
-            this.handleError(error2, msg);
+      this.writeSemaphore = new semaphore_1.Semaphore(1);
+      this.writable.onError((error) => this.fireError(error));
+      this.writable.onClose(() => this.fireClose());
+    }
+    async write(msg) {
+      return this.writeSemaphore.lock(async () => {
+        const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
+          if (this.options.contentEncoder !== void 0) {
+            return this.options.contentEncoder.encode(buffer);
+          } else {
+            return buffer;
           }
         });
+        return payload.then((buffer) => {
+          const headers = [];
+          headers.push(ContentLength2, buffer.byteLength.toString(), CRLF);
+          headers.push(CRLF);
+          return this.doWrite(msg, headers, buffer);
+        }, (error) => {
+          this.fireError(error);
+          throw error;
+        });
+      });
+    }
+    async doWrite(msg, headers, data) {
+      try {
+        await this.writable.write(headers.join(""), "ascii");
+        return this.writable.write(data);
       } catch (error) {
         this.handleError(error, msg);
+        return Promise.reject(error);
       }
     }
     handleError(error, msg) {
       this.errorCount++;
       this.fireError(error, msg, this.errorCount);
     }
-  };
-  exports2.SocketMessageWriter = SocketMessageWriter;
-});
-
-// node_modules/vscode-jsonrpc/lib/cancellation.js
-var require_cancellation = __commonJS((exports2) => {
-  "use strict";
-  Object.defineProperty(exports2, "__esModule", {value: true});
-  var events_1 = require_events();
-  var Is = require_is();
-  var CancellationToken19;
-  (function(CancellationToken20) {
-    CancellationToken20.None = Object.freeze({
-      isCancellationRequested: false,
-      onCancellationRequested: events_1.Event.None
-    });
-    CancellationToken20.Cancelled = Object.freeze({
-      isCancellationRequested: true,
-      onCancellationRequested: events_1.Event.None
-    });
-    function is2(value) {
-      let candidate = value;
-      return candidate && (candidate === CancellationToken20.None || candidate === CancellationToken20.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
-    }
-    CancellationToken20.is = is2;
-  })(CancellationToken19 = exports2.CancellationToken || (exports2.CancellationToken = {}));
-  var shortcutEvent = Object.freeze(function(callback, context) {
-    let handle = setTimeout(callback.bind(context), 0);
-    return {dispose() {
-      clearTimeout(handle);
-    }};
-  });
-  var MutableToken = class {
-    constructor() {
-      this._isCancelled = false;
-    }
-    cancel() {
-      if (!this._isCancelled) {
-        this._isCancelled = true;
-        if (this._emitter) {
-          this._emitter.fire(void 0);
-          this.dispose();
-        }
-      }
-    }
-    get isCancellationRequested() {
-      return this._isCancelled;
-    }
-    get onCancellationRequested() {
-      if (this._isCancelled) {
-        return shortcutEvent;
-      }
-      if (!this._emitter) {
-        this._emitter = new events_1.Emitter();
-      }
-      return this._emitter.event;
-    }
-    dispose() {
-      if (this._emitter) {
-        this._emitter.dispose();
-        this._emitter = void 0;
-      }
-    }
-  };
-  var CancellationTokenSource3 = class {
-    get token() {
-      if (!this._token) {
-        this._token = new MutableToken();
-      }
-      return this._token;
-    }
-    cancel() {
-      if (!this._token) {
-        this._token = CancellationToken19.Cancelled;
-      } else {
-        this._token.cancel();
-      }
-    }
-    dispose() {
-      if (!this._token) {
-        this._token = CancellationToken19.None;
-      } else if (this._token instanceof MutableToken) {
-        this._token.dispose();
-      }
+    end() {
+      this.writable.end();
     }
   };
-  exports2.CancellationTokenSource = CancellationTokenSource3;
+  exports2.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
 });
 
-// node_modules/vscode-jsonrpc/lib/linkedMap.js
+// node_modules/vscode-jsonrpc/lib/common/linkedMap.js
 var require_linkedMap = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.LRUCache = exports2.LinkedMap = exports2.Touch = void 0;
   var Touch;
   (function(Touch2) {
     Touch2.None = 0;
     Touch2.First = 1;
+    Touch2.AsOld = Touch2.First;
     Touch2.Last = 2;
+    Touch2.AsNew = Touch2.Last;
   })(Touch = exports2.Touch || (exports2.Touch = {}));
   var LinkedMap = class {
     constructor() {
+      this[Symbol.toStringTag] = "LinkedMap";
       this._map = new Map();
       this._head = void 0;
       this._tail = void 0;
       this._size = 0;
+      this._state = 0;
     }
     clear() {
       this._map.clear();
       this._head = void 0;
       this._tail = void 0;
       this._size = 0;
+      this._state++;
     }
     isEmpty() {
       return !this._head && !this._tail;
@@ -903,14 +1242,25 @@ var require_linkedMap = __commonJS((exports2) => {
     get size() {
       return this._size;
     }
+    get first() {
+      var _a;
+      return (_a = this._head) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    get last() {
+      var _a;
+      return (_a = this._tail) === null || _a === void 0 ? void 0 : _a.value;
+    }
     has(key) {
       return this._map.has(key);
     }
-    get(key) {
+    get(key, touch = Touch.None) {
       const item = this._map.get(key);
       if (!item) {
         return void 0;
       }
+      if (touch !== Touch.None) {
+        this.touch(item, touch);
+      }
       return item.value;
     }
     set(key, value, touch = Touch.None) {
@@ -939,16 +1289,20 @@ var require_linkedMap = __commonJS((exports2) => {
         this._map.set(key, item);
         this._size++;
       }
+      return this;
     }
     delete(key) {
+      return !!this.remove(key);
+    }
+    remove(key) {
       const item = this._map.get(key);
       if (!item) {
-        return false;
+        return void 0;
       }
       this._map.delete(key);
       this.removeItem(item);
       this._size--;
-      return true;
+      return item.value;
     }
     shift() {
       if (!this._head && !this._tail) {
@@ -964,6 +1318,7 @@ var require_linkedMap = __commonJS((exports2) => {
       return item.value;
     }
     forEach(callbackfn, thisArg) {
+      const state = this._state;
       let current = this._head;
       while (current) {
         if (thisArg) {
@@ -971,37 +1326,105 @@ var require_linkedMap = __commonJS((exports2) => {
         } else {
           callbackfn(current.value, current.key, this);
         }
+        if (this._state !== state) {
+          throw new Error(`LinkedMap got modified during iteration.`);
+        }
         current = current.next;
       }
     }
-    forEachReverse(callbackfn, thisArg) {
-      let current = this._tail;
-      while (current) {
-        if (thisArg) {
-          callbackfn.bind(thisArg)(current.value, current.key, this);
-        } else {
-          callbackfn(current.value, current.key, this);
+    keys() {
+      const map = this;
+      const state = this._state;
+      let current = this._head;
+      const iterator = {
+        [Symbol.iterator]() {
+          return iterator;
+        },
+        next() {
+          if (map._state !== state) {
+            throw new Error(`LinkedMap got modified during iteration.`);
+          }
+          if (current) {
+            const result = {value: current.key, done: false};
+            current = current.next;
+            return result;
+          } else {
+            return {value: void 0, done: true};
+          }
         }
-        current = current.previous;
-      }
+      };
+      return iterator;
     }
     values() {
-      let result = [];
+      const map = this;
+      const state = this._state;
       let current = this._head;
-      while (current) {
-        result.push(current.value);
-        current = current.next;
-      }
-      return result;
+      const iterator = {
+        [Symbol.iterator]() {
+          return iterator;
+        },
+        next() {
+          if (map._state !== state) {
+            throw new Error(`LinkedMap got modified during iteration.`);
+          }
+          if (current) {
+            const result = {value: current.value, done: false};
+            current = current.next;
+            return result;
+          } else {
+            return {value: void 0, done: true};
+          }
+        }
+      };
+      return iterator;
     }
-    keys() {
-      let result = [];
+    entries() {
+      const map = this;
+      const state = this._state;
       let current = this._head;
-      while (current) {
-        result.push(current.key);
+      const iterator = {
+        [Symbol.iterator]() {
+          return iterator;
+        },
+        next() {
+          if (map._state !== state) {
+            throw new Error(`LinkedMap got modified during iteration.`);
+          }
+          if (current) {
+            const result = {value: [current.key, current.value], done: false};
+            current = current.next;
+            return result;
+          } else {
+            return {value: void 0, done: true};
+          }
+        }
+      };
+      return iterator;
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    trimOld(newSize) {
+      if (newSize >= this.size) {
+        return;
+      }
+      if (newSize === 0) {
+        this.clear();
+        return;
+      }
+      let current = this._head;
+      let currentSize = this.size;
+      while (current && currentSize > newSize) {
+        this._map.delete(current.key);
         current = current.next;
+        currentSize--;
       }
-      return result;
+      this._head = current;
+      this._size = currentSize;
+      if (current) {
+        current.previous = void 0;
+      }
+      this._state++;
     }
     addItemFirst(item) {
       if (!this._head && !this._tail) {
@@ -1013,6 +1436,7 @@ var require_linkedMap = __commonJS((exports2) => {
         this._head.previous = item;
       }
       this._head = item;
+      this._state++;
     }
     addItemLast(item) {
       if (!this._head && !this._tail) {
@@ -1024,14 +1448,23 @@ var require_linkedMap = __commonJS((exports2) => {
         this._tail.next = item;
       }
       this._tail = item;
+      this._state++;
     }
     removeItem(item) {
       if (item === this._head && item === this._tail) {
         this._head = void 0;
         this._tail = void 0;
       } else if (item === this._head) {
+        if (!item.next) {
+          throw new Error("Invalid list");
+        }
+        item.next.previous = void 0;
         this._head = item.next;
       } else if (item === this._tail) {
+        if (!item.previous) {
+          throw new Error("Invalid list");
+        }
+        item.previous.next = void 0;
         this._tail = item.previous;
       } else {
         const next = item.next;
@@ -1042,6 +1475,9 @@ var require_linkedMap = __commonJS((exports2) => {
         next.previous = previous;
         previous.next = next;
       }
+      item.next = void 0;
+      item.previous = void 0;
+      this._state++;
     }
     touch(item, touch) {
       if (!this._head || !this._tail) {
@@ -1067,6 +1503,7 @@ var require_linkedMap = __commonJS((exports2) => {
         item.next = this._head;
         this._head.previous = item;
         this._head = item;
+        this._state++;
       } else if (touch === Touch.Last) {
         if (item === this._tail) {
           return;
@@ -1084,163 +1521,75 @@ var require_linkedMap = __commonJS((exports2) => {
         item.previous = this._tail;
         this._tail.next = item;
         this._tail = item;
+        this._state++;
       }
     }
-  };
-  exports2.LinkedMap = LinkedMap;
-});
-
-// node_modules/vscode-jsonrpc/lib/pipeSupport.js
-var require_pipeSupport = __commonJS((exports2) => {
-  "use strict";
-  Object.defineProperty(exports2, "__esModule", {value: true});
-  var path_1 = require("path");
-  var os_1 = require("os");
-  var crypto_1 = require("crypto");
-  var net_1 = require("net");
-  var messageReader_1 = require_messageReader();
-  var messageWriter_1 = require_messageWriter();
-  function generateRandomPipeName() {
-    const randomSuffix = crypto_1.randomBytes(21).toString("hex");
-    if (process.platform === "win32") {
-      return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
-    } else {
-      return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`);
-    }
-  }
-  exports2.generateRandomPipeName = generateRandomPipeName;
-  function createClientPipeTransport(pipeName, encoding = "utf-8") {
-    let connectResolve;
-    let connected = new Promise((resolve, _reject) => {
-      connectResolve = resolve;
-    });
-    return new Promise((resolve, reject) => {
-      let server = net_1.createServer((socket) => {
-        server.close();
-        connectResolve([
-          new messageReader_1.SocketMessageReader(socket, encoding),
-          new messageWriter_1.SocketMessageWriter(socket, encoding)
-        ]);
+    toJSON() {
+      const data = [];
+      this.forEach((value, key) => {
+        data.push([key, value]);
       });
-      server.on("error", reject);
-      server.listen(pipeName, () => {
-        server.removeListener("error", reject);
-        resolve({
-          onConnected: () => {
-            return connected;
-          }
-        });
-      });
-    });
-  }
-  exports2.createClientPipeTransport = createClientPipeTransport;
-  function createServerPipeTransport(pipeName, encoding = "utf-8") {
-    const socket = net_1.createConnection(pipeName);
-    return [
-      new messageReader_1.SocketMessageReader(socket, encoding),
-      new messageWriter_1.SocketMessageWriter(socket, encoding)
-    ];
-  }
-  exports2.createServerPipeTransport = createServerPipeTransport;
-});
-
-// node_modules/vscode-jsonrpc/lib/socketSupport.js
-var require_socketSupport = __commonJS((exports2) => {
-  "use strict";
-  Object.defineProperty(exports2, "__esModule", {value: true});
-  var net_1 = require("net");
-  var messageReader_1 = require_messageReader();
-  var messageWriter_1 = require_messageWriter();
-  function createClientSocketTransport(port, encoding = "utf-8") {
-    let connectResolve;
-    let connected = new Promise((resolve, _reject) => {
-      connectResolve = resolve;
-    });
-    return new Promise((resolve, reject) => {
-      let server = net_1.createServer((socket) => {
-        server.close();
-        connectResolve([
-          new messageReader_1.SocketMessageReader(socket, encoding),
-          new messageWriter_1.SocketMessageWriter(socket, encoding)
-        ]);
-      });
-      server.on("error", reject);
-      server.listen(port, "127.0.0.1", () => {
-        server.removeListener("error", reject);
-        resolve({
-          onConnected: () => {
-            return connected;
-          }
-        });
-      });
-    });
-  }
-  exports2.createClientSocketTransport = createClientSocketTransport;
-  function createServerSocketTransport(port, encoding = "utf-8") {
-    const socket = net_1.createConnection(port, "127.0.0.1");
-    return [
-      new messageReader_1.SocketMessageReader(socket, encoding),
-      new messageWriter_1.SocketMessageWriter(socket, encoding)
-    ];
-  }
-  exports2.createServerSocketTransport = createServerSocketTransport;
+      return data;
+    }
+    fromJSON(data) {
+      this.clear();
+      for (const [key, value] of data) {
+        this.set(key, value);
+      }
+    }
+  };
+  exports2.LinkedMap = LinkedMap;
+  var LRUCache = class extends LinkedMap {
+    constructor(limit, ratio = 1) {
+      super();
+      this._limit = limit;
+      this._ratio = Math.min(Math.max(0, ratio), 1);
+    }
+    get limit() {
+      return this._limit;
+    }
+    set limit(limit) {
+      this._limit = limit;
+      this.checkTrim();
+    }
+    get ratio() {
+      return this._ratio;
+    }
+    set ratio(ratio) {
+      this._ratio = Math.min(Math.max(0, ratio), 1);
+      this.checkTrim();
+    }
+    get(key, touch = Touch.AsNew) {
+      return super.get(key, touch);
+    }
+    peek(key) {
+      return super.get(key, Touch.None);
+    }
+    set(key, value) {
+      super.set(key, value, Touch.Last);
+      this.checkTrim();
+      return this;
+    }
+    checkTrim() {
+      if (this.size > this._limit) {
+        this.trimOld(Math.round(this._limit * this._ratio));
+      }
+    }
+  };
+  exports2.LRUCache = LRUCache;
 });
 
-// node_modules/vscode-jsonrpc/lib/main.js
-var require_main = __commonJS((exports2) => {
+// node_modules/vscode-jsonrpc/lib/common/connection.js
+var require_connection = __commonJS((exports2) => {
   "use strict";
-  function __export2(m) {
-    for (var p in m)
-      if (!exports2.hasOwnProperty(p))
-        exports2[p] = m[p];
-  }
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.createMessageConnection = exports2.ConnectionOptions = exports2.CancellationStrategy = exports2.CancellationSenderStrategy = exports2.CancellationReceiverStrategy = exports2.ConnectionStrategy = exports2.ConnectionError = exports2.ConnectionErrors = exports2.LogTraceNotification = exports2.SetTraceNotification = exports2.TraceFormat = exports2.Trace = exports2.NullLogger = exports2.ProgressType = void 0;
+  var ral_1 = require_ral();
   var Is = require_is();
   var messages_1 = require_messages();
-  exports2.RequestType = messages_1.RequestType;
-  exports2.RequestType0 = messages_1.RequestType0;
-  exports2.RequestType1 = messages_1.RequestType1;
-  exports2.RequestType2 = messages_1.RequestType2;
-  exports2.RequestType3 = messages_1.RequestType3;
-  exports2.RequestType4 = messages_1.RequestType4;
-  exports2.RequestType5 = messages_1.RequestType5;
-  exports2.RequestType6 = messages_1.RequestType6;
-  exports2.RequestType7 = messages_1.RequestType7;
-  exports2.RequestType8 = messages_1.RequestType8;
-  exports2.RequestType9 = messages_1.RequestType9;
-  exports2.ResponseError = messages_1.ResponseError;
-  exports2.ErrorCodes = messages_1.ErrorCodes;
-  exports2.NotificationType = messages_1.NotificationType;
-  exports2.NotificationType0 = messages_1.NotificationType0;
-  exports2.NotificationType1 = messages_1.NotificationType1;
-  exports2.NotificationType2 = messages_1.NotificationType2;
-  exports2.NotificationType3 = messages_1.NotificationType3;
-  exports2.NotificationType4 = messages_1.NotificationType4;
-  exports2.NotificationType5 = messages_1.NotificationType5;
-  exports2.NotificationType6 = messages_1.NotificationType6;
-  exports2.NotificationType7 = messages_1.NotificationType7;
-  exports2.NotificationType8 = messages_1.NotificationType8;
-  exports2.NotificationType9 = messages_1.NotificationType9;
-  var messageReader_1 = require_messageReader();
-  exports2.MessageReader = messageReader_1.MessageReader;
-  exports2.StreamMessageReader = messageReader_1.StreamMessageReader;
-  exports2.IPCMessageReader = messageReader_1.IPCMessageReader;
-  exports2.SocketMessageReader = messageReader_1.SocketMessageReader;
-  var messageWriter_1 = require_messageWriter();
-  exports2.MessageWriter = messageWriter_1.MessageWriter;
-  exports2.StreamMessageWriter = messageWriter_1.StreamMessageWriter;
-  exports2.IPCMessageWriter = messageWriter_1.IPCMessageWriter;
-  exports2.SocketMessageWriter = messageWriter_1.SocketMessageWriter;
+  var linkedMap_1 = require_linkedMap();
   var events_1 = require_events();
-  exports2.Disposable = events_1.Disposable;
-  exports2.Event = events_1.Event;
-  exports2.Emitter = events_1.Emitter;
   var cancellation_1 = require_cancellation();
-  exports2.CancellationTokenSource = cancellation_1.CancellationTokenSource;
-  exports2.CancellationToken = cancellation_1.CancellationToken;
-  var linkedMap_1 = require_linkedMap();
-  __export2(require_pipeSupport());
-  __export2(require_socketSupport());
   var CancelNotification;
   (function(CancelNotification2) {
     CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
@@ -1254,6 +1603,13 @@ var require_main = __commonJS((exports2) => {
     }
   };
   exports2.ProgressType = ProgressType;
+  var StarRequestHandler;
+  (function(StarRequestHandler2) {
+    function is2(value) {
+      return Is.func(value);
+    }
+    StarRequestHandler2.is = is2;
+  })(StarRequestHandler || (StarRequestHandler = {}));
   exports2.NullLogger = Object.freeze({
     error: () => {
     },
@@ -1320,11 +1676,11 @@ var require_main = __commonJS((exports2) => {
   })(TraceFormat = exports2.TraceFormat || (exports2.TraceFormat = {}));
   var SetTraceNotification;
   (function(SetTraceNotification2) {
-    SetTraceNotification2.type = new messages_1.NotificationType("$/setTraceNotification");
+    SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
   })(SetTraceNotification = exports2.SetTraceNotification || (exports2.SetTraceNotification = {}));
   var LogTraceNotification;
   (function(LogTraceNotification2) {
-    LogTraceNotification2.type = new messages_1.NotificationType("$/logTraceNotification");
+    LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
   })(LogTraceNotification = exports2.LogTraceNotification || (exports2.LogTraceNotification = {}));
   var ConnectionErrors;
   (function(ConnectionErrors2) {
@@ -1343,11 +1699,59 @@ var require_main = __commonJS((exports2) => {
   var ConnectionStrategy;
   (function(ConnectionStrategy2) {
     function is2(value) {
-      let candidate = value;
+      const candidate = value;
       return candidate && Is.func(candidate.cancelUndispatched);
     }
     ConnectionStrategy2.is = is2;
   })(ConnectionStrategy = exports2.ConnectionStrategy || (exports2.ConnectionStrategy = {}));
+  var CancellationReceiverStrategy;
+  (function(CancellationReceiverStrategy2) {
+    CancellationReceiverStrategy2.Message = Object.freeze({
+      createCancellationTokenSource(_) {
+        return new cancellation_1.CancellationTokenSource();
+      }
+    });
+    function is2(value) {
+      const candidate = value;
+      return candidate && Is.func(candidate.createCancellationTokenSource);
+    }
+    CancellationReceiverStrategy2.is = is2;
+  })(CancellationReceiverStrategy = exports2.CancellationReceiverStrategy || (exports2.CancellationReceiverStrategy = {}));
+  var CancellationSenderStrategy;
+  (function(CancellationSenderStrategy2) {
+    CancellationSenderStrategy2.Message = Object.freeze({
+      sendCancellation(conn, id) {
+        conn.sendNotification(CancelNotification.type, {id});
+      },
+      cleanup(_) {
+      }
+    });
+    function is2(value) {
+      const candidate = value;
+      return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
+    }
+    CancellationSenderStrategy2.is = is2;
+  })(CancellationSenderStrategy = exports2.CancellationSenderStrategy || (exports2.CancellationSenderStrategy = {}));
+  var CancellationStrategy;
+  (function(CancellationStrategy2) {
+    CancellationStrategy2.Message = Object.freeze({
+      receiver: CancellationReceiverStrategy.Message,
+      sender: CancellationSenderStrategy.Message
+    });
+    function is2(value) {
+      const candidate = value;
+      return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
+    }
+    CancellationStrategy2.is = is2;
+  })(CancellationStrategy = exports2.CancellationStrategy || (exports2.CancellationStrategy = {}));
+  var ConnectionOptions;
+  (function(ConnectionOptions2) {
+    function is2(value) {
+      const candidate = value;
+      return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy));
+    }
+    ConnectionOptions2.is = is2;
+  })(ConnectionOptions = exports2.ConnectionOptions || (exports2.ConnectionOptions = {}));
   var ConnectionState;
   (function(ConnectionState2) {
     ConnectionState2[ConnectionState2["New"] = 1] = "New";
@@ -1355,16 +1759,17 @@ var require_main = __commonJS((exports2) => {
     ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
     ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
   })(ConnectionState || (ConnectionState = {}));
-  function _createMessageConnection(messageReader, messageWriter, logger, strategy) {
+  function createMessageConnection(messageReader, messageWriter, _logger, options) {
+    const logger = _logger !== void 0 ? _logger : exports2.NullLogger;
     let sequenceNumber = 0;
     let notificationSquenceNumber = 0;
     let unknownResponseSquenceNumber = 0;
     const version = "2.0";
     let starRequestHandler = void 0;
-    let requestHandlers = Object.create(null);
+    const requestHandlers = Object.create(null);
     let starNotificationHandler = void 0;
-    let notificationHandlers = Object.create(null);
-    let progressHandlers = new Map();
+    const notificationHandlers = Object.create(null);
+    const progressHandlers = new Map();
     let timer;
     let messageQueue = new linkedMap_1.LinkedMap();
     let responsePromises = Object.create(null);
@@ -1373,12 +1778,16 @@ var require_main = __commonJS((exports2) => {
     let traceFormat = TraceFormat.Text;
     let tracer;
     let state = ConnectionState.New;
-    let errorEmitter = new events_1.Emitter();
-    let closeEmitter = new events_1.Emitter();
-    let unhandledNotificationEmitter = new events_1.Emitter();
-    let unhandledProgressEmitter = new events_1.Emitter();
-    let disposeEmitter = new events_1.Emitter();
+    const errorEmitter = new events_1.Emitter();
+    const closeEmitter = new events_1.Emitter();
+    const unhandledNotificationEmitter = new events_1.Emitter();
+    const unhandledProgressEmitter = new events_1.Emitter();
+    const disposeEmitter = new events_1.Emitter();
+    const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
     function createRequestQueueKey(id) {
+      if (id === null) {
+        throw new Error(`Can't send requests with id null since the response can't be correlated.`);
+      }
       return "req-" + id.toString();
     }
     function createResponseQueueKey(id) {
@@ -1432,7 +1841,7 @@ var require_main = __commonJS((exports2) => {
       if (timer || messageQueue.size === 0) {
         return;
       }
-      timer = setImmediate(() => {
+      timer = ral_1.default().timer.setImmediate(() => {
         timer = void 0;
         processMessageQueue();
       });
@@ -1441,7 +1850,7 @@ var require_main = __commonJS((exports2) => {
       if (messageQueue.size === 0) {
         return;
       }
-      let message = messageQueue.shift();
+      const message = messageQueue.shift();
       try {
         if (messages_1.isRequestMessage(message)) {
           handleRequest(message);
@@ -1456,13 +1865,14 @@ var require_main = __commonJS((exports2) => {
         triggerMessageQueue();
       }
     }
-    let callback = (message) => {
+    const callback = (message) => {
       try {
         if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {
-          let key = createRequestQueueKey(message.params.id);
-          let toCancel = messageQueue.get(key);
+          const key = createRequestQueueKey(message.params.id);
+          const toCancel = messageQueue.get(key);
           if (messages_1.isRequestMessage(toCancel)) {
-            let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+            const strategy = options === null || options === void 0 ? void 0 : options.connectionStrategy;
+            const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
             if (response && (response.error !== void 0 || response.result !== void 0)) {
               messageQueue.delete(key);
               response.id = toCancel.id;
@@ -1482,7 +1892,7 @@ var require_main = __commonJS((exports2) => {
         return;
       }
       function reply(resultOrError, method, startTime2) {
-        let message = {
+        const message = {
           jsonrpc: version,
           id: requestMessage.id
         };
@@ -1495,7 +1905,7 @@ var require_main = __commonJS((exports2) => {
         messageWriter.write(message);
       }
       function replyError(error, method, startTime2) {
-        let message = {
+        const message = {
           jsonrpc: version,
           id: requestMessage.id,
           error: error.toJson()
@@ -1507,7 +1917,7 @@ var require_main = __commonJS((exports2) => {
         if (result === void 0) {
           result = null;
         }
-        let message = {
+        const message = {
           jsonrpc: version,
           id: requestMessage.id,
           result
@@ -1516,28 +1926,44 @@ var require_main = __commonJS((exports2) => {
         messageWriter.write(message);
       }
       traceReceivedRequest(requestMessage);
-      let element = requestHandlers[requestMessage.method];
+      const element = requestHandlers[requestMessage.method];
       let type;
       let requestHandler;
       if (element) {
         type = element.type;
         requestHandler = element.handler;
       }
-      let startTime = Date.now();
+      const startTime = Date.now();
       if (requestHandler || starRequestHandler) {
-        let cancellationSource = new cancellation_1.CancellationTokenSource();
-        let tokenKey = String(requestMessage.id);
+        const tokenKey = String(requestMessage.id);
+        const cancellationSource = cancellationStrategy.receiver.createCancellationTokenSource(tokenKey);
         requestTokens[tokenKey] = cancellationSource;
         try {
           let handlerResult;
-          if (requestMessage.params === void 0 || type !== void 0 && type.numberOfParams === 0) {
-            handlerResult = requestHandler ? requestHandler(cancellationSource.token) : starRequestHandler(requestMessage.method, cancellationSource.token);
-          } else if (Is.array(requestMessage.params) && (type === void 0 || type.numberOfParams > 1)) {
-            handlerResult = requestHandler ? requestHandler(...requestMessage.params, cancellationSource.token) : starRequestHandler(requestMessage.method, ...requestMessage.params, cancellationSource.token);
-          } else {
-            handlerResult = requestHandler ? requestHandler(requestMessage.params, cancellationSource.token) : starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
+          if (requestHandler) {
+            if (requestMessage.params === void 0) {
+              if (type !== void 0 && type.numberOfParams !== 0) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but recevied none.`), requestMessage.method, startTime);
+                return;
+              }
+              handlerResult = requestHandler(cancellationSource.token);
+            } else if (Array.isArray(requestMessage.params)) {
+              if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
+                return;
+              }
+              handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
+            } else {
+              if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
+                return;
+              }
+              handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
+            }
+          } else if (starRequestHandler) {
+            handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
           }
-          let promise = handlerResult;
+          const promise = handlerResult;
           if (!handlerResult) {
             delete requestTokens[tokenKey];
             replySuccess(handlerResult, requestMessage.method, startTime);
@@ -1585,14 +2011,14 @@ ${JSON.stringify(responseMessage.error, void 0, 4)}`);
           logger.error(`Received response message without id. No further error information provided.`);
         }
       } else {
-        let key = String(responseMessage.id);
-        let responsePromise = responsePromises[key];
+        const key = String(responseMessage.id);
+        const responsePromise = responsePromises[key];
         traceReceivedResponse(responseMessage, responsePromise);
         if (responsePromise) {
           delete responsePromises[key];
           try {
             if (responseMessage.error) {
-              let error = responseMessage.error;
+              const error = responseMessage.error;
               responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
             } else if (responseMessage.result !== void 0) {
               responsePromise.resolve(responseMessage.result);
@@ -1617,14 +2043,14 @@ ${JSON.stringify(responseMessage.error, void 0, 4)}`);
       let notificationHandler;
       if (message.method === CancelNotification.type.method) {
         notificationHandler = (params) => {
-          let id = params.id;
-          let source = requestTokens[String(id)];
+          const id = params.id;
+          const source = requestTokens[String(id)];
           if (source) {
             source.cancel();
           }
         };
       } else {
-        let element = notificationHandlers[message.method];
+        const element = notificationHandlers[message.method];
         if (element) {
           notificationHandler = element.handler;
           type = element.type;
@@ -1633,12 +2059,32 @@ ${JSON.stringify(responseMessage.error, void 0, 4)}`);
       if (notificationHandler || starNotificationHandler) {
         try {
           traceReceivedNotification(message);
-          if (message.params === void 0 || type !== void 0 && type.numberOfParams === 0) {
-            notificationHandler ? notificationHandler() : starNotificationHandler(message.method);
-          } else if (Is.array(message.params) && (type === void 0 || type.numberOfParams > 1)) {
-            notificationHandler ? notificationHandler(...message.params) : starNotificationHandler(message.method, ...message.params);
-          } else {
-            notificationHandler ? notificationHandler(message.params) : starNotificationHandler(message.method, message.params);
+          if (notificationHandler) {
+            if (message.params === void 0) {
+              if (type !== void 0) {
+                if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
+                  logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but recevied none.`);
+                }
+              }
+              notificationHandler();
+            } else if (Array.isArray(message.params)) {
+              if (type !== void 0) {
+                if (type.parameterStructures === messages_1.ParameterStructures.byName) {
+                  logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
+                }
+                if (type.numberOfParams !== message.params.length) {
+                  logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${message.params.length} argumennts`);
+                }
+              }
+              notificationHandler(...message.params);
+            } else {
+              if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+                logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
+              }
+              notificationHandler(message.params);
+            }
+          } else if (starNotificationHandler) {
+            starNotificationHandler(message.method, message.params);
           }
         } catch (error) {
           if (error.message) {
@@ -1658,10 +2104,10 @@ ${JSON.stringify(responseMessage.error, void 0, 4)}`);
       }
       logger.error(`Received message which is neither a response nor a notification message:
 ${JSON.stringify(message, null, 4)}`);
-      let responseMessage = message;
+      const responseMessage = message;
       if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
-        let key = String(responseMessage.id);
-        let responseHandler = responsePromises[key];
+        const key = String(responseMessage.id);
+        const responseHandler = responsePromises[key];
         if (responseHandler) {
           responseHandler.reject(new Error("The received response has neither a result nor an error property."));
         }
@@ -1787,7 +2233,7 @@ ${JSON.stringify(message, null, 4)}`);
           }
         }
         if (responsePromise) {
-          let error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
+          const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
           tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
         } else {
           tracer.log(`Received response ${message.id} without active response promise.`, data);
@@ -1833,15 +2279,45 @@ ${JSON.stringify(message, null, 4)}`);
         return param;
       }
     }
+    function nullToUndefined(param) {
+      if (param === null) {
+        return void 0;
+      } else {
+        return param;
+      }
+    }
+    function isNamedParam(param) {
+      return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
+    }
+    function computeSingleParam(parameterStructures, param) {
+      switch (parameterStructures) {
+        case messages_1.ParameterStructures.auto:
+          if (isNamedParam(param)) {
+            return nullToUndefined(param);
+          } else {
+            return [undefinedToNull(param)];
+          }
+          break;
+        case messages_1.ParameterStructures.byName:
+          if (!isNamedParam(param)) {
+            throw new Error(`Recevied parameters by name but param is not an object literal.`);
+          }
+          return nullToUndefined(param);
+        case messages_1.ParameterStructures.byPosition:
+          return [undefinedToNull(param)];
+        default:
+          throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
+      }
+    }
     function computeMessageParams(type, params) {
       let result;
-      let numberOfParams = type.numberOfParams;
+      const numberOfParams = type.numberOfParams;
       switch (numberOfParams) {
         case 0:
-          result = null;
+          result = void 0;
           break;
         case 1:
-          result = undefinedToNull(params[0]);
+          result = computeSingleParam(type.parameterStructures, params[0]);
           break;
         default:
           result = [];
@@ -1857,29 +2333,42 @@ ${JSON.stringify(message, null, 4)}`);
       }
       return result;
     }
-    let connection = {
-      sendNotification: (type, ...params) => {
+    const connection = {
+      sendNotification: (type, ...args) => {
         throwIfClosedOrDisposed();
         let method;
         let messageParams;
         if (Is.string(type)) {
           method = type;
-          switch (params.length) {
+          const first = args[0];
+          let paramStart = 0;
+          let parameterStructures = messages_1.ParameterStructures.auto;
+          if (messages_1.ParameterStructures.is(first)) {
+            paramStart = 1;
+            parameterStructures = first;
+          }
+          let paramEnd = args.length;
+          const numberOfParams = paramEnd - paramStart;
+          switch (numberOfParams) {
             case 0:
-              messageParams = null;
+              messageParams = void 0;
               break;
             case 1:
-              messageParams = params[0];
+              messageParams = computeSingleParam(parameterStructures, args[paramStart]);
               break;
             default:
-              messageParams = params;
+              if (parameterStructures === messages_1.ParameterStructures.byName) {
+                throw new Error(`Recevied ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
+              }
+              messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
               break;
           }
         } else {
+          const params = args;
           method = type.method;
           messageParams = computeMessageParams(type, params);
         }
-        let notificationMessage = {
+        const notificationMessage = {
           jsonrpc: version,
           method,
           params: messageParams
@@ -1889,15 +2378,27 @@ ${JSON.stringify(message, null, 4)}`);
       },
       onNotification: (type, handler) => {
         throwIfClosedOrDisposed();
+        let method;
         if (Is.func(type)) {
           starNotificationHandler = type;
         } else if (handler) {
           if (Is.string(type)) {
+            method = type;
             notificationHandlers[type] = {type: void 0, handler};
           } else {
+            method = type.method;
             notificationHandlers[type.method] = {type, handler};
           }
         }
+        return {
+          dispose: () => {
+            if (method !== void 0) {
+              delete notificationHandlers[method];
+            } else {
+              starNotificationHandler = void 0;
+            }
+          }
+        };
       },
       onProgress: (_type, token, handler) => {
         if (progressHandlers.has(token)) {
@@ -1914,7 +2415,7 @@ ${JSON.stringify(message, null, 4)}`);
         connection.sendNotification(ProgressNotification.type, {token, value});
       },
       onUnhandledProgress: unhandledProgressEmitter.event,
-      sendRequest: (type, ...params) => {
+      sendRequest: (type, ...args) => {
         throwIfClosedOrDisposed();
         throwIfNotListening();
         let method;
@@ -1922,47 +2423,66 @@ ${JSON.stringify(message, null, 4)}`);
         let token = void 0;
         if (Is.string(type)) {
           method = type;
-          switch (params.length) {
+          const first = args[0];
+          const last = args[args.length - 1];
+          let paramStart = 0;
+          let parameterStructures = messages_1.ParameterStructures.auto;
+          if (messages_1.ParameterStructures.is(first)) {
+            paramStart = 1;
+            parameterStructures = first;
+          }
+          let paramEnd = args.length;
+          if (cancellation_1.CancellationToken.is(last)) {
+            paramEnd = paramEnd - 1;
+            token = last;
+          }
+          const numberOfParams = paramEnd - paramStart;
+          switch (numberOfParams) {
             case 0:
-              messageParams = null;
+              messageParams = void 0;
               break;
             case 1:
-              if (cancellation_1.CancellationToken.is(params[0])) {
-                messageParams = null;
-                token = params[0];
-              } else {
-                messageParams = undefinedToNull(params[0]);
-              }
+              messageParams = computeSingleParam(parameterStructures, args[paramStart]);
               break;
             default:
-              const last = params.length - 1;
-              if (cancellation_1.CancellationToken.is(params[last])) {
-                token = params[last];
-                if (params.length === 2) {
-                  messageParams = undefinedToNull(params[0]);
-                } else {
-                  messageParams = params.slice(0, last).map((value) => undefinedToNull(value));
-                }
-              } else {
-                messageParams = params.map((value) => undefinedToNull(value));
+              if (parameterStructures === messages_1.ParameterStructures.byName) {
+                throw new Error(`Recevied ${numberOfParams} parameters for 'by Name' request parameter structure.`);
               }
+              messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
               break;
           }
         } else {
+          const params = args;
           method = type.method;
           messageParams = computeMessageParams(type, params);
-          let numberOfParams = type.numberOfParams;
+          const numberOfParams = type.numberOfParams;
           token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : void 0;
         }
-        let id = sequenceNumber++;
-        let result = new Promise((resolve, reject) => {
-          let requestMessage = {
+        const id = sequenceNumber++;
+        let disposable;
+        if (token) {
+          disposable = token.onCancellationRequested(() => {
+            cancellationStrategy.sender.sendCancellation(connection, id);
+          });
+        }
+        const result = new Promise((resolve, reject) => {
+          const requestMessage = {
             jsonrpc: version,
             id,
             method,
             params: messageParams
           };
-          let responsePromise = {method, timerStart: Date.now(), resolve, reject};
+          const resolveWithCleanup = (r) => {
+            resolve(r);
+            cancellationStrategy.sender.cleanup(id);
+            disposable === null || disposable === void 0 ? void 0 : disposable.dispose();
+          };
+          const rejectWithCleanup = (r) => {
+            reject(r);
+            cancellationStrategy.sender.cleanup(id);
+            disposable === null || disposable === void 0 ? void 0 : disposable.dispose();
+          };
+          let responsePromise = {method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup};
           traceSendingRequest(requestMessage);
           try {
             messageWriter.write(requestMessage);
@@ -1974,24 +2494,38 @@ ${JSON.stringify(message, null, 4)}`);
             responsePromises[String(id)] = responsePromise;
           }
         });
-        if (token) {
-          token.onCancellationRequested(() => {
-            connection.sendNotification(CancelNotification.type, {id});
-          });
-        }
         return result;
       },
       onRequest: (type, handler) => {
         throwIfClosedOrDisposed();
-        if (Is.func(type)) {
+        let method = null;
+        if (StarRequestHandler.is(type)) {
+          method = void 0;
           starRequestHandler = type;
-        } else if (handler) {
-          if (Is.string(type)) {
-            requestHandlers[type] = {type: void 0, handler};
-          } else {
+        } else if (Is.string(type)) {
+          method = null;
+          if (handler !== void 0) {
+            method = type;
+            requestHandlers[type] = {handler, type: void 0};
+          }
+        } else {
+          if (handler !== void 0) {
+            method = type.method;
             requestHandlers[type.method] = {type, handler};
           }
         }
+        return {
+          dispose: () => {
+            if (method === null) {
+              return;
+            }
+            if (method !== void 0) {
+              delete requestHandlers[method];
+            } else {
+              starRequestHandler = void 0;
+            }
+          }
+        };
       },
       trace: (_value, _tracer, sendNotificationOrTraceOptions) => {
         let _sendNotification = false;
@@ -2019,13 +2553,16 @@ ${JSON.stringify(message, null, 4)}`);
       onClose: closeEmitter.event,
       onUnhandledNotification: unhandledNotificationEmitter.event,
       onDispose: disposeEmitter.event,
+      end: () => {
+        messageWriter.end();
+      },
       dispose: () => {
         if (isDisposed()) {
           return;
         }
         state = ConnectionState.Disposed;
         disposeEmitter.fire(void 0);
-        let error = new Error("Connection got disposed.");
+        const error = new Error("Connection got disposed.");
         Object.keys(responsePromises).forEach((key) => {
           responsePromises[key].reject(error);
         });
@@ -2046,7 +2583,7 @@ ${JSON.stringify(message, null, 4)}`);
         messageReader.listen(callback);
       },
       inspect: () => {
-        console.log("inspect");
+        ral_1.default().console.log("inspect");
       }
     };
     connection.onNotification(LogTraceNotification.type, (params) => {
@@ -2065,29 +2602,410 @@ ${JSON.stringify(message, null, 4)}`);
     });
     return connection;
   }
-  function isMessageReader(value) {
-    return value.listen !== void 0 && value.read === void 0;
+  exports2.createMessageConnection = createMessageConnection;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/api.js
+var require_api = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.CancellationSenderStrategy = exports2.CancellationReceiverStrategy = exports2.ConnectionError = exports2.ConnectionErrors = exports2.LogTraceNotification = exports2.SetTraceNotification = exports2.TraceFormat = exports2.Trace = exports2.ProgressType = exports2.createMessageConnection = exports2.NullLogger = exports2.ConnectionOptions = exports2.ConnectionStrategy = exports2.WriteableStreamMessageWriter = exports2.AbstractMessageWriter = exports2.MessageWriter = exports2.ReadableStreamMessageReader = exports2.AbstractMessageReader = exports2.MessageReader = exports2.CancellationToken = exports2.CancellationTokenSource = exports2.Emitter = exports2.Event = exports2.Disposable = exports2.ParameterStructures = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.ErrorCodes = exports2.ResponseError = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType0 = exports2.RequestType = exports2.RAL = void 0;
+  exports2.CancellationStrategy = void 0;
+  var messages_1 = require_messages();
+  Object.defineProperty(exports2, "RequestType", {enumerable: true, get: function() {
+    return messages_1.RequestType;
+  }});
+  Object.defineProperty(exports2, "RequestType0", {enumerable: true, get: function() {
+    return messages_1.RequestType0;
+  }});
+  Object.defineProperty(exports2, "RequestType1", {enumerable: true, get: function() {
+    return messages_1.RequestType1;
+  }});
+  Object.defineProperty(exports2, "RequestType2", {enumerable: true, get: function() {
+    return messages_1.RequestType2;
+  }});
+  Object.defineProperty(exports2, "RequestType3", {enumerable: true, get: function() {
+    return messages_1.RequestType3;
+  }});
+  Object.defineProperty(exports2, "RequestType4", {enumerable: true, get: function() {
+    return messages_1.RequestType4;
+  }});
+  Object.defineProperty(exports2, "RequestType5", {enumerable: true, get: function() {
+    return messages_1.RequestType5;
+  }});
+  Object.defineProperty(exports2, "RequestType6", {enumerable: true, get: function() {
+    return messages_1.RequestType6;
+  }});
+  Object.defineProperty(exports2, "RequestType7", {enumerable: true, get: function() {
+    return messages_1.RequestType7;
+  }});
+  Object.defineProperty(exports2, "RequestType8", {enumerable: true, get: function() {
+    return messages_1.RequestType8;
+  }});
+  Object.defineProperty(exports2, "RequestType9", {enumerable: true, get: function() {
+    return messages_1.RequestType9;
+  }});
+  Object.defineProperty(exports2, "ResponseError", {enumerable: true, get: function() {
+    return messages_1.ResponseError;
+  }});
+  Object.defineProperty(exports2, "ErrorCodes", {enumerable: true, get: function() {
+    return messages_1.ErrorCodes;
+  }});
+  Object.defineProperty(exports2, "NotificationType", {enumerable: true, get: function() {
+    return messages_1.NotificationType;
+  }});
+  Object.defineProperty(exports2, "NotificationType0", {enumerable: true, get: function() {
+    return messages_1.NotificationType0;
+  }});
+  Object.defineProperty(exports2, "NotificationType1", {enumerable: true, get: function() {
+    return messages_1.NotificationType1;
+  }});
+  Object.defineProperty(exports2, "NotificationType2", {enumerable: true, get: function() {
+    return messages_1.NotificationType2;
+  }});
+  Object.defineProperty(exports2, "NotificationType3", {enumerable: true, get: function() {
+    return messages_1.NotificationType3;
+  }});
+  Object.defineProperty(exports2, "NotificationType4", {enumerable: true, get: function() {
+    return messages_1.NotificationType4;
+  }});
+  Object.defineProperty(exports2, "NotificationType5", {enumerable: true, get: function() {
+    return messages_1.NotificationType5;
+  }});
+  Object.defineProperty(exports2, "NotificationType6", {enumerable: true, get: function() {
+    return messages_1.NotificationType6;
+  }});
+  Object.defineProperty(exports2, "NotificationType7", {enumerable: true, get: function() {
+    return messages_1.NotificationType7;
+  }});
+  Object.defineProperty(exports2, "NotificationType8", {enumerable: true, get: function() {
+    return messages_1.NotificationType8;
+  }});
+  Object.defineProperty(exports2, "NotificationType9", {enumerable: true, get: function() {
+    return messages_1.NotificationType9;
+  }});
+  Object.defineProperty(exports2, "ParameterStructures", {enumerable: true, get: function() {
+    return messages_1.ParameterStructures;
+  }});
+  var disposable_1 = require_disposable();
+  Object.defineProperty(exports2, "Disposable", {enumerable: true, get: function() {
+    return disposable_1.Disposable;
+  }});
+  var events_1 = require_events();
+  Object.defineProperty(exports2, "Event", {enumerable: true, get: function() {
+    return events_1.Event;
+  }});
+  Object.defineProperty(exports2, "Emitter", {enumerable: true, get: function() {
+    return events_1.Emitter;
+  }});
+  var cancellation_1 = require_cancellation();
+  Object.defineProperty(exports2, "CancellationTokenSource", {enumerable: true, get: function() {
+    return cancellation_1.CancellationTokenSource;
+  }});
+  Object.defineProperty(exports2, "CancellationToken", {enumerable: true, get: function() {
+    return cancellation_1.CancellationToken;
+  }});
+  var messageReader_1 = require_messageReader();
+  Object.defineProperty(exports2, "MessageReader", {enumerable: true, get: function() {
+    return messageReader_1.MessageReader;
+  }});
+  Object.defineProperty(exports2, "AbstractMessageReader", {enumerable: true, get: function() {
+    return messageReader_1.AbstractMessageReader;
+  }});
+  Object.defineProperty(exports2, "ReadableStreamMessageReader", {enumerable: true, get: function() {
+    return messageReader_1.ReadableStreamMessageReader;
+  }});
+  var messageWriter_1 = require_messageWriter();
+  Object.defineProperty(exports2, "MessageWriter", {enumerable: true, get: function() {
+    return messageWriter_1.MessageWriter;
+  }});
+  Object.defineProperty(exports2, "AbstractMessageWriter", {enumerable: true, get: function() {
+    return messageWriter_1.AbstractMessageWriter;
+  }});
+  Object.defineProperty(exports2, "WriteableStreamMessageWriter", {enumerable: true, get: function() {
+    return messageWriter_1.WriteableStreamMessageWriter;
+  }});
+  var connection_1 = require_connection();
+  Object.defineProperty(exports2, "ConnectionStrategy", {enumerable: true, get: function() {
+    return connection_1.ConnectionStrategy;
+  }});
+  Object.defineProperty(exports2, "ConnectionOptions", {enumerable: true, get: function() {
+    return connection_1.ConnectionOptions;
+  }});
+  Object.defineProperty(exports2, "NullLogger", {enumerable: true, get: function() {
+    return connection_1.NullLogger;
+  }});
+  Object.defineProperty(exports2, "createMessageConnection", {enumerable: true, get: function() {
+    return connection_1.createMessageConnection;
+  }});
+  Object.defineProperty(exports2, "ProgressType", {enumerable: true, get: function() {
+    return connection_1.ProgressType;
+  }});
+  Object.defineProperty(exports2, "Trace", {enumerable: true, get: function() {
+    return connection_1.Trace;
+  }});
+  Object.defineProperty(exports2, "TraceFormat", {enumerable: true, get: function() {
+    return connection_1.TraceFormat;
+  }});
+  Object.defineProperty(exports2, "SetTraceNotification", {enumerable: true, get: function() {
+    return connection_1.SetTraceNotification;
+  }});
+  Object.defineProperty(exports2, "LogTraceNotification", {enumerable: true, get: function() {
+    return connection_1.LogTraceNotification;
+  }});
+  Object.defineProperty(exports2, "ConnectionErrors", {enumerable: true, get: function() {
+    return connection_1.ConnectionErrors;
+  }});
+  Object.defineProperty(exports2, "ConnectionError", {enumerable: true, get: function() {
+    return connection_1.ConnectionError;
+  }});
+  Object.defineProperty(exports2, "CancellationReceiverStrategy", {enumerable: true, get: function() {
+    return connection_1.CancellationReceiverStrategy;
+  }});
+  Object.defineProperty(exports2, "CancellationSenderStrategy", {enumerable: true, get: function() {
+    return connection_1.CancellationSenderStrategy;
+  }});
+  Object.defineProperty(exports2, "CancellationStrategy", {enumerable: true, get: function() {
+    return connection_1.CancellationStrategy;
+  }});
+  var ral_1 = require_ral();
+  exports2.RAL = ral_1.default;
+});
+
+// node_modules/vscode-jsonrpc/lib/node/main.js
+var require_main = __commonJS((exports2) => {
+  "use strict";
+  var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    Object.defineProperty(o, k2, {enumerable: true, get: function() {
+      return m[k];
+    }});
+  } : function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+        __createBinding(exports3, m, p);
+  };
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.createMessageConnection = exports2.createServerSocketTransport = exports2.createClientSocketTransport = exports2.createServerPipeTransport = exports2.createClientPipeTransport = exports2.generateRandomPipeName = exports2.StreamMessageWriter = exports2.StreamMessageReader = exports2.SocketMessageWriter = exports2.SocketMessageReader = exports2.IPCMessageWriter = exports2.IPCMessageReader = void 0;
+  var ril_1 = require_ril();
+  ril_1.default.install();
+  var api_1 = require_api();
+  var path9 = require("path");
+  var os3 = require("os");
+  var crypto_1 = require("crypto");
+  var net_1 = require("net");
+  __exportStar2(require_api(), exports2);
+  var IPCMessageReader = class extends api_1.AbstractMessageReader {
+    constructor(process2) {
+      super();
+      this.process = process2;
+      let eventEmitter = this.process;
+      eventEmitter.on("error", (error) => this.fireError(error));
+      eventEmitter.on("close", () => this.fireClose());
+    }
+    listen(callback) {
+      this.process.on("message", callback);
+      return api_1.Disposable.create(() => this.process.off("message", callback));
+    }
+  };
+  exports2.IPCMessageReader = IPCMessageReader;
+  var IPCMessageWriter = class extends api_1.AbstractMessageWriter {
+    constructor(process2) {
+      super();
+      this.process = process2;
+      this.errorCount = 0;
+      let eventEmitter = this.process;
+      eventEmitter.on("error", (error) => this.fireError(error));
+      eventEmitter.on("close", () => this.fireClose);
+    }
+    write(msg) {
+      try {
+        if (typeof this.process.send === "function") {
+          this.process.send(msg, void 0, void 0, (error) => {
+            if (error) {
+              this.errorCount++;
+              this.handleError(error, msg);
+            } else {
+              this.errorCount = 0;
+            }
+          });
+        }
+        return Promise.resolve();
+      } catch (error) {
+        this.handleError(error, msg);
+        return Promise.reject(error);
+      }
+    }
+    handleError(error, msg) {
+      this.errorCount++;
+      this.fireError(error, msg, this.errorCount);
+    }
+    end() {
+    }
+  };
+  exports2.IPCMessageWriter = IPCMessageWriter;
+  var SocketMessageReader = class extends api_1.ReadableStreamMessageReader {
+    constructor(socket, encoding = "utf-8") {
+      super(ril_1.default().stream.asReadableStream(socket), encoding);
+    }
+  };
+  exports2.SocketMessageReader = SocketMessageReader;
+  var SocketMessageWriter = class extends api_1.WriteableStreamMessageWriter {
+    constructor(socket, options) {
+      super(ril_1.default().stream.asWritableStream(socket), options);
+      this.socket = socket;
+    }
+    dispose() {
+      super.dispose();
+      this.socket.destroy();
+    }
+  };
+  exports2.SocketMessageWriter = SocketMessageWriter;
+  var StreamMessageReader = class extends api_1.ReadableStreamMessageReader {
+    constructor(readble, encoding) {
+      super(ril_1.default().stream.asReadableStream(readble), encoding);
+    }
+  };
+  exports2.StreamMessageReader = StreamMessageReader;
+  var StreamMessageWriter = class extends api_1.WriteableStreamMessageWriter {
+    constructor(writable, options) {
+      super(ril_1.default().stream.asWritableStream(writable), options);
+    }
+  };
+  exports2.StreamMessageWriter = StreamMessageWriter;
+  var XDG_RUNTIME_DIR = process.env["XDG_RUNTIME_DIR"];
+  var safeIpcPathLengths = new Map([
+    ["linux", 107],
+    ["darwin", 103]
+  ]);
+  function generateRandomPipeName() {
+    const randomSuffix = crypto_1.randomBytes(21).toString("hex");
+    if (process.platform === "win32") {
+      return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
+    }
+    let result;
+    if (XDG_RUNTIME_DIR) {
+      result = path9.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
+    } else {
+      result = path9.join(os3.tmpdir(), `vscode-${randomSuffix}.sock`);
+    }
+    const limit = safeIpcPathLengths.get(process.platform);
+    if (limit !== void 0 && result.length >= limit) {
+      ril_1.default().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
+    }
+    return result;
+  }
+  exports2.generateRandomPipeName = generateRandomPipeName;
+  function createClientPipeTransport(pipeName, encoding = "utf-8") {
+    let connectResolve;
+    const connected = new Promise((resolve, _reject) => {
+      connectResolve = resolve;
+    });
+    return new Promise((resolve, reject) => {
+      let server = net_1.createServer((socket) => {
+        server.close();
+        connectResolve([
+          new SocketMessageReader(socket, encoding),
+          new SocketMessageWriter(socket, encoding)
+        ]);
+      });
+      server.on("error", reject);
+      server.listen(pipeName, () => {
+        server.removeListener("error", reject);
+        resolve({
+          onConnected: () => {
+            return connected;
+          }
+        });
+      });
+    });
+  }
+  exports2.createClientPipeTransport = createClientPipeTransport;
+  function createServerPipeTransport(pipeName, encoding = "utf-8") {
+    const socket = net_1.createConnection(pipeName);
+    return [
+      new SocketMessageReader(socket, encoding),
+      new SocketMessageWriter(socket, encoding)
+    ];
+  }
+  exports2.createServerPipeTransport = createServerPipeTransport;
+  function createClientSocketTransport(port, encoding = "utf-8") {
+    let connectResolve;
+    const connected = new Promise((resolve, _reject) => {
+      connectResolve = resolve;
+    });
+    return new Promise((resolve, reject) => {
+      const server = net_1.createServer((socket) => {
+        server.close();
+        connectResolve([
+          new SocketMessageReader(socket, encoding),
+          new SocketMessageWriter(socket, encoding)
+        ]);
+      });
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        server.removeListener("error", reject);
+        resolve({
+          onConnected: () => {
+            return connected;
+          }
+        });
+      });
+    });
+  }
+  exports2.createClientSocketTransport = createClientSocketTransport;
+  function createServerSocketTransport(port, encoding = "utf-8") {
+    const socket = net_1.createConnection(port, "127.0.0.1");
+    return [
+      new SocketMessageReader(socket, encoding),
+      new SocketMessageWriter(socket, encoding)
+    ];
+  }
+  exports2.createServerSocketTransport = createServerSocketTransport;
+  function isReadableStream(value) {
+    const candidate = value;
+    return candidate.read !== void 0 && candidate.addListener !== void 0;
   }
-  function isMessageWriter(value) {
-    return value.write !== void 0 && value.end === void 0;
+  function isWritableStream(value) {
+    const candidate = value;
+    return candidate.write !== void 0 && candidate.addListener !== void 0;
   }
-  function createMessageConnection(input, output, logger, strategy) {
+  function createMessageConnection(input, output, logger, options) {
     if (!logger) {
-      logger = exports2.NullLogger;
+      logger = api_1.NullLogger;
     }
-    let reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input);
-    let writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output);
-    return _createMessageConnection(reader, writer, logger, strategy);
+    const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
+    const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
+    if (api_1.ConnectionStrategy.is(options)) {
+      options = {connectionStrategy: options};
+    }
+    return api_1.createMessageConnection(reader, writer, logger, options);
   }
   exports2.createMessageConnection = createMessageConnection;
 });
 
+// node_modules/vscode-jsonrpc/node.js
+var require_node = __commonJS((exports2, module2) => {
+  "use strict";
+  module2.exports = require_main();
+});
+
 // node_modules/vscode-languageserver-types/lib/esm/main.js
 var require_main2 = __commonJS((exports2) => {
   __export(exports2, {
+    AnnotatedTextEdit: () => AnnotatedTextEdit,
+    ChangeAnnotation: () => ChangeAnnotation,
+    ChangeAnnotationIdentifier: () => ChangeAnnotationIdentifier,
     CodeAction: () => CodeAction6,
     CodeActionContext: () => CodeActionContext6,
     CodeActionKind: () => CodeActionKind6,
+    CodeDescription: () => CodeDescription,
     CodeLens: () => CodeLens2,
     Color: () => Color,
     ColorInformation: () => ColorInformation,
@@ -2095,14 +3013,14 @@ var require_main2 = __commonJS((exports2) => {
     Command: () => Command5,
     CompletionItem: () => CompletionItem4,
     CompletionItemKind: () => CompletionItemKind3,
-    CompletionItemTag: () => CompletionItemTag,
+    CompletionItemTag: () => CompletionItemTag2,
     CompletionList: () => CompletionList3,
     CreateFile: () => CreateFile,
     DeleteFile: () => DeleteFile,
-    Diagnostic: () => Diagnostic5,
+    Diagnostic: () => Diagnostic6,
     DiagnosticRelatedInformation: () => DiagnosticRelatedInformation2,
     DiagnosticSeverity: () => DiagnosticSeverity3,
-    DiagnosticTag: () => DiagnosticTag,
+    DiagnosticTag: () => DiagnosticTag3,
     DocumentHighlight: () => DocumentHighlight2,
     DocumentHighlightKind: () => DocumentHighlightKind2,
     DocumentLink: () => DocumentLink,
@@ -2112,73 +3030,94 @@ var require_main2 = __commonJS((exports2) => {
     FoldingRangeKind: () => FoldingRangeKind,
     FormattingOptions: () => FormattingOptions,
     Hover: () => Hover,
+    InsertReplaceEdit: () => InsertReplaceEdit,
     InsertTextFormat: () => InsertTextFormat3,
-    Location: () => Location3,
+    InsertTextMode: () => InsertTextMode,
+    Location: () => Location4,
     LocationLink: () => LocationLink,
     MarkedString: () => MarkedString,
     MarkupContent: () => MarkupContent3,
     MarkupKind: () => MarkupKind3,
+    OptionalVersionedTextDocumentIdentifier: () => OptionalVersionedTextDocumentIdentifier,
     ParameterInformation: () => ParameterInformation,
-    Position: () => Position7,
-    Range: () => Range15,
+    Position: () => Position10,
+    Range: () => Range17,
     RenameFile: () => RenameFile,
     SelectionRange: () => SelectionRange,
     SignatureInformation: () => SignatureInformation,
     SymbolInformation: () => SymbolInformation2,
-    SymbolKind: () => SymbolKind3,
-    SymbolTag: () => SymbolTag,
-    TextDocument: () => TextDocument11,
+    SymbolKind: () => SymbolKind5,
+    SymbolTag: () => SymbolTag4,
+    TextDocument: () => TextDocument13,
     TextDocumentEdit: () => TextDocumentEdit,
     TextDocumentIdentifier: () => TextDocumentIdentifier,
     TextDocumentItem: () => TextDocumentItem,
     TextEdit: () => TextEdit6,
     VersionedTextDocumentIdentifier: () => VersionedTextDocumentIdentifier,
     WorkspaceChange: () => WorkspaceChange,
-    WorkspaceEdit: () => WorkspaceEdit6
+    WorkspaceEdit: () => WorkspaceEdit6,
+    integer: () => integer,
+    uinteger: () => uinteger
   });
   "use strict";
-  var Position7;
-  (function(Position8) {
+  var integer;
+  (function(integer2) {
+    integer2.MIN_VALUE = -2147483648;
+    integer2.MAX_VALUE = 2147483647;
+  })(integer || (integer = {}));
+  var uinteger;
+  (function(uinteger2) {
+    uinteger2.MIN_VALUE = 0;
+    uinteger2.MAX_VALUE = 2147483647;
+  })(uinteger || (uinteger = {}));
+  var Position10;
+  (function(Position11) {
     function create(line, character) {
+      if (line === Number.MAX_VALUE) {
+        line = uinteger.MAX_VALUE;
+      }
+      if (character === Number.MAX_VALUE) {
+        character = uinteger.MAX_VALUE;
+      }
       return {line, character};
     }
-    Position8.create = create;
+    Position11.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character);
+      return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
     }
-    Position8.is = is2;
-  })(Position7 || (Position7 = {}));
-  var Range15;
-  (function(Range16) {
+    Position11.is = is2;
+  })(Position10 || (Position10 = {}));
+  var Range17;
+  (function(Range18) {
     function create(one, two, three, four) {
-      if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {
-        return {start: Position7.create(one, two), end: Position7.create(three, four)};
-      } else if (Position7.is(one) && Position7.is(two)) {
+      if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
+        return {start: Position10.create(one, two), end: Position10.create(three, four)};
+      } else if (Position10.is(one) && Position10.is(two)) {
         return {start: one, end: two};
       } else {
         throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");
       }
     }
-    Range16.create = create;
+    Range18.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.objectLiteral(candidate) && Position7.is(candidate.start) && Position7.is(candidate.end);
+      return Is.objectLiteral(candidate) && Position10.is(candidate.start) && Position10.is(candidate.end);
     }
-    Range16.is = is2;
-  })(Range15 || (Range15 = {}));
-  var Location3;
-  (function(Location4) {
+    Range18.is = is2;
+  })(Range17 || (Range17 = {}));
+  var Location4;
+  (function(Location5) {
     function create(uri, range) {
       return {uri, range};
     }
-    Location4.create = create;
+    Location5.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Range15.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+      return Is.defined(candidate) && Range17.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
     }
-    Location4.is = is2;
-  })(Location3 || (Location3 = {}));
+    Location5.is = is2;
+  })(Location4 || (Location4 = {}));
   var LocationLink;
   (function(LocationLink2) {
     function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
@@ -2187,7 +3126,7 @@ var require_main2 = __commonJS((exports2) => {
     LocationLink2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Range15.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range15.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range15.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+      return Is.defined(candidate) && Range17.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range17.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range17.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
     }
     LocationLink2.is = is2;
   })(LocationLink || (LocationLink = {}));
@@ -2204,7 +3143,7 @@ var require_main2 = __commonJS((exports2) => {
     Color2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.number(candidate.red) && Is.number(candidate.green) && Is.number(candidate.blue) && Is.number(candidate.alpha);
+      return Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
     }
     Color2.is = is2;
   })(Color || (Color = {}));
@@ -2219,7 +3158,7 @@ var require_main2 = __commonJS((exports2) => {
     ColorInformation2.create = create;
     function is2(value) {
       var candidate = value;
-      return Range15.is(candidate.range) && Color.is(candidate.color);
+      return Range17.is(candidate.range) && Color.is(candidate.color);
     }
     ColorInformation2.is = is2;
   })(ColorInformation || (ColorInformation = {}));
@@ -2266,7 +3205,7 @@ var require_main2 = __commonJS((exports2) => {
     FoldingRange3.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.number(candidate.startLine) && Is.number(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.number(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.number(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
+      return Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
     }
     FoldingRange3.is = is2;
   })(FoldingRange2 || (FoldingRange2 = {}));
@@ -2281,7 +3220,7 @@ var require_main2 = __commonJS((exports2) => {
     DiagnosticRelatedInformation3.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Location3.is(candidate.location) && Is.string(candidate.message);
+      return Is.defined(candidate) && Location4.is(candidate.location) && Is.string(candidate.message);
     }
     DiagnosticRelatedInformation3.is = is2;
   })(DiagnosticRelatedInformation2 || (DiagnosticRelatedInformation2 = {}));
@@ -2292,13 +3231,21 @@ var require_main2 = __commonJS((exports2) => {
     DiagnosticSeverity4.Information = 3;
     DiagnosticSeverity4.Hint = 4;
   })(DiagnosticSeverity3 || (DiagnosticSeverity3 = {}));
-  var DiagnosticTag;
-  (function(DiagnosticTag2) {
-    DiagnosticTag2.Unnecessary = 1;
-    DiagnosticTag2.Deprecated = 2;
-  })(DiagnosticTag || (DiagnosticTag = {}));
-  var Diagnostic5;
-  (function(Diagnostic6) {
+  var DiagnosticTag3;
+  (function(DiagnosticTag4) {
+    DiagnosticTag4.Unnecessary = 1;
+    DiagnosticTag4.Deprecated = 2;
+  })(DiagnosticTag3 || (DiagnosticTag3 = {}));
+  var CodeDescription;
+  (function(CodeDescription2) {
+    function is2(value) {
+      var candidate = value;
+      return candidate !== void 0 && candidate !== null && Is.string(candidate.href);
+    }
+    CodeDescription2.is = is2;
+  })(CodeDescription || (CodeDescription = {}));
+  var Diagnostic6;
+  (function(Diagnostic7) {
     function create(range, message, severity, code, source, relatedInformation) {
       var result = {range, message};
       if (Is.defined(severity)) {
@@ -2315,13 +3262,14 @@ var require_main2 = __commonJS((exports2) => {
       }
       return result;
     }
-    Diagnostic6.create = create;
+    Diagnostic7.create = create;
     function is2(value) {
+      var _a;
       var candidate = value;
-      return Is.defined(candidate) && Range15.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.number(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation2.is));
+      return Is.defined(candidate) && Range17.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation2.is));
     }
-    Diagnostic6.is = is2;
-  })(Diagnostic5 || (Diagnostic5 = {}));
+    Diagnostic7.is = is2;
+  })(Diagnostic6 || (Diagnostic6 = {}));
   var Command5;
   (function(Command6) {
     function create(title, command) {
@@ -2358,10 +3306,57 @@ var require_main2 = __commonJS((exports2) => {
     TextEdit7.del = del;
     function is2(value) {
       var candidate = value;
-      return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range15.is(candidate.range);
+      return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range17.is(candidate.range);
     }
     TextEdit7.is = is2;
   })(TextEdit6 || (TextEdit6 = {}));
+  var ChangeAnnotation;
+  (function(ChangeAnnotation2) {
+    function create(label, needsConfirmation, description) {
+      var result = {label};
+      if (needsConfirmation !== void 0) {
+        result.needsConfirmation = needsConfirmation;
+      }
+      if (description !== void 0) {
+        result.description = description;
+      }
+      return result;
+    }
+    ChangeAnnotation2.create = create;
+    function is2(value) {
+      var candidate = value;
+      return candidate !== void 0 && Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+    }
+    ChangeAnnotation2.is = is2;
+  })(ChangeAnnotation || (ChangeAnnotation = {}));
+  var ChangeAnnotationIdentifier;
+  (function(ChangeAnnotationIdentifier2) {
+    function is2(value) {
+      var candidate = value;
+      return typeof candidate === "string";
+    }
+    ChangeAnnotationIdentifier2.is = is2;
+  })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
+  var AnnotatedTextEdit;
+  (function(AnnotatedTextEdit2) {
+    function replace(range, newText, annotation) {
+      return {range, newText, annotationId: annotation};
+    }
+    AnnotatedTextEdit2.replace = replace;
+    function insert(position, newText, annotation) {
+      return {range: {start: position, end: position}, newText, annotationId: annotation};
+    }
+    AnnotatedTextEdit2.insert = insert;
+    function del(range, annotation) {
+      return {range, newText: "", annotationId: annotation};
+    }
+    AnnotatedTextEdit2.del = del;
+    function is2(value) {
+      var candidate = value;
+      return TextEdit6.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    AnnotatedTextEdit2.is = is2;
+  })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
   var TextDocumentEdit;
   (function(TextDocumentEdit2) {
     function create(textDocument, edits) {
@@ -2370,13 +3365,13 @@ var require_main2 = __commonJS((exports2) => {
     TextDocumentEdit2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && VersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
+      return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
     }
     TextDocumentEdit2.is = is2;
   })(TextDocumentEdit || (TextDocumentEdit = {}));
   var CreateFile;
   (function(CreateFile2) {
-    function create(uri, options) {
+    function create(uri, options, annotation) {
       var result = {
         kind: "create",
         uri
@@ -2384,18 +3379,21 @@ var require_main2 = __commonJS((exports2) => {
       if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
         result.options = options;
       }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
       return result;
     }
     CreateFile2.create = create;
     function is2(value) {
       var candidate = value;
-      return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists)));
+      return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
     }
     CreateFile2.is = is2;
   })(CreateFile || (CreateFile = {}));
   var RenameFile;
   (function(RenameFile2) {
-    function create(oldUri, newUri, options) {
+    function create(oldUri, newUri, options, annotation) {
       var result = {
         kind: "rename",
         oldUri,
@@ -2404,18 +3402,21 @@ var require_main2 = __commonJS((exports2) => {
       if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
         result.options = options;
       }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
       return result;
     }
     RenameFile2.create = create;
     function is2(value) {
       var candidate = value;
-      return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists)));
+      return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
     }
     RenameFile2.is = is2;
   })(RenameFile || (RenameFile = {}));
   var DeleteFile;
   (function(DeleteFile2) {
-    function create(uri, options) {
+    function create(uri, options, annotation) {
       var result = {
         kind: "delete",
         uri
@@ -2423,12 +3424,15 @@ var require_main2 = __commonJS((exports2) => {
       if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
         result.options = options;
       }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
       return result;
     }
     DeleteFile2.create = create;
     function is2(value) {
       var candidate = value;
-      return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists)));
+      return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
     }
     DeleteFile2.is = is2;
   })(DeleteFile || (DeleteFile = {}));
@@ -2447,17 +3451,63 @@ var require_main2 = __commonJS((exports2) => {
     WorkspaceEdit7.is = is2;
   })(WorkspaceEdit6 || (WorkspaceEdit6 = {}));
   var TextEditChangeImpl = function() {
-    function TextEditChangeImpl2(edits) {
+    function TextEditChangeImpl2(edits, changeAnnotations) {
       this.edits = edits;
-    }
-    TextEditChangeImpl2.prototype.insert = function(position, newText) {
-      this.edits.push(TextEdit6.insert(position, newText));
+      this.changeAnnotations = changeAnnotations;
+    }
+    TextEditChangeImpl2.prototype.insert = function(position, newText, annotation) {
+      var edit;
+      var id;
+      if (annotation === void 0) {
+        edit = TextEdit6.insert(position, newText);
+      } else if (ChangeAnnotationIdentifier.is(annotation)) {
+        id = annotation;
+        edit = AnnotatedTextEdit.insert(position, newText, annotation);
+      } else {
+        this.assertChangeAnnotations(this.changeAnnotations);
+        id = this.changeAnnotations.manage(annotation);
+        edit = AnnotatedTextEdit.insert(position, newText, id);
+      }
+      this.edits.push(edit);
+      if (id !== void 0) {
+        return id;
+      }
     };
-    TextEditChangeImpl2.prototype.replace = function(range, newText) {
-      this.edits.push(TextEdit6.replace(range, newText));
+    TextEditChangeImpl2.prototype.replace = function(range, newText, annotation) {
+      var edit;
+      var id;
+      if (annotation === void 0) {
+        edit = TextEdit6.replace(range, newText);
+      } else if (ChangeAnnotationIdentifier.is(annotation)) {
+        id = annotation;
+        edit = AnnotatedTextEdit.replace(range, newText, annotation);
+      } else {
+        this.assertChangeAnnotations(this.changeAnnotations);
+        id = this.changeAnnotations.manage(annotation);
+        edit = AnnotatedTextEdit.replace(range, newText, id);
+      }
+      this.edits.push(edit);
+      if (id !== void 0) {
+        return id;
+      }
     };
-    TextEditChangeImpl2.prototype.delete = function(range) {
-      this.edits.push(TextEdit6.del(range));
+    TextEditChangeImpl2.prototype.delete = function(range, annotation) {
+      var edit;
+      var id;
+      if (annotation === void 0) {
+        edit = TextEdit6.del(range);
+      } else if (ChangeAnnotationIdentifier.is(annotation)) {
+        id = annotation;
+        edit = AnnotatedTextEdit.del(range, annotation);
+      } else {
+        this.assertChangeAnnotations(this.changeAnnotations);
+        id = this.changeAnnotations.manage(annotation);
+        edit = AnnotatedTextEdit.del(range, id);
+      }
+      this.edits.push(edit);
+      if (id !== void 0) {
+        return id;
+      }
     };
     TextEditChangeImpl2.prototype.add = function(edit) {
       this.edits.push(edit);
@@ -2468,18 +3518,65 @@ var require_main2 = __commonJS((exports2) => {
     TextEditChangeImpl2.prototype.clear = function() {
       this.edits.splice(0, this.edits.length);
     };
+    TextEditChangeImpl2.prototype.assertChangeAnnotations = function(value) {
+      if (value === void 0) {
+        throw new Error("Text edit change is not configured to manage change annotations.");
+      }
+    };
     return TextEditChangeImpl2;
   }();
+  var ChangeAnnotations = function() {
+    function ChangeAnnotations2(annotations) {
+      this._annotations = annotations === void 0 ? Object.create(null) : annotations;
+      this._counter = 0;
+      this._size = 0;
+    }
+    ChangeAnnotations2.prototype.all = function() {
+      return this._annotations;
+    };
+    Object.defineProperty(ChangeAnnotations2.prototype, "size", {
+      get: function() {
+        return this._size;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    ChangeAnnotations2.prototype.manage = function(idOrAnnotation, annotation) {
+      var id;
+      if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
+        id = idOrAnnotation;
+      } else {
+        id = this.nextId();
+        annotation = idOrAnnotation;
+      }
+      if (this._annotations[id] !== void 0) {
+        throw new Error("Id " + id + " is already in use.");
+      }
+      if (annotation === void 0) {
+        throw new Error("No annotation provided for id " + id);
+      }
+      this._annotations[id] = annotation;
+      this._size++;
+      return id;
+    };
+    ChangeAnnotations2.prototype.nextId = function() {
+      this._counter++;
+      return this._counter.toString();
+    };
+    return ChangeAnnotations2;
+  }();
   var WorkspaceChange = function() {
     function WorkspaceChange2(workspaceEdit) {
       var _this = this;
       this._textEditChanges = Object.create(null);
-      if (workspaceEdit) {
+      if (workspaceEdit !== void 0) {
         this._workspaceEdit = workspaceEdit;
         if (workspaceEdit.documentChanges) {
+          this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
+          workspaceEdit.changeAnnotations = this._changeAnnotations.all();
           workspaceEdit.documentChanges.forEach(function(change) {
             if (TextDocumentEdit.is(change)) {
-              var textEditChange = new TextEditChangeImpl(change.edits);
+              var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);
               _this._textEditChanges[change.textDocument.uri] = textEditChange;
             }
           });
@@ -2489,26 +3586,32 @@ var require_main2 = __commonJS((exports2) => {
             _this._textEditChanges[key] = textEditChange;
           });
         }
+      } else {
+        this._workspaceEdit = {};
       }
     }
     Object.defineProperty(WorkspaceChange2.prototype, "edit", {
       get: function() {
+        this.initDocumentChanges();
+        if (this._changeAnnotations !== void 0) {
+          if (this._changeAnnotations.size === 0) {
+            this._workspaceEdit.changeAnnotations = void 0;
+          } else {
+            this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+          }
+        }
         return this._workspaceEdit;
       },
-      enumerable: true,
+      enumerable: false,
       configurable: true
     });
     WorkspaceChange2.prototype.getTextEditChange = function(key) {
-      if (VersionedTextDocumentIdentifier.is(key)) {
-        if (!this._workspaceEdit) {
-          this._workspaceEdit = {
-            documentChanges: []
-          };
-        }
-        if (!this._workspaceEdit.documentChanges) {
+      if (OptionalVersionedTextDocumentIdentifier.is(key)) {
+        this.initDocumentChanges();
+        if (this._workspaceEdit.documentChanges === void 0) {
           throw new Error("Workspace edit is not configured for document changes.");
         }
-        var textDocument = key;
+        var textDocument = {uri: key.uri, version: key.version};
         var result = this._textEditChanges[textDocument.uri];
         if (!result) {
           var edits = [];
@@ -2517,17 +3620,13 @@ var require_main2 = __commonJS((exports2) => {
             edits
           };
           this._workspaceEdit.documentChanges.push(textDocumentEdit);
-          result = new TextEditChangeImpl(edits);
+          result = new TextEditChangeImpl(edits, this._changeAnnotations);
           this._textEditChanges[textDocument.uri] = result;
         }
         return result;
       } else {
-        if (!this._workspaceEdit) {
-          this._workspaceEdit = {
-            changes: Object.create(null)
-          };
-        }
-        if (!this._workspaceEdit.changes) {
+        this.initChanges();
+        if (this._workspaceEdit.changes === void 0) {
           throw new Error("Workspace edit is not configured for normal text edit changes.");
         }
         var result = this._textEditChanges[key];
@@ -2540,22 +3639,89 @@ var require_main2 = __commonJS((exports2) => {
         return result;
       }
     };
-    WorkspaceChange2.prototype.createFile = function(uri, options) {
-      this.checkDocumentChanges();
-      this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options));
+    WorkspaceChange2.prototype.initDocumentChanges = function() {
+      if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
+        this._changeAnnotations = new ChangeAnnotations();
+        this._workspaceEdit.documentChanges = [];
+        this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+      }
+    };
+    WorkspaceChange2.prototype.initChanges = function() {
+      if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
+        this._workspaceEdit.changes = Object.create(null);
+      }
     };
-    WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, options) {
-      this.checkDocumentChanges();
-      this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options));
+    WorkspaceChange2.prototype.createFile = function(uri, optionsOrAnnotation, options) {
+      this.initDocumentChanges();
+      if (this._workspaceEdit.documentChanges === void 0) {
+        throw new Error("Workspace edit is not configured for document changes.");
+      }
+      var annotation;
+      if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+        annotation = optionsOrAnnotation;
+      } else {
+        options = optionsOrAnnotation;
+      }
+      var operation;
+      var id;
+      if (annotation === void 0) {
+        operation = CreateFile.create(uri, options);
+      } else {
+        id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+        operation = CreateFile.create(uri, options, id);
+      }
+      this._workspaceEdit.documentChanges.push(operation);
+      if (id !== void 0) {
+        return id;
+      }
     };
-    WorkspaceChange2.prototype.deleteFile = function(uri, options) {
-      this.checkDocumentChanges();
-      this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options));
+    WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, optionsOrAnnotation, options) {
+      this.initDocumentChanges();
+      if (this._workspaceEdit.documentChanges === void 0) {
+        throw new Error("Workspace edit is not configured for document changes.");
+      }
+      var annotation;
+      if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+        annotation = optionsOrAnnotation;
+      } else {
+        options = optionsOrAnnotation;
+      }
+      var operation;
+      var id;
+      if (annotation === void 0) {
+        operation = RenameFile.create(oldUri, newUri, options);
+      } else {
+        id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+        operation = RenameFile.create(oldUri, newUri, options, id);
+      }
+      this._workspaceEdit.documentChanges.push(operation);
+      if (id !== void 0) {
+        return id;
+      }
     };
-    WorkspaceChange2.prototype.checkDocumentChanges = function() {
-      if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) {
+    WorkspaceChange2.prototype.deleteFile = function(uri, optionsOrAnnotation, options) {
+      this.initDocumentChanges();
+      if (this._workspaceEdit.documentChanges === void 0) {
         throw new Error("Workspace edit is not configured for document changes.");
       }
+      var annotation;
+      if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+        annotation = optionsOrAnnotation;
+      } else {
+        options = optionsOrAnnotation;
+      }
+      var operation;
+      var id;
+      if (annotation === void 0) {
+        operation = DeleteFile.create(uri, options);
+      } else {
+        id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+        operation = DeleteFile.create(uri, options, id);
+      }
+      this._workspaceEdit.documentChanges.push(operation);
+      if (id !== void 0) {
+        return id;
+      }
     };
     return WorkspaceChange2;
   }();
@@ -2579,10 +3745,22 @@ var require_main2 = __commonJS((exports2) => {
     VersionedTextDocumentIdentifier2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version));
+      return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
     }
     VersionedTextDocumentIdentifier2.is = is2;
   })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
+  var OptionalVersionedTextDocumentIdentifier;
+  (function(OptionalVersionedTextDocumentIdentifier2) {
+    function create(uri, version) {
+      return {uri, version};
+    }
+    OptionalVersionedTextDocumentIdentifier2.create = create;
+    function is2(value) {
+      var candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
+    }
+    OptionalVersionedTextDocumentIdentifier2.is = is2;
+  })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
   var TextDocumentItem;
   (function(TextDocumentItem2) {
     function create(uri, languageId, version, text) {
@@ -2591,7 +3769,7 @@ var require_main2 = __commonJS((exports2) => {
     TextDocumentItem2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text);
+      return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
     }
     TextDocumentItem2.is = is2;
   })(TextDocumentItem || (TextDocumentItem = {}));
@@ -2648,10 +3826,27 @@ var require_main2 = __commonJS((exports2) => {
     InsertTextFormat4.PlainText = 1;
     InsertTextFormat4.Snippet = 2;
   })(InsertTextFormat3 || (InsertTextFormat3 = {}));
-  var CompletionItemTag;
-  (function(CompletionItemTag2) {
-    CompletionItemTag2.Deprecated = 1;
-  })(CompletionItemTag || (CompletionItemTag = {}));
+  var CompletionItemTag2;
+  (function(CompletionItemTag3) {
+    CompletionItemTag3.Deprecated = 1;
+  })(CompletionItemTag2 || (CompletionItemTag2 = {}));
+  var InsertReplaceEdit;
+  (function(InsertReplaceEdit2) {
+    function create(newText, insert, replace) {
+      return {newText, insert, replace};
+    }
+    InsertReplaceEdit2.create = create;
+    function is2(value) {
+      var candidate = value;
+      return candidate && Is.string(candidate.newText) && Range17.is(candidate.insert) && Range17.is(candidate.replace);
+    }
+    InsertReplaceEdit2.is = is2;
+  })(InsertReplaceEdit || (InsertReplaceEdit = {}));
+  var InsertTextMode;
+  (function(InsertTextMode2) {
+    InsertTextMode2.asIs = 1;
+    InsertTextMode2.adjustIndentation = 2;
+  })(InsertTextMode || (InsertTextMode = {}));
   var CompletionItem4;
   (function(CompletionItem5) {
     function create(label) {
@@ -2682,7 +3877,7 @@ var require_main2 = __commonJS((exports2) => {
   (function(Hover2) {
     function is2(value) {
       var candidate = value;
-      return !!candidate && Is.objectLiteral(candidate) && (MarkupContent3.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range15.is(value.range));
+      return !!candidate && Is.objectLiteral(candidate) && (MarkupContent3.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range17.is(value.range));
     }
     Hover2.is = is2;
   })(Hover || (Hover = {}));
@@ -2730,39 +3925,39 @@ var require_main2 = __commonJS((exports2) => {
     }
     DocumentHighlight3.create = create;
   })(DocumentHighlight2 || (DocumentHighlight2 = {}));
-  var SymbolKind3;
-  (function(SymbolKind4) {
-    SymbolKind4.File = 1;
-    SymbolKind4.Module = 2;
-    SymbolKind4.Namespace = 3;
-    SymbolKind4.Package = 4;
-    SymbolKind4.Class = 5;
-    SymbolKind4.Method = 6;
-    SymbolKind4.Property = 7;
-    SymbolKind4.Field = 8;
-    SymbolKind4.Constructor = 9;
-    SymbolKind4.Enum = 10;
-    SymbolKind4.Interface = 11;
-    SymbolKind4.Function = 12;
-    SymbolKind4.Variable = 13;
-    SymbolKind4.Constant = 14;
-    SymbolKind4.String = 15;
-    SymbolKind4.Number = 16;
-    SymbolKind4.Boolean = 17;
-    SymbolKind4.Array = 18;
-    SymbolKind4.Object = 19;
-    SymbolKind4.Key = 20;
-    SymbolKind4.Null = 21;
-    SymbolKind4.EnumMember = 22;
-    SymbolKind4.Struct = 23;
-    SymbolKind4.Event = 24;
-    SymbolKind4.Operator = 25;
-    SymbolKind4.TypeParameter = 26;
-  })(SymbolKind3 || (SymbolKind3 = {}));
-  var SymbolTag;
-  (function(SymbolTag2) {
-    SymbolTag2.Deprecated = 1;
-  })(SymbolTag || (SymbolTag = {}));
+  var SymbolKind5;
+  (function(SymbolKind6) {
+    SymbolKind6.File = 1;
+    SymbolKind6.Module = 2;
+    SymbolKind6.Namespace = 3;
+    SymbolKind6.Package = 4;
+    SymbolKind6.Class = 5;
+    SymbolKind6.Method = 6;
+    SymbolKind6.Property = 7;
+    SymbolKind6.Field = 8;
+    SymbolKind6.Constructor = 9;
+    SymbolKind6.Enum = 10;
+    SymbolKind6.Interface = 11;
+    SymbolKind6.Function = 12;
+    SymbolKind6.Variable = 13;
+    SymbolKind6.Constant = 14;
+    SymbolKind6.String = 15;
+    SymbolKind6.Number = 16;
+    SymbolKind6.Boolean = 17;
+    SymbolKind6.Array = 18;
+    SymbolKind6.Object = 19;
+    SymbolKind6.Key = 20;
+    SymbolKind6.Null = 21;
+    SymbolKind6.EnumMember = 22;
+    SymbolKind6.Struct = 23;
+    SymbolKind6.Event = 24;
+    SymbolKind6.Operator = 25;
+    SymbolKind6.TypeParameter = 26;
+  })(SymbolKind5 || (SymbolKind5 = {}));
+  var SymbolTag4;
+  (function(SymbolTag5) {
+    SymbolTag5.Deprecated = 1;
+  })(SymbolTag4 || (SymbolTag4 = {}));
   var SymbolInformation2;
   (function(SymbolInformation3) {
     function create(name, kind, range, uri, containerName) {
@@ -2796,7 +3991,7 @@ var require_main2 = __commonJS((exports2) => {
     DocumentSymbol3.create = create;
     function is2(value) {
       var candidate = value;
-      return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range15.is(candidate.range) && Range15.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children));
+      return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range17.is(candidate.range) && Range17.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
     }
     DocumentSymbol3.is = is2;
   })(DocumentSymbol2 || (DocumentSymbol2 = {}));
@@ -2824,20 +4019,24 @@ var require_main2 = __commonJS((exports2) => {
     CodeActionContext7.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic5.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));
+      return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic6.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));
     }
     CodeActionContext7.is = is2;
   })(CodeActionContext6 || (CodeActionContext6 = {}));
   var CodeAction6;
   (function(CodeAction7) {
-    function create(title, commandOrEdit, kind) {
+    function create(title, kindOrCommandOrEdit, kind) {
       var result = {title};
-      if (Command5.is(commandOrEdit)) {
-        result.command = commandOrEdit;
+      var checkKind = true;
+      if (typeof kindOrCommandOrEdit === "string") {
+        checkKind = false;
+        result.kind = kindOrCommandOrEdit;
+      } else if (Command5.is(kindOrCommandOrEdit)) {
+        result.command = kindOrCommandOrEdit;
       } else {
-        result.edit = commandOrEdit;
+        result.edit = kindOrCommandOrEdit;
       }
-      if (kind !== void 0) {
+      if (checkKind && kind !== void 0) {
         result.kind = kind;
       }
       return result;
@@ -2845,7 +4044,7 @@ var require_main2 = __commonJS((exports2) => {
     CodeAction7.create = create;
     function is2(value) {
       var candidate = value;
-      return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic5.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command5.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit6.is(candidate.edit));
+      return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic6.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command5.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit6.is(candidate.edit));
     }
     CodeAction7.is = is2;
   })(CodeAction6 || (CodeAction6 = {}));
@@ -2861,7 +4060,7 @@ var require_main2 = __commonJS((exports2) => {
     CodeLens3.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Range15.is(candidate.range) && (Is.undefined(candidate.command) || Command5.is(candidate.command));
+      return Is.defined(candidate) && Range17.is(candidate.range) && (Is.undefined(candidate.command) || Command5.is(candidate.command));
     }
     CodeLens3.is = is2;
   })(CodeLens2 || (CodeLens2 = {}));
@@ -2873,7 +4072,7 @@ var require_main2 = __commonJS((exports2) => {
     FormattingOptions2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
+      return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
     }
     FormattingOptions2.is = is2;
   })(FormattingOptions || (FormattingOptions = {}));
@@ -2885,7 +4084,7 @@ var require_main2 = __commonJS((exports2) => {
     DocumentLink2.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Range15.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+      return Is.defined(candidate) && Range17.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
     }
     DocumentLink2.is = is2;
   })(DocumentLink || (DocumentLink = {}));
@@ -2897,22 +4096,22 @@ var require_main2 = __commonJS((exports2) => {
     SelectionRange2.create = create;
     function is2(value) {
       var candidate = value;
-      return candidate !== void 0 && Range15.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
+      return candidate !== void 0 && Range17.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
     }
     SelectionRange2.is = is2;
   })(SelectionRange || (SelectionRange = {}));
   var EOL = ["\n", "\r\n", "\r"];
-  var TextDocument11;
-  (function(TextDocument12) {
+  var TextDocument13;
+  (function(TextDocument14) {
     function create(uri, languageId, version, content) {
       return new FullTextDocument(uri, languageId, version, content);
     }
-    TextDocument12.create = create;
+    TextDocument14.create = create;
     function is2(value) {
       var candidate = value;
-      return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.number(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
+      return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
     }
-    TextDocument12.is = is2;
+    TextDocument14.is = is2;
     function applyEdits(document, edits) {
       var text = document.getText();
       var sortedEdits = mergeSort(edits, function(a, b) {
@@ -2936,7 +4135,7 @@ var require_main2 = __commonJS((exports2) => {
       }
       return text;
     }
-    TextDocument12.applyEdits = applyEdits;
+    TextDocument14.applyEdits = applyEdits;
     function mergeSort(data, compare) {
       if (data.length <= 1) {
         return data;
@@ -2965,7 +4164,7 @@ var require_main2 = __commonJS((exports2) => {
       }
       return data;
     }
-  })(TextDocument11 || (TextDocument11 = {}));
+  })(TextDocument13 || (TextDocument13 = {}));
   var FullTextDocument = function() {
     function FullTextDocument2(uri, languageId, version, content) {
       this._uri = uri;
@@ -2978,21 +4177,21 @@ var require_main2 = __commonJS((exports2) => {
       get: function() {
         return this._uri;
       },
-      enumerable: true,
+      enumerable: false,
       configurable: true
     });
     Object.defineProperty(FullTextDocument2.prototype, "languageId", {
       get: function() {
         return this._languageId;
       },
-      enumerable: true,
+      enumerable: false,
       configurable: true
     });
     Object.defineProperty(FullTextDocument2.prototype, "version", {
       get: function() {
         return this._version;
       },
-      enumerable: true,
+      enumerable: false,
       configurable: true
     });
     FullTextDocument2.prototype.getText = function(range) {
@@ -3036,7 +4235,7 @@ var require_main2 = __commonJS((exports2) => {
       var lineOffsets = this.getLineOffsets();
       var low = 0, high = lineOffsets.length;
       if (high === 0) {
-        return Position7.create(0, offset);
+        return Position10.create(0, offset);
       }
       while (low < high) {
         var mid = Math.floor((low + high) / 2);
@@ -3047,7 +4246,7 @@ var require_main2 = __commonJS((exports2) => {
         }
       }
       var line = low - 1;
-      return Position7.create(line, offset - lineOffsets[line]);
+      return Position10.create(line, offset - lineOffsets[line]);
     };
     FullTextDocument2.prototype.offsetAt = function(position) {
       var lineOffsets = this.getLineOffsets();
@@ -3064,7 +4263,7 @@ var require_main2 = __commonJS((exports2) => {
       get: function() {
         return this.getLineOffsets().length;
       },
-      enumerable: true,
+      enumerable: false,
       configurable: true
     });
     return FullTextDocument2;
@@ -3092,6 +4291,18 @@ var require_main2 = __commonJS((exports2) => {
       return toString2.call(value) === "[object Number]";
     }
     Is2.number = number;
+    function numberRange(value, min, max) {
+      return toString2.call(value) === "[object Number]" && min <= value && value <= max;
+    }
+    Is2.numberRange = numberRange;
+    function integer2(value) {
+      return toString2.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+    }
+    Is2.integer = integer2;
+    function uinteger2(value) {
+      return toString2.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+    }
+    Is2.uinteger = uinteger2;
     function func(value) {
       return toString2.call(value) === "[object Function]";
     }
@@ -3107,10 +4318,49 @@ var require_main2 = __commonJS((exports2) => {
   })(Is || (Is = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/utils/is.js
+// node_modules/vscode-languageserver-protocol/lib/common/messages.js
+var require_messages2 = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.ProtocolNotificationType = exports2.ProtocolNotificationType0 = exports2.ProtocolRequestType = exports2.ProtocolRequestType0 = exports2.RegistrationType = void 0;
+  var vscode_jsonrpc_1 = require_main();
+  var RegistrationType = class {
+    constructor(method) {
+      this.method = method;
+    }
+  };
+  exports2.RegistrationType = RegistrationType;
+  var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
+    constructor(method) {
+      super(method);
+    }
+  };
+  exports2.ProtocolRequestType0 = ProtocolRequestType0;
+  var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
+    constructor(method) {
+      super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+  };
+  exports2.ProtocolRequestType = ProtocolRequestType;
+  var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
+    constructor(method) {
+      super(method);
+    }
+  };
+  exports2.ProtocolNotificationType0 = ProtocolNotificationType0;
+  var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
+    constructor(method) {
+      super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+  };
+  exports2.ProtocolNotificationType = ProtocolNotificationType;
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/utils/is.js
 var require_is2 = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.objectLiteral = exports2.typedArray = exports2.stringArray = exports2.array = exports2.func = exports2.error = exports2.number = exports2.string = exports2.boolean = void 0;
   function boolean2(value) {
     return value === true || value === false;
   }
@@ -3149,69 +4399,37 @@ var require_is2 = __commonJS((exports2) => {
   exports2.objectLiteral = objectLiteral;
 });
 
-// node_modules/vscode-languageserver-protocol/lib/messages.js
-var require_messages2 = __commonJS((exports2) => {
-  "use strict";
-  Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
-  var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
-    constructor(method) {
-      super(method);
-    }
-  };
-  exports2.ProtocolRequestType0 = ProtocolRequestType0;
-  var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
-    constructor(method) {
-      super(method);
-    }
-  };
-  exports2.ProtocolRequestType = ProtocolRequestType;
-  var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
-    constructor(method) {
-      super(method);
-    }
-  };
-  exports2.ProtocolNotificationType = ProtocolNotificationType;
-  var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
-    constructor(method) {
-      super(method);
-    }
-  };
-  exports2.ProtocolNotificationType0 = ProtocolNotificationType0;
-});
-
-// node_modules/vscode-languageserver-protocol/lib/protocol.implementation.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js
 var require_protocol_implementation = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
+  exports2.ImplementationRequest = void 0;
   var messages_1 = require_messages2();
   var ImplementationRequest;
   (function(ImplementationRequest2) {
     ImplementationRequest2.method = "textDocument/implementation";
     ImplementationRequest2.type = new messages_1.ProtocolRequestType(ImplementationRequest2.method);
-    ImplementationRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(ImplementationRequest = exports2.ImplementationRequest || (exports2.ImplementationRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.typeDefinition.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js
 var require_protocol_typeDefinition = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
+  exports2.TypeDefinitionRequest = void 0;
   var messages_1 = require_messages2();
   var TypeDefinitionRequest;
   (function(TypeDefinitionRequest2) {
     TypeDefinitionRequest2.method = "textDocument/typeDefinition";
     TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest2.method);
-    TypeDefinitionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(TypeDefinitionRequest = exports2.TypeDefinitionRequest || (exports2.TypeDefinitionRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.workspaceFolders.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js
 var require_protocol_workspaceFolders = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.DidChangeWorkspaceFoldersNotification = exports2.WorkspaceFoldersRequest = void 0;
   var messages_1 = require_messages2();
   var WorkspaceFoldersRequest;
   (function(WorkspaceFoldersRequest2) {
@@ -3223,10 +4441,11 @@ var require_protocol_workspaceFolders = __commonJS((exports2) => {
   })(DidChangeWorkspaceFoldersNotification = exports2.DidChangeWorkspaceFoldersNotification || (exports2.DidChangeWorkspaceFoldersNotification = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.configuration.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js
 var require_protocol_configuration = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.ConfigurationRequest = void 0;
   var messages_1 = require_messages2();
   var ConfigurationRequest;
   (function(ConfigurationRequest2) {
@@ -3234,17 +4453,16 @@ var require_protocol_configuration = __commonJS((exports2) => {
   })(ConfigurationRequest = exports2.ConfigurationRequest || (exports2.ConfigurationRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.colorProvider.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js
 var require_protocol_colorProvider = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
+  exports2.ColorPresentationRequest = exports2.DocumentColorRequest = void 0;
   var messages_1 = require_messages2();
   var DocumentColorRequest;
   (function(DocumentColorRequest2) {
     DocumentColorRequest2.method = "textDocument/documentColor";
     DocumentColorRequest2.type = new messages_1.ProtocolRequestType(DocumentColorRequest2.method);
-    DocumentColorRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(DocumentColorRequest = exports2.DocumentColorRequest || (exports2.DocumentColorRequest = {}));
   var ColorPresentationRequest;
   (function(ColorPresentationRequest2) {
@@ -3252,11 +4470,11 @@ var require_protocol_colorProvider = __commonJS((exports2) => {
   })(ColorPresentationRequest = exports2.ColorPresentationRequest || (exports2.ColorPresentationRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.foldingRange.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js
 var require_protocol_foldingRange = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
+  exports2.FoldingRangeRequest = exports2.FoldingRangeKind = void 0;
   var messages_1 = require_messages2();
   var FoldingRangeKind;
   (function(FoldingRangeKind2) {
@@ -3268,47 +4486,49 @@ var require_protocol_foldingRange = __commonJS((exports2) => {
   (function(FoldingRangeRequest2) {
     FoldingRangeRequest2.method = "textDocument/foldingRange";
     FoldingRangeRequest2.type = new messages_1.ProtocolRequestType(FoldingRangeRequest2.method);
-    FoldingRangeRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(FoldingRangeRequest = exports2.FoldingRangeRequest || (exports2.FoldingRangeRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.declaration.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js
 var require_protocol_declaration = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
+  exports2.DeclarationRequest = void 0;
   var messages_1 = require_messages2();
   var DeclarationRequest;
   (function(DeclarationRequest2) {
     DeclarationRequest2.method = "textDocument/declaration";
     DeclarationRequest2.type = new messages_1.ProtocolRequestType(DeclarationRequest2.method);
-    DeclarationRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(DeclarationRequest = exports2.DeclarationRequest || (exports2.DeclarationRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.selectionRange.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js
 var require_protocol_selectionRange = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
+  exports2.SelectionRangeRequest = void 0;
   var messages_1 = require_messages2();
   var SelectionRangeRequest;
   (function(SelectionRangeRequest2) {
     SelectionRangeRequest2.method = "textDocument/selectionRange";
     SelectionRangeRequest2.type = new messages_1.ProtocolRequestType(SelectionRangeRequest2.method);
-    SelectionRangeRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(SelectionRangeRequest = exports2.SelectionRangeRequest || (exports2.SelectionRangeRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.progress.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js
 var require_protocol_progress = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCreateRequest = exports2.WorkDoneProgress = void 0;
   var vscode_jsonrpc_1 = require_main();
   var messages_1 = require_messages2();
   var WorkDoneProgress;
   (function(WorkDoneProgress2) {
     WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
+    function is2(value) {
+      return value === WorkDoneProgress2.type;
+    }
+    WorkDoneProgress2.is = is2;
   })(WorkDoneProgress = exports2.WorkDoneProgress || (exports2.WorkDoneProgress = {}));
   var WorkDoneProgressCreateRequest;
   (function(WorkDoneProgressCreateRequest2) {
@@ -3320,35 +4540,342 @@ var require_protocol_progress = __commonJS((exports2) => {
   })(WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCancelNotification || (exports2.WorkDoneProgressCancelNotification = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.js
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js
+var require_protocol_callHierarchy = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyIncomingCallsRequest = exports2.CallHierarchyPrepareRequest = void 0;
+  var messages_1 = require_messages2();
+  var CallHierarchyPrepareRequest;
+  (function(CallHierarchyPrepareRequest2) {
+    CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
+    CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
+  })(CallHierarchyPrepareRequest = exports2.CallHierarchyPrepareRequest || (exports2.CallHierarchyPrepareRequest = {}));
+  var CallHierarchyIncomingCallsRequest;
+  (function(CallHierarchyIncomingCallsRequest2) {
+    CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
+    CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
+  })(CallHierarchyIncomingCallsRequest = exports2.CallHierarchyIncomingCallsRequest || (exports2.CallHierarchyIncomingCallsRequest = {}));
+  var CallHierarchyOutgoingCallsRequest;
+  (function(CallHierarchyOutgoingCallsRequest2) {
+    CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
+    CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
+  })(CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyOutgoingCallsRequest || (exports2.CallHierarchyOutgoingCallsRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js
+var require_protocol_semanticTokens = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.SemanticTokensRefreshRequest = exports2.SemanticTokensRangeRequest = exports2.SemanticTokensDeltaRequest = exports2.SemanticTokensRequest = exports2.SemanticTokensRegistrationType = exports2.TokenFormat = exports2.SemanticTokens = exports2.SemanticTokenModifiers = exports2.SemanticTokenTypes = void 0;
+  var messages_1 = require_messages2();
+  var SemanticTokenTypes;
+  (function(SemanticTokenTypes2) {
+    SemanticTokenTypes2["namespace"] = "namespace";
+    SemanticTokenTypes2["type"] = "type";
+    SemanticTokenTypes2["class"] = "class";
+    SemanticTokenTypes2["enum"] = "enum";
+    SemanticTokenTypes2["interface"] = "interface";
+    SemanticTokenTypes2["struct"] = "struct";
+    SemanticTokenTypes2["typeParameter"] = "typeParameter";
+    SemanticTokenTypes2["parameter"] = "parameter";
+    SemanticTokenTypes2["variable"] = "variable";
+    SemanticTokenTypes2["property"] = "property";
+    SemanticTokenTypes2["enumMember"] = "enumMember";
+    SemanticTokenTypes2["event"] = "event";
+    SemanticTokenTypes2["function"] = "function";
+    SemanticTokenTypes2["method"] = "method";
+    SemanticTokenTypes2["macro"] = "macro";
+    SemanticTokenTypes2["keyword"] = "keyword";
+    SemanticTokenTypes2["modifier"] = "modifier";
+    SemanticTokenTypes2["comment"] = "comment";
+    SemanticTokenTypes2["string"] = "string";
+    SemanticTokenTypes2["number"] = "number";
+    SemanticTokenTypes2["regexp"] = "regexp";
+    SemanticTokenTypes2["operator"] = "operator";
+  })(SemanticTokenTypes = exports2.SemanticTokenTypes || (exports2.SemanticTokenTypes = {}));
+  var SemanticTokenModifiers;
+  (function(SemanticTokenModifiers2) {
+    SemanticTokenModifiers2["declaration"] = "declaration";
+    SemanticTokenModifiers2["definition"] = "definition";
+    SemanticTokenModifiers2["readonly"] = "readonly";
+    SemanticTokenModifiers2["static"] = "static";
+    SemanticTokenModifiers2["deprecated"] = "deprecated";
+    SemanticTokenModifiers2["abstract"] = "abstract";
+    SemanticTokenModifiers2["async"] = "async";
+    SemanticTokenModifiers2["modification"] = "modification";
+    SemanticTokenModifiers2["documentation"] = "documentation";
+    SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
+  })(SemanticTokenModifiers = exports2.SemanticTokenModifiers || (exports2.SemanticTokenModifiers = {}));
+  var SemanticTokens;
+  (function(SemanticTokens2) {
+    function is2(value) {
+      const candidate = value;
+      return candidate !== void 0 && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
+    }
+    SemanticTokens2.is = is2;
+  })(SemanticTokens = exports2.SemanticTokens || (exports2.SemanticTokens = {}));
+  var TokenFormat;
+  (function(TokenFormat2) {
+    TokenFormat2.Relative = "relative";
+  })(TokenFormat = exports2.TokenFormat || (exports2.TokenFormat = {}));
+  var SemanticTokensRegistrationType;
+  (function(SemanticTokensRegistrationType2) {
+    SemanticTokensRegistrationType2.method = "textDocument/semanticTokens";
+    SemanticTokensRegistrationType2.type = new messages_1.RegistrationType(SemanticTokensRegistrationType2.method);
+  })(SemanticTokensRegistrationType = exports2.SemanticTokensRegistrationType || (exports2.SemanticTokensRegistrationType = {}));
+  var SemanticTokensRequest;
+  (function(SemanticTokensRequest2) {
+    SemanticTokensRequest2.method = "textDocument/semanticTokens/full";
+    SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
+  })(SemanticTokensRequest = exports2.SemanticTokensRequest || (exports2.SemanticTokensRequest = {}));
+  var SemanticTokensDeltaRequest;
+  (function(SemanticTokensDeltaRequest2) {
+    SemanticTokensDeltaRequest2.method = "textDocument/semanticTokens/full/delta";
+    SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest2.method);
+  })(SemanticTokensDeltaRequest = exports2.SemanticTokensDeltaRequest || (exports2.SemanticTokensDeltaRequest = {}));
+  var SemanticTokensRangeRequest;
+  (function(SemanticTokensRangeRequest2) {
+    SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
+    SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
+  })(SemanticTokensRangeRequest = exports2.SemanticTokensRangeRequest || (exports2.SemanticTokensRangeRequest = {}));
+  var SemanticTokensRefreshRequest;
+  (function(SemanticTokensRefreshRequest2) {
+    SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`;
+    SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest2.method);
+  })(SemanticTokensRefreshRequest = exports2.SemanticTokensRefreshRequest || (exports2.SemanticTokensRefreshRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js
+var require_protocol_showDocument = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.ShowDocumentRequest = void 0;
+  var messages_1 = require_messages2();
+  var ShowDocumentRequest;
+  (function(ShowDocumentRequest2) {
+    ShowDocumentRequest2.method = "window/showDocument";
+    ShowDocumentRequest2.type = new messages_1.ProtocolRequestType(ShowDocumentRequest2.method);
+  })(ShowDocumentRequest = exports2.ShowDocumentRequest || (exports2.ShowDocumentRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js
+var require_protocol_linkedEditingRange = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.LinkedEditingRangeRequest = void 0;
+  var messages_1 = require_messages2();
+  var LinkedEditingRangeRequest;
+  (function(LinkedEditingRangeRequest2) {
+    LinkedEditingRangeRequest2.method = "textDocument/linkedEditingRange";
+    LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest2.method);
+  })(LinkedEditingRangeRequest = exports2.LinkedEditingRangeRequest || (exports2.LinkedEditingRangeRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js
+var require_protocol_fileOperations = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.WillDeleteFilesRequest = exports2.DidDeleteFilesNotification = exports2.DidRenameFilesNotification = exports2.WillRenameFilesRequest = exports2.DidCreateFilesNotification = exports2.WillCreateFilesRequest = exports2.FileOperationPatternKind = void 0;
+  var messages_1 = require_messages2();
+  var FileOperationPatternKind;
+  (function(FileOperationPatternKind2) {
+    FileOperationPatternKind2.file = "file";
+    FileOperationPatternKind2.folder = "folder";
+  })(FileOperationPatternKind = exports2.FileOperationPatternKind || (exports2.FileOperationPatternKind = {}));
+  var WillCreateFilesRequest;
+  (function(WillCreateFilesRequest2) {
+    WillCreateFilesRequest2.method = "workspace/willCreateFiles";
+    WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest2.method);
+  })(WillCreateFilesRequest = exports2.WillCreateFilesRequest || (exports2.WillCreateFilesRequest = {}));
+  var DidCreateFilesNotification;
+  (function(DidCreateFilesNotification2) {
+    DidCreateFilesNotification2.method = "workspace/didCreateFiles";
+    DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification2.method);
+  })(DidCreateFilesNotification = exports2.DidCreateFilesNotification || (exports2.DidCreateFilesNotification = {}));
+  var WillRenameFilesRequest;
+  (function(WillRenameFilesRequest2) {
+    WillRenameFilesRequest2.method = "workspace/willRenameFiles";
+    WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest2.method);
+  })(WillRenameFilesRequest = exports2.WillRenameFilesRequest || (exports2.WillRenameFilesRequest = {}));
+  var DidRenameFilesNotification;
+  (function(DidRenameFilesNotification2) {
+    DidRenameFilesNotification2.method = "workspace/didRenameFiles";
+    DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification2.method);
+  })(DidRenameFilesNotification = exports2.DidRenameFilesNotification || (exports2.DidRenameFilesNotification = {}));
+  var DidDeleteFilesNotification;
+  (function(DidDeleteFilesNotification2) {
+    DidDeleteFilesNotification2.method = "workspace/didDeleteFiles";
+    DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification2.method);
+  })(DidDeleteFilesNotification = exports2.DidDeleteFilesNotification || (exports2.DidDeleteFilesNotification = {}));
+  var WillDeleteFilesRequest;
+  (function(WillDeleteFilesRequest2) {
+    WillDeleteFilesRequest2.method = "workspace/willDeleteFiles";
+    WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest2.method);
+  })(WillDeleteFilesRequest = exports2.WillDeleteFilesRequest || (exports2.WillDeleteFilesRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js
+var require_protocol_moniker = __commonJS((exports2) => {
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.MonikerRequest = exports2.MonikerKind = exports2.UniquenessLevel = void 0;
+  var messages_1 = require_messages2();
+  var UniquenessLevel;
+  (function(UniquenessLevel2) {
+    UniquenessLevel2["document"] = "document";
+    UniquenessLevel2["project"] = "project";
+    UniquenessLevel2["group"] = "group";
+    UniquenessLevel2["scheme"] = "scheme";
+    UniquenessLevel2["global"] = "global";
+  })(UniquenessLevel = exports2.UniquenessLevel || (exports2.UniquenessLevel = {}));
+  var MonikerKind;
+  (function(MonikerKind2) {
+    MonikerKind2["import"] = "import";
+    MonikerKind2["export"] = "export";
+    MonikerKind2["local"] = "local";
+  })(MonikerKind = exports2.MonikerKind || (exports2.MonikerKind = {}));
+  var MonikerRequest;
+  (function(MonikerRequest2) {
+    MonikerRequest2.method = "textDocument/moniker";
+    MonikerRequest2.type = new messages_1.ProtocolRequestType(MonikerRequest2.method);
+  })(MonikerRequest = exports2.MonikerRequest || (exports2.MonikerRequest = {}));
+});
+
+// node_modules/vscode-languageserver-protocol/lib/common/protocol.js
 var require_protocol = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
+  exports2.DocumentLinkRequest = exports2.CodeLensRefreshRequest = exports2.CodeLensResolveRequest = exports2.CodeLensRequest = exports2.WorkspaceSymbolRequest = exports2.CodeActionResolveRequest = exports2.CodeActionRequest = exports2.DocumentSymbolRequest = exports2.DocumentHighlightRequest = exports2.ReferencesRequest = exports2.DefinitionRequest = exports2.SignatureHelpRequest = exports2.SignatureHelpTriggerKind = exports2.HoverRequest = exports2.CompletionResolveRequest = exports2.CompletionRequest = exports2.CompletionTriggerKind = exports2.PublishDiagnosticsNotification = exports2.WatchKind = exports2.FileChangeType = exports2.DidChangeWatchedFilesNotification = exports2.WillSaveTextDocumentWaitUntilRequest = exports2.WillSaveTextDocumentNotification = exports2.TextDocumentSaveReason = exports2.DidSaveTextDocumentNotification = exports2.DidCloseTextDocumentNotification = exports2.DidChangeTextDocumentNotification = exports2.TextDocumentContentChangeEvent = exports2.DidOpenTextDocumentNotification = exports2.TextDocumentSyncKind = exports2.TelemetryEventNotification = exports2.LogMessageNotification = exports2.ShowMessageRequest = exports2.ShowMessageNotification = exports2.MessageType = exports2.DidChangeConfigurationNotification = exports2.ExitNotification = exports2.ShutdownRequest = exports2.InitializedNotification = exports2.InitializeError = exports2.InitializeRequest = exports2.WorkDoneProgressOptions = exports2.TextDocumentRegistrationOptions = exports2.StaticRegistrationOptions = exports2.FailureHandlingKind = exports2.ResourceOperationKind = exports2.UnregistrationRequest = exports2.RegistrationRequest = exports2.DocumentSelector = exports2.DocumentFilter = void 0;
+  exports2.MonikerRequest = exports2.MonikerKind = exports2.UniquenessLevel = exports2.WillDeleteFilesRequest = exports2.DidDeleteFilesNotification = exports2.WillRenameFilesRequest = exports2.DidRenameFilesNotification = exports2.WillCreateFilesRequest = exports2.DidCreateFilesNotification = exports2.FileOperationPatternKind = exports2.LinkedEditingRangeRequest = exports2.ShowDocumentRequest = exports2.SemanticTokensRegistrationType = exports2.SemanticTokensRefreshRequest = exports2.SemanticTokensRangeRequest = exports2.SemanticTokensDeltaRequest = exports2.SemanticTokensRequest = exports2.TokenFormat = exports2.SemanticTokens = exports2.SemanticTokenModifiers = exports2.SemanticTokenTypes = exports2.CallHierarchyPrepareRequest = exports2.CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyIncomingCallsRequest = exports2.WorkDoneProgressCancelNotification = exports2.WorkDoneProgressCreateRequest = exports2.WorkDoneProgress = exports2.SelectionRangeRequest = exports2.DeclarationRequest = exports2.FoldingRangeRequest = exports2.ColorPresentationRequest = exports2.DocumentColorRequest = exports2.ConfigurationRequest = exports2.DidChangeWorkspaceFoldersNotification = exports2.WorkspaceFoldersRequest = exports2.TypeDefinitionRequest = exports2.ImplementationRequest = exports2.ApplyWorkspaceEditRequest = exports2.ExecuteCommandRequest = exports2.PrepareRenameRequest = exports2.RenameRequest = exports2.PrepareSupportDefaultBehavior = exports2.DocumentOnTypeFormattingRequest = exports2.DocumentRangeFormattingRequest = exports2.DocumentFormattingRequest = exports2.DocumentLinkResolveRequest = void 0;
   var Is = require_is2();
-  var vscode_jsonrpc_1 = require_main();
   var messages_1 = require_messages2();
   var protocol_implementation_1 = require_protocol_implementation();
-  exports2.ImplementationRequest = protocol_implementation_1.ImplementationRequest;
+  Object.defineProperty(exports2, "ImplementationRequest", {enumerable: true, get: function() {
+    return protocol_implementation_1.ImplementationRequest;
+  }});
   var protocol_typeDefinition_1 = require_protocol_typeDefinition();
-  exports2.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest;
+  Object.defineProperty(exports2, "TypeDefinitionRequest", {enumerable: true, get: function() {
+    return protocol_typeDefinition_1.TypeDefinitionRequest;
+  }});
   var protocol_workspaceFolders_1 = require_protocol_workspaceFolders();
-  exports2.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest;
-  exports2.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
+  Object.defineProperty(exports2, "WorkspaceFoldersRequest", {enumerable: true, get: function() {
+    return protocol_workspaceFolders_1.WorkspaceFoldersRequest;
+  }});
+  Object.defineProperty(exports2, "DidChangeWorkspaceFoldersNotification", {enumerable: true, get: function() {
+    return protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
+  }});
   var protocol_configuration_1 = require_protocol_configuration();
-  exports2.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest;
+  Object.defineProperty(exports2, "ConfigurationRequest", {enumerable: true, get: function() {
+    return protocol_configuration_1.ConfigurationRequest;
+  }});
   var protocol_colorProvider_1 = require_protocol_colorProvider();
-  exports2.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest;
-  exports2.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest;
+  Object.defineProperty(exports2, "DocumentColorRequest", {enumerable: true, get: function() {
+    return protocol_colorProvider_1.DocumentColorRequest;
+  }});
+  Object.defineProperty(exports2, "ColorPresentationRequest", {enumerable: true, get: function() {
+    return protocol_colorProvider_1.ColorPresentationRequest;
+  }});
   var protocol_foldingRange_1 = require_protocol_foldingRange();
-  exports2.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest;
+  Object.defineProperty(exports2, "FoldingRangeRequest", {enumerable: true, get: function() {
+    return protocol_foldingRange_1.FoldingRangeRequest;
+  }});
   var protocol_declaration_1 = require_protocol_declaration();
-  exports2.DeclarationRequest = protocol_declaration_1.DeclarationRequest;
+  Object.defineProperty(exports2, "DeclarationRequest", {enumerable: true, get: function() {
+    return protocol_declaration_1.DeclarationRequest;
+  }});
   var protocol_selectionRange_1 = require_protocol_selectionRange();
-  exports2.SelectionRangeRequest = protocol_selectionRange_1.SelectionRangeRequest;
+  Object.defineProperty(exports2, "SelectionRangeRequest", {enumerable: true, get: function() {
+    return protocol_selectionRange_1.SelectionRangeRequest;
+  }});
   var protocol_progress_1 = require_protocol_progress();
-  exports2.WorkDoneProgress = protocol_progress_1.WorkDoneProgress;
-  exports2.WorkDoneProgressCreateRequest = protocol_progress_1.WorkDoneProgressCreateRequest;
-  exports2.WorkDoneProgressCancelNotification = protocol_progress_1.WorkDoneProgressCancelNotification;
+  Object.defineProperty(exports2, "WorkDoneProgress", {enumerable: true, get: function() {
+    return protocol_progress_1.WorkDoneProgress;
+  }});
+  Object.defineProperty(exports2, "WorkDoneProgressCreateRequest", {enumerable: true, get: function() {
+    return protocol_progress_1.WorkDoneProgressCreateRequest;
+  }});
+  Object.defineProperty(exports2, "WorkDoneProgressCancelNotification", {enumerable: true, get: function() {
+    return protocol_progress_1.WorkDoneProgressCancelNotification;
+  }});
+  var protocol_callHierarchy_1 = require_protocol_callHierarchy();
+  Object.defineProperty(exports2, "CallHierarchyIncomingCallsRequest", {enumerable: true, get: function() {
+    return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest;
+  }});
+  Object.defineProperty(exports2, "CallHierarchyOutgoingCallsRequest", {enumerable: true, get: function() {
+    return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest;
+  }});
+  Object.defineProperty(exports2, "CallHierarchyPrepareRequest", {enumerable: true, get: function() {
+    return protocol_callHierarchy_1.CallHierarchyPrepareRequest;
+  }});
+  var protocol_semanticTokens_1 = require_protocol_semanticTokens();
+  Object.defineProperty(exports2, "SemanticTokenTypes", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokenTypes;
+  }});
+  Object.defineProperty(exports2, "SemanticTokenModifiers", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokenModifiers;
+  }});
+  Object.defineProperty(exports2, "SemanticTokens", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokens;
+  }});
+  Object.defineProperty(exports2, "TokenFormat", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.TokenFormat;
+  }});
+  Object.defineProperty(exports2, "SemanticTokensRequest", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokensRequest;
+  }});
+  Object.defineProperty(exports2, "SemanticTokensDeltaRequest", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokensDeltaRequest;
+  }});
+  Object.defineProperty(exports2, "SemanticTokensRangeRequest", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokensRangeRequest;
+  }});
+  Object.defineProperty(exports2, "SemanticTokensRefreshRequest", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokensRefreshRequest;
+  }});
+  Object.defineProperty(exports2, "SemanticTokensRegistrationType", {enumerable: true, get: function() {
+    return protocol_semanticTokens_1.SemanticTokensRegistrationType;
+  }});
+  var protocol_showDocument_1 = require_protocol_showDocument();
+  Object.defineProperty(exports2, "ShowDocumentRequest", {enumerable: true, get: function() {
+    return protocol_showDocument_1.ShowDocumentRequest;
+  }});
+  var protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange();
+  Object.defineProperty(exports2, "LinkedEditingRangeRequest", {enumerable: true, get: function() {
+    return protocol_linkedEditingRange_1.LinkedEditingRangeRequest;
+  }});
+  var protocol_fileOperations_1 = require_protocol_fileOperations();
+  Object.defineProperty(exports2, "FileOperationPatternKind", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.FileOperationPatternKind;
+  }});
+  Object.defineProperty(exports2, "DidCreateFilesNotification", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.DidCreateFilesNotification;
+  }});
+  Object.defineProperty(exports2, "WillCreateFilesRequest", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.WillCreateFilesRequest;
+  }});
+  Object.defineProperty(exports2, "DidRenameFilesNotification", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.DidRenameFilesNotification;
+  }});
+  Object.defineProperty(exports2, "WillRenameFilesRequest", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.WillRenameFilesRequest;
+  }});
+  Object.defineProperty(exports2, "DidDeleteFilesNotification", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.DidDeleteFilesNotification;
+  }});
+  Object.defineProperty(exports2, "WillDeleteFilesRequest", {enumerable: true, get: function() {
+    return protocol_fileOperations_1.WillDeleteFilesRequest;
+  }});
+  var protocol_moniker_1 = require_protocol_moniker();
+  Object.defineProperty(exports2, "UniquenessLevel", {enumerable: true, get: function() {
+    return protocol_moniker_1.UniquenessLevel;
+  }});
+  Object.defineProperty(exports2, "MonikerKind", {enumerable: true, get: function() {
+    return protocol_moniker_1.MonikerKind;
+  }});
+  Object.defineProperty(exports2, "MonikerRequest", {enumerable: true, get: function() {
+    return protocol_moniker_1.MonikerRequest;
+  }});
   var DocumentFilter;
   (function(DocumentFilter2) {
     function is2(value) {
@@ -3480,6 +5007,19 @@ var require_protocol = __commonJS((exports2) => {
     DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
     DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
   })(DidOpenTextDocumentNotification = exports2.DidOpenTextDocumentNotification || (exports2.DidOpenTextDocumentNotification = {}));
+  var TextDocumentContentChangeEvent2;
+  (function(TextDocumentContentChangeEvent3) {
+    function isIncremental(event) {
+      let candidate = event;
+      return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
+    }
+    TextDocumentContentChangeEvent3.isIncremental = isIncremental;
+    function isFull(event) {
+      let candidate = event;
+      return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
+    }
+    TextDocumentContentChangeEvent3.isFull = isFull;
+  })(TextDocumentContentChangeEvent2 = exports2.TextDocumentContentChangeEvent || (exports2.TextDocumentContentChangeEvent = {}));
   var DidChangeTextDocumentNotification;
   (function(DidChangeTextDocumentNotification2) {
     DidChangeTextDocumentNotification2.method = "textDocument/didChange";
@@ -3541,7 +5081,6 @@ var require_protocol = __commonJS((exports2) => {
   (function(CompletionRequest2) {
     CompletionRequest2.method = "textDocument/completion";
     CompletionRequest2.type = new messages_1.ProtocolRequestType(CompletionRequest2.method);
-    CompletionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(CompletionRequest = exports2.CompletionRequest || (exports2.CompletionRequest = {}));
   var CompletionResolveRequest;
   (function(CompletionResolveRequest2) {
@@ -3568,56 +5107,61 @@ var require_protocol = __commonJS((exports2) => {
   (function(DefinitionRequest2) {
     DefinitionRequest2.method = "textDocument/definition";
     DefinitionRequest2.type = new messages_1.ProtocolRequestType(DefinitionRequest2.method);
-    DefinitionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(DefinitionRequest = exports2.DefinitionRequest || (exports2.DefinitionRequest = {}));
   var ReferencesRequest;
   (function(ReferencesRequest2) {
     ReferencesRequest2.method = "textDocument/references";
     ReferencesRequest2.type = new messages_1.ProtocolRequestType(ReferencesRequest2.method);
-    ReferencesRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(ReferencesRequest = exports2.ReferencesRequest || (exports2.ReferencesRequest = {}));
   var DocumentHighlightRequest;
   (function(DocumentHighlightRequest2) {
     DocumentHighlightRequest2.method = "textDocument/documentHighlight";
     DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest2.method);
-    DocumentHighlightRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(DocumentHighlightRequest = exports2.DocumentHighlightRequest || (exports2.DocumentHighlightRequest = {}));
   var DocumentSymbolRequest;
   (function(DocumentSymbolRequest2) {
     DocumentSymbolRequest2.method = "textDocument/documentSymbol";
     DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest2.method);
-    DocumentSymbolRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(DocumentSymbolRequest = exports2.DocumentSymbolRequest || (exports2.DocumentSymbolRequest = {}));
   var CodeActionRequest;
   (function(CodeActionRequest2) {
     CodeActionRequest2.method = "textDocument/codeAction";
     CodeActionRequest2.type = new messages_1.ProtocolRequestType(CodeActionRequest2.method);
-    CodeActionRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(CodeActionRequest = exports2.CodeActionRequest || (exports2.CodeActionRequest = {}));
+  var CodeActionResolveRequest;
+  (function(CodeActionResolveRequest2) {
+    CodeActionResolveRequest2.method = "codeAction/resolve";
+    CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest2.method);
+  })(CodeActionResolveRequest = exports2.CodeActionResolveRequest || (exports2.CodeActionResolveRequest = {}));
   var WorkspaceSymbolRequest;
   (function(WorkspaceSymbolRequest2) {
     WorkspaceSymbolRequest2.method = "workspace/symbol";
     WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest2.method);
-    WorkspaceSymbolRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(WorkspaceSymbolRequest = exports2.WorkspaceSymbolRequest || (exports2.WorkspaceSymbolRequest = {}));
   var CodeLensRequest;
   (function(CodeLensRequest2) {
-    CodeLensRequest2.type = new messages_1.ProtocolRequestType("textDocument/codeLens");
-    CodeLensRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
+    CodeLensRequest2.method = "textDocument/codeLens";
+    CodeLensRequest2.type = new messages_1.ProtocolRequestType(CodeLensRequest2.method);
   })(CodeLensRequest = exports2.CodeLensRequest || (exports2.CodeLensRequest = {}));
   var CodeLensResolveRequest;
   (function(CodeLensResolveRequest2) {
-    CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType("codeLens/resolve");
+    CodeLensResolveRequest2.method = "codeLens/resolve";
+    CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest2.method);
   })(CodeLensResolveRequest = exports2.CodeLensResolveRequest || (exports2.CodeLensResolveRequest = {}));
+  var CodeLensRefreshRequest;
+  (function(CodeLensRefreshRequest2) {
+    CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`;
+    CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest2.method);
+  })(CodeLensRefreshRequest = exports2.CodeLensRefreshRequest || (exports2.CodeLensRefreshRequest = {}));
   var DocumentLinkRequest;
   (function(DocumentLinkRequest2) {
     DocumentLinkRequest2.method = "textDocument/documentLink";
     DocumentLinkRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkRequest2.method);
-    DocumentLinkRequest2.resultType = new vscode_jsonrpc_1.ProgressType();
   })(DocumentLinkRequest = exports2.DocumentLinkRequest || (exports2.DocumentLinkRequest = {}));
   var DocumentLinkResolveRequest;
   (function(DocumentLinkResolveRequest2) {
-    DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType("documentLink/resolve");
+    DocumentLinkResolveRequest2.method = "documentLink/resolve";
+    DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest2.method);
   })(DocumentLinkResolveRequest = exports2.DocumentLinkResolveRequest || (exports2.DocumentLinkResolveRequest = {}));
   var DocumentFormattingRequest;
   (function(DocumentFormattingRequest2) {
@@ -3634,6 +5178,10 @@ var require_protocol = __commonJS((exports2) => {
     DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
     DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
   })(DocumentOnTypeFormattingRequest = exports2.DocumentOnTypeFormattingRequest || (exports2.DocumentOnTypeFormattingRequest = {}));
+  var PrepareSupportDefaultBehavior;
+  (function(PrepareSupportDefaultBehavior2) {
+    PrepareSupportDefaultBehavior2.Identifier = 1;
+  })(PrepareSupportDefaultBehavior = exports2.PrepareSupportDefaultBehavior || (exports2.PrepareSupportDefaultBehavior = {}));
   var RenameRequest;
   (function(RenameRequest2) {
     RenameRequest2.method = "textDocument/rename";
@@ -3654,174 +5202,85 @@ var require_protocol = __commonJS((exports2) => {
   })(ApplyWorkspaceEditRequest = exports2.ApplyWorkspaceEditRequest || (exports2.ApplyWorkspaceEditRequest = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.callHierarchy.proposed.js
-var require_protocol_callHierarchy_proposed = __commonJS((exports2) => {
+// node_modules/vscode-languageserver-protocol/lib/common/connection.js
+var require_connection2 = __commonJS((exports2) => {
   "use strict";
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var messages_1 = require_messages2();
-  var CallHierarchyPrepareRequest;
-  (function(CallHierarchyPrepareRequest2) {
-    CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
-    CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
-  })(CallHierarchyPrepareRequest = exports2.CallHierarchyPrepareRequest || (exports2.CallHierarchyPrepareRequest = {}));
-  var CallHierarchyIncomingCallsRequest;
-  (function(CallHierarchyIncomingCallsRequest2) {
-    CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
-    CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
-  })(CallHierarchyIncomingCallsRequest = exports2.CallHierarchyIncomingCallsRequest || (exports2.CallHierarchyIncomingCallsRequest = {}));
-  var CallHierarchyOutgoingCallsRequest;
-  (function(CallHierarchyOutgoingCallsRequest2) {
-    CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
-    CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
-  })(CallHierarchyOutgoingCallsRequest = exports2.CallHierarchyOutgoingCallsRequest || (exports2.CallHierarchyOutgoingCallsRequest = {}));
+  exports2.createProtocolConnection = void 0;
+  var vscode_jsonrpc_1 = require_main();
+  function createProtocolConnection(input, output, logger, options) {
+    if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
+      options = {connectionStrategy: options};
+    }
+    return vscode_jsonrpc_1.createMessageConnection(input, output, logger, options);
+  }
+  exports2.createProtocolConnection = createProtocolConnection;
 });
 
-// node_modules/vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.js
-var require_protocol_sematicTokens_proposed = __commonJS((exports2) => {
+// node_modules/vscode-languageserver-protocol/lib/common/api.js
+var require_api2 = __commonJS((exports2) => {
   "use strict";
+  var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    Object.defineProperty(o, k2, {enumerable: true, get: function() {
+      return m[k];
+    }});
+  } : function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+        __createBinding(exports3, m, p);
+  };
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var messages_1 = require_messages2();
-  var SemanticTokenTypes;
-  (function(SemanticTokenTypes2) {
-    SemanticTokenTypes2["comment"] = "comment";
-    SemanticTokenTypes2["keyword"] = "keyword";
-    SemanticTokenTypes2["string"] = "string";
-    SemanticTokenTypes2["number"] = "number";
-    SemanticTokenTypes2["regexp"] = "regexp";
-    SemanticTokenTypes2["operator"] = "operator";
-    SemanticTokenTypes2["namespace"] = "namespace";
-    SemanticTokenTypes2["type"] = "type";
-    SemanticTokenTypes2["struct"] = "struct";
-    SemanticTokenTypes2["class"] = "class";
-    SemanticTokenTypes2["interface"] = "interface";
-    SemanticTokenTypes2["enum"] = "enum";
-    SemanticTokenTypes2["typeParameter"] = "typeParameter";
-    SemanticTokenTypes2["function"] = "function";
-    SemanticTokenTypes2["member"] = "member";
-    SemanticTokenTypes2["property"] = "property";
-    SemanticTokenTypes2["macro"] = "macro";
-    SemanticTokenTypes2["variable"] = "variable";
-    SemanticTokenTypes2["parameter"] = "parameter";
-    SemanticTokenTypes2["label"] = "label";
-  })(SemanticTokenTypes = exports2.SemanticTokenTypes || (exports2.SemanticTokenTypes = {}));
-  var SemanticTokenModifiers;
-  (function(SemanticTokenModifiers2) {
-    SemanticTokenModifiers2["documentation"] = "documentation";
-    SemanticTokenModifiers2["declaration"] = "declaration";
-    SemanticTokenModifiers2["definition"] = "definition";
-    SemanticTokenModifiers2["reference"] = "reference";
-    SemanticTokenModifiers2["static"] = "static";
-    SemanticTokenModifiers2["abstract"] = "abstract";
-    SemanticTokenModifiers2["deprecated"] = "deprecated";
-    SemanticTokenModifiers2["async"] = "async";
-    SemanticTokenModifiers2["volatile"] = "volatile";
-    SemanticTokenModifiers2["readonly"] = "readonly";
-  })(SemanticTokenModifiers = exports2.SemanticTokenModifiers || (exports2.SemanticTokenModifiers = {}));
-  var SemanticTokens;
-  (function(SemanticTokens2) {
-    function is2(value) {
-      const candidate = value;
-      return candidate !== void 0 && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
-    }
-    SemanticTokens2.is = is2;
-  })(SemanticTokens = exports2.SemanticTokens || (exports2.SemanticTokens = {}));
-  var SemanticTokensRequest;
-  (function(SemanticTokensRequest2) {
-    SemanticTokensRequest2.method = "textDocument/semanticTokens";
-    SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
-  })(SemanticTokensRequest = exports2.SemanticTokensRequest || (exports2.SemanticTokensRequest = {}));
-  var SemanticTokensEditsRequest;
-  (function(SemanticTokensEditsRequest2) {
-    SemanticTokensEditsRequest2.method = "textDocument/semanticTokens/edits";
-    SemanticTokensEditsRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensEditsRequest2.method);
-  })(SemanticTokensEditsRequest = exports2.SemanticTokensEditsRequest || (exports2.SemanticTokensEditsRequest = {}));
-  var SemanticTokensRangeRequest;
-  (function(SemanticTokensRangeRequest2) {
-    SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
-    SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
-  })(SemanticTokensRangeRequest = exports2.SemanticTokensRangeRequest || (exports2.SemanticTokensRangeRequest = {}));
+  exports2.LSPErrorCodes = exports2.createProtocolConnection = void 0;
+  __exportStar2(require_main(), exports2);
+  __exportStar2(require_main2(), exports2);
+  __exportStar2(require_messages2(), exports2);
+  __exportStar2(require_protocol(), exports2);
+  var connection_1 = require_connection2();
+  Object.defineProperty(exports2, "createProtocolConnection", {enumerable: true, get: function() {
+    return connection_1.createProtocolConnection;
+  }});
+  var LSPErrorCodes;
+  (function(LSPErrorCodes2) {
+    LSPErrorCodes2.lspReservedErrorRangeStart = -32899;
+    LSPErrorCodes2.ContentModified = -32801;
+    LSPErrorCodes2.RequestCancelled = -32800;
+    LSPErrorCodes2.lspReservedErrorRangeEnd = -32800;
+  })(LSPErrorCodes = exports2.LSPErrorCodes || (exports2.LSPErrorCodes = {}));
 });
 
-// node_modules/vscode-languageserver-protocol/lib/main.js
+// node_modules/vscode-languageserver-protocol/lib/node/main.js
 var require_main3 = __commonJS((exports2) => {
   "use strict";
-  function __export2(m) {
+  var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    Object.defineProperty(o, k2, {enumerable: true, get: function() {
+      return m[k];
+    }});
+  } : function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
     for (var p in m)
-      if (!exports2.hasOwnProperty(p))
-        exports2[p] = m[p];
-  }
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+        __createBinding(exports3, m, p);
+  };
   Object.defineProperty(exports2, "__esModule", {value: true});
-  var vscode_jsonrpc_1 = require_main();
-  exports2.ErrorCodes = vscode_jsonrpc_1.ErrorCodes;
-  exports2.ResponseError = vscode_jsonrpc_1.ResponseError;
-  exports2.CancellationToken = vscode_jsonrpc_1.CancellationToken;
-  exports2.CancellationTokenSource = vscode_jsonrpc_1.CancellationTokenSource;
-  exports2.Disposable = vscode_jsonrpc_1.Disposable;
-  exports2.Event = vscode_jsonrpc_1.Event;
-  exports2.Emitter = vscode_jsonrpc_1.Emitter;
-  exports2.Trace = vscode_jsonrpc_1.Trace;
-  exports2.TraceFormat = vscode_jsonrpc_1.TraceFormat;
-  exports2.SetTraceNotification = vscode_jsonrpc_1.SetTraceNotification;
-  exports2.LogTraceNotification = vscode_jsonrpc_1.LogTraceNotification;
-  exports2.RequestType = vscode_jsonrpc_1.RequestType;
-  exports2.RequestType0 = vscode_jsonrpc_1.RequestType0;
-  exports2.NotificationType = vscode_jsonrpc_1.NotificationType;
-  exports2.NotificationType0 = vscode_jsonrpc_1.NotificationType0;
-  exports2.MessageReader = vscode_jsonrpc_1.MessageReader;
-  exports2.MessageWriter = vscode_jsonrpc_1.MessageWriter;
-  exports2.ConnectionStrategy = vscode_jsonrpc_1.ConnectionStrategy;
-  exports2.StreamMessageReader = vscode_jsonrpc_1.StreamMessageReader;
-  exports2.StreamMessageWriter = vscode_jsonrpc_1.StreamMessageWriter;
-  exports2.IPCMessageReader = vscode_jsonrpc_1.IPCMessageReader;
-  exports2.IPCMessageWriter = vscode_jsonrpc_1.IPCMessageWriter;
-  exports2.createClientPipeTransport = vscode_jsonrpc_1.createClientPipeTransport;
-  exports2.createServerPipeTransport = vscode_jsonrpc_1.createServerPipeTransport;
-  exports2.generateRandomPipeName = vscode_jsonrpc_1.generateRandomPipeName;
-  exports2.createClientSocketTransport = vscode_jsonrpc_1.createClientSocketTransport;
-  exports2.createServerSocketTransport = vscode_jsonrpc_1.createServerSocketTransport;
-  exports2.ProgressType = vscode_jsonrpc_1.ProgressType;
-  __export2(require_main2());
-  __export2(require_protocol());
-  var callHierarchy = require_protocol_callHierarchy_proposed();
-  var st = require_protocol_sematicTokens_proposed();
-  var Proposed;
-  (function(Proposed2) {
-    let CallHierarchyPrepareRequest;
-    (function(CallHierarchyPrepareRequest2) {
-      CallHierarchyPrepareRequest2.method = callHierarchy.CallHierarchyPrepareRequest.method;
-      CallHierarchyPrepareRequest2.type = callHierarchy.CallHierarchyPrepareRequest.type;
-    })(CallHierarchyPrepareRequest = Proposed2.CallHierarchyPrepareRequest || (Proposed2.CallHierarchyPrepareRequest = {}));
-    let CallHierarchyIncomingCallsRequest;
-    (function(CallHierarchyIncomingCallsRequest2) {
-      CallHierarchyIncomingCallsRequest2.method = callHierarchy.CallHierarchyIncomingCallsRequest.method;
-      CallHierarchyIncomingCallsRequest2.type = callHierarchy.CallHierarchyIncomingCallsRequest.type;
-    })(CallHierarchyIncomingCallsRequest = Proposed2.CallHierarchyIncomingCallsRequest || (Proposed2.CallHierarchyIncomingCallsRequest = {}));
-    let CallHierarchyOutgoingCallsRequest;
-    (function(CallHierarchyOutgoingCallsRequest2) {
-      CallHierarchyOutgoingCallsRequest2.method = callHierarchy.CallHierarchyOutgoingCallsRequest.method;
-      CallHierarchyOutgoingCallsRequest2.type = callHierarchy.CallHierarchyOutgoingCallsRequest.type;
-    })(CallHierarchyOutgoingCallsRequest = Proposed2.CallHierarchyOutgoingCallsRequest || (Proposed2.CallHierarchyOutgoingCallsRequest = {}));
-    Proposed2.SemanticTokenTypes = st.SemanticTokenTypes;
-    Proposed2.SemanticTokenModifiers = st.SemanticTokenModifiers;
-    Proposed2.SemanticTokens = st.SemanticTokens;
-    let SemanticTokensRequest;
-    (function(SemanticTokensRequest2) {
-      SemanticTokensRequest2.method = st.SemanticTokensRequest.method;
-      SemanticTokensRequest2.type = st.SemanticTokensRequest.type;
-    })(SemanticTokensRequest = Proposed2.SemanticTokensRequest || (Proposed2.SemanticTokensRequest = {}));
-    let SemanticTokensEditsRequest;
-    (function(SemanticTokensEditsRequest2) {
-      SemanticTokensEditsRequest2.method = st.SemanticTokensEditsRequest.method;
-      SemanticTokensEditsRequest2.type = st.SemanticTokensEditsRequest.type;
-    })(SemanticTokensEditsRequest = Proposed2.SemanticTokensEditsRequest || (Proposed2.SemanticTokensEditsRequest = {}));
-    let SemanticTokensRangeRequest;
-    (function(SemanticTokensRangeRequest2) {
-      SemanticTokensRangeRequest2.method = st.SemanticTokensRangeRequest.method;
-      SemanticTokensRangeRequest2.type = st.SemanticTokensRangeRequest.type;
-    })(SemanticTokensRangeRequest = Proposed2.SemanticTokensRangeRequest || (Proposed2.SemanticTokensRangeRequest = {}));
-  })(Proposed = exports2.Proposed || (exports2.Proposed = {}));
-  function createProtocolConnection(reader, writer, logger, strategy) {
-    return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy);
+  exports2.createProtocolConnection = void 0;
+  var node_1 = require_node();
+  __exportStar2(require_node(), exports2);
+  __exportStar2(require_api2(), exports2);
+  function createProtocolConnection(input, output, logger, options) {
+    return node_1.createMessageConnection(input, output, logger, options);
   }
   exports2.createProtocolConnection = createProtocolConnection;
 });
@@ -4450,7 +5909,7 @@ var require_coerce = __commonJS((exports2, module2) => {
 
 // node_modules/semver/classes/range.js
 var require_range = __commonJS((exports2, module2) => {
-  var Range15 = class {
+  var Range17 = class {
     constructor(range, options) {
       if (!options || typeof options !== "object") {
         options = {
@@ -4458,11 +5917,11 @@ var require_range = __commonJS((exports2, module2) => {
           includePrerelease: false
         };
       }
-      if (range instanceof Range15) {
+      if (range instanceof Range17) {
         if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
           return range;
         } else {
-          return new Range15(range.raw, options);
+          return new Range17(range.raw, options);
         }
       }
       if (range instanceof Comparator) {
@@ -4505,7 +5964,7 @@ var require_range = __commonJS((exports2, module2) => {
       return range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)).filter(this.options.loose ? (comp) => !!comp.match(compRe) : () => true).map((comp) => new Comparator(comp, this.options));
     }
     intersects(range, options) {
-      if (!(range instanceof Range15)) {
+      if (!(range instanceof Range17)) {
         throw new TypeError("a Range is required");
       }
       return this.set.some((thisComparators) => {
@@ -4537,7 +5996,7 @@ var require_range = __commonJS((exports2, module2) => {
       return false;
     }
   };
-  module2.exports = Range15;
+  module2.exports = Range17;
   var Comparator = require_comparator();
   var debug = require_debug();
   var SemVer = require_semver();
@@ -4843,12 +6302,12 @@ var require_comparator = __commonJS((exports2, module2) => {
         if (this.value === "") {
           return true;
         }
-        return new Range15(comp.value, options).test(this.value);
+        return new Range17(comp.value, options).test(this.value);
       } else if (comp.operator === "") {
         if (comp.value === "") {
           return true;
         }
-        return new Range15(this.value, options).test(comp.semver);
+        return new Range17(this.value, options).test(comp.semver);
       }
       const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
       const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
@@ -4864,15 +6323,15 @@ var require_comparator = __commonJS((exports2, module2) => {
   var cmp = require_cmp();
   var debug = require_debug();
   var SemVer = require_semver();
-  var Range15 = require_range();
+  var Range17 = require_range();
 });
 
 // node_modules/semver/functions/satisfies.js
 var require_satisfies = __commonJS((exports2, module2) => {
-  var Range15 = require_range();
+  var Range17 = require_range();
   var satisfies = (version, range, options) => {
     try {
-      range = new Range15(range, options);
+      range = new Range17(range, options);
     } catch (er) {
       return false;
     }
@@ -4883,21 +6342,21 @@ var require_satisfies = __commonJS((exports2, module2) => {
 
 // node_modules/semver/ranges/to-comparators.js
 var require_to_comparators = __commonJS((exports2, module2) => {
-  var Range15 = require_range();
-  var toComparators = (range, options) => new Range15(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+  var Range17 = require_range();
+  var toComparators = (range, options) => new Range17(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
   module2.exports = toComparators;
 });
 
 // node_modules/semver/ranges/max-satisfying.js
 var require_max_satisfying = __commonJS((exports2, module2) => {
   var SemVer = require_semver();
-  var Range15 = require_range();
+  var Range17 = require_range();
   var maxSatisfying = (versions, range, options) => {
     let max = null;
     let maxSV = null;
     let rangeObj = null;
     try {
-      rangeObj = new Range15(range, options);
+      rangeObj = new Range17(range, options);
     } catch (er) {
       return null;
     }
@@ -4917,13 +6376,13 @@ var require_max_satisfying = __commonJS((exports2, module2) => {
 // node_modules/semver/ranges/min-satisfying.js
 var require_min_satisfying = __commonJS((exports2, module2) => {
   var SemVer = require_semver();
-  var Range15 = require_range();
+  var Range17 = require_range();
   var minSatisfying = (versions, range, options) => {
     let min = null;
     let minSV = null;
     let rangeObj = null;
     try {
-      rangeObj = new Range15(range, options);
+      rangeObj = new Range17(range, options);
     } catch (er) {
       return null;
     }
@@ -4943,10 +6402,10 @@ var require_min_satisfying = __commonJS((exports2, module2) => {
 // node_modules/semver/ranges/min-version.js
 var require_min_version = __commonJS((exports2, module2) => {
   var SemVer = require_semver();
-  var Range15 = require_range();
+  var Range17 = require_range();
   var gt = require_gt();
   var minVersion = (range, loose) => {
-    range = new Range15(range, loose);
+    range = new Range17(range, loose);
     let minver = new SemVer("0.0.0");
     if (range.test(minver)) {
       return minver;
@@ -4992,10 +6451,10 @@ var require_min_version = __commonJS((exports2, module2) => {
 
 // node_modules/semver/ranges/valid.js
 var require_valid2 = __commonJS((exports2, module2) => {
-  var Range15 = require_range();
+  var Range17 = require_range();
   var validRange = (range, options) => {
     try {
-      return new Range15(range, options).range || "*";
+      return new Range17(range, options).range || "*";
     } catch (er) {
       return null;
     }
@@ -5008,7 +6467,7 @@ var require_outside = __commonJS((exports2, module2) => {
   var SemVer = require_semver();
   var Comparator = require_comparator();
   var {ANY} = Comparator;
-  var Range15 = require_range();
+  var Range17 = require_range();
   var satisfies = require_satisfies();
   var gt = require_gt();
   var lt = require_lt();
@@ -5016,7 +6475,7 @@ var require_outside = __commonJS((exports2, module2) => {
   var gte2 = require_gte();
   var outside = (version, range, hilo, options) => {
     version = new SemVer(version, options);
-    range = new Range15(range, options);
+    range = new Range17(range, options);
     let gtfn, ltefn, ltfn, comp, ecomp;
     switch (hilo) {
       case ">":
@@ -5085,10 +6544,10 @@ var require_ltr = __commonJS((exports2, module2) => {
 
 // node_modules/semver/ranges/intersects.js
 var require_intersects = __commonJS((exports2, module2) => {
-  var Range15 = require_range();
+  var Range17 = require_range();
   var intersects = (r1, r2, options) => {
-    r1 = new Range15(r1, options);
-    r2 = new Range15(r2, options);
+    r1 = new Range17(r1, options);
+    r2 = new Range17(r2, options);
     return r1.intersects(r2);
   };
   module2.exports = intersects;
@@ -5140,13 +6599,13 @@ var require_simplify = __commonJS((exports2, module2) => {
 
 // node_modules/semver/ranges/subset.js
 var require_subset = __commonJS((exports2, module2) => {
-  var Range15 = require_range();
+  var Range17 = require_range();
   var {ANY} = require_comparator();
   var satisfies = require_satisfies();
   var compare = require_compare();
   var subset = (sub, dom, options) => {
-    sub = new Range15(sub, options);
-    dom = new Range15(dom, options);
+    sub = new Range17(sub, options);
+    dom = new Range17(dom, options);
     let sawNonNull = false;
     OUTER:
       for (const simpleSub of sub.set) {
@@ -5296,7 +6755,7 @@ var require_windows = __commonJS((exports2, module2) => {
   module2.exports = isexe;
   isexe.sync = sync;
   var fs5 = require("fs");
-  function checkPathExt(path8, options) {
+  function checkPathExt(path9, options) {
     var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -5307,25 +6766,25 @@ var require_windows = __commonJS((exports2, module2) => {
     }
     for (var i = 0; i < pathext.length; i++) {
       var p = pathext[i].toLowerCase();
-      if (p && path8.substr(-p.length).toLowerCase() === p) {
+      if (p && path9.substr(-p.length).toLowerCase() === p) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat, path8, options) {
+  function checkStat(stat, path9, options) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path8, options);
+    return checkPathExt(path9, options);
   }
-  function isexe(path8, options, cb) {
-    fs5.stat(path8, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path8, options));
+  function isexe(path9, options, cb) {
+    fs5.stat(path9, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path9, options));
     });
   }
-  function sync(path8, options) {
-    return checkStat(fs5.statSync(path8), path8, options);
+  function sync(path9, options) {
+    return checkStat(fs5.statSync(path9), path9, options);
   }
 });
 
@@ -5334,13 +6793,13 @@ var require_mode = __commonJS((exports2, module2) => {
   module2.exports = isexe;
   isexe.sync = sync;
   var fs5 = require("fs");
-  function isexe(path8, options, cb) {
-    fs5.stat(path8, function(er, stat) {
+  function isexe(path9, options, cb) {
+    fs5.stat(path9, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options));
     });
   }
-  function sync(path8, options) {
-    return checkStat(fs5.statSync(path8), options);
+  function sync(path9, options) {
+    return checkStat(fs5.statSync(path9), options);
   }
   function checkStat(stat, options) {
     return stat.isFile() && checkMode(stat, options);
@@ -5371,7 +6830,7 @@ var require_isexe = __commonJS((exports2, module2) => {
   }
   module2.exports = isexe;
   isexe.sync = sync;
-  function isexe(path8, options, cb) {
+  function isexe(path9, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -5381,7 +6840,7 @@ var require_isexe = __commonJS((exports2, module2) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve, reject) {
-        isexe(path8, options || {}, function(er, is2) {
+        isexe(path9, options || {}, function(er, is2) {
           if (er) {
             reject(er);
           } else {
@@ -5390,7 +6849,7 @@ var require_isexe = __commonJS((exports2, module2) => {
         });
       });
     }
-    core(path8, options || {}, function(er, is2) {
+    core(path9, options || {}, function(er, is2) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -5400,9 +6859,9 @@ var require_isexe = __commonJS((exports2, module2) => {
       cb(er, is2);
     });
   }
-  function sync(path8, options) {
+  function sync(path9, options) {
     try {
-      return core.sync(path8, options || {});
+      return core.sync(path9, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -5416,7 +6875,7 @@ var require_isexe = __commonJS((exports2, module2) => {
 // node_modules/which/which.js
 var require_which = __commonJS((exports2, module2) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path8 = require("path");
+  var path9 = require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), {code: "ENOENT"});
@@ -5452,7 +6911,7 @@ var require_which = __commonJS((exports2, module2) => {
         return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path8.join(pathPart, cmd);
+      const pCmd = path9.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       resolve(subStep(p, i, 0));
     });
@@ -5479,7 +6938,7 @@ var require_which = __commonJS((exports2, module2) => {
     for (let i = 0; i < pathEnv.length; i++) {
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path8.join(pathPart, cmd);
+      const pCmd = path9.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j = 0; j < pathExt.length; j++) {
         const cur = p + pathExt[j];
@@ -5509,15 +6968,15 @@ var require_which = __commonJS((exports2, module2) => {
 __export(exports, {
   activate: () => activate
 });
-var import_coc32 = __toModule(require("coc.nvim"));
+var import_coc37 = __toModule(require("coc.nvim"));
 
 // src/server/index.ts
-var import_coc30 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol23 = __toModule(require_main3());
+var import_coc35 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol24 = __toModule(require_main3());
 
 // src/server/typescriptServiceClientHost.ts
-var import_coc29 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol22 = __toModule(require_main3());
+var import_coc34 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol23 = __toModule(require_main3());
 
 // src/utils/arrays.ts
 function equals(one, other, itemEquals = (a, b) => a === b) {
@@ -5599,6 +7058,8 @@ API.v381 = API2.fromSimpleString("3.8.1");
 API.v390 = API2.fromSimpleString("3.9.0");
 API.v400 = API2.fromSimpleString("4.0.0");
 API.v401 = API2.fromSimpleString("4.0.1");
+API.v420 = API2.fromSimpleString("4.2.0");
+API.v430 = API2.fromSimpleString("4.3.0");
 var api_default = API;
 
 // src/server/features/fileConfigurationManager.ts
@@ -5661,8 +7122,8 @@ var FileConfigurationManager = class {
   }
   formatEnabled(document) {
     let {languageId, uri} = document;
-    let language = languageId.startsWith("typescript") ? "typescript" : "javascript";
-    const config = import_coc.workspace.getConfiguration(`${language}.format`, uri);
+    let language2 = languageId.startsWith("typescript") ? "typescript" : "javascript";
+    const config = import_coc.workspace.getConfiguration(`${language2}.format`, uri);
     return config.get("enabled");
   }
   enableJavascript() {
@@ -5676,8 +7137,8 @@ var FileConfigurationManager = class {
       preferences: this.getPreferences(lang, document.uri)
     };
   }
-  getFormatOptions(options, language, uri) {
-    const config = import_coc.workspace.getConfiguration(`${language}.format`, uri);
+  getFormatOptions(options, language2, uri) {
+    const config = import_coc.workspace.getConfiguration(`${language2}.format`, uri);
     return {
       tabSize: options.tabSize,
       indentSize: options.tabSize,
@@ -5711,21 +7172,26 @@ var FileConfigurationManager = class {
       paths: config.get("paths", true),
       completeFunctionCalls: config.get("completeFunctionCalls", true),
       autoImports: config.get("autoImports", true),
+      importStatementSuggestions: config.get("importStatements", true),
+      includeCompletionsForImportStatements: config.get("includeCompletionsForImportStatements", true),
+      includeCompletionsWithSnippetText: config.get("includeCompletionsWithSnippetText", true),
       includeAutomaticOptionalChainCompletions: config.get("includeAutomaticOptionalChainCompletions", true)
     };
   }
-  getPreferences(language, uri) {
+  getPreferences(language2, uri) {
     if (this.client.apiVersion.lt(api_default.v290)) {
       return {};
     }
-    const config = import_coc.workspace.getConfiguration(`${language}.preferences`, uri);
+    const config = import_coc.workspace.getConfiguration(`${language2}.preferences`, uri);
     const preferences = {
       quotePreference: this.getQuoteStyle(config),
       importModuleSpecifierPreference: getImportModuleSpecifier(config),
       importModuleSpecifierEnding: getImportModuleSpecifierEndingPreference(config),
       allowTextChangesInNewFiles: uri.startsWith("file:"),
       allowRenameOfImportPath: true,
-      providePrefixAndSuffixTextForRename: config.get("renameShorthandProperties", true) === false ? false : config.get("useAliasesForRenames", true)
+      providePrefixAndSuffixTextForRename: config.get("renameShorthandProperties", true) === false ? false : config.get("useAliasesForRenames", true),
+      includeCompletionsForImportStatements: this.getCompleteOptions(language2).includeCompletionsForImportStatements,
+      includeCompletionsWithSnippetText: this.getCompleteOptions(language2).includeCompletionsWithSnippetText
     };
     return preferences;
   }
@@ -5743,12 +7209,14 @@ var fileConfigurationManager_default = FileConfigurationManager;
 function getImportModuleSpecifier(config) {
   let val = config.get("importModuleSpecifier");
   switch (val) {
+    case "project-relative":
+      return "project-relative";
     case "relative":
       return "relative";
     case "non-relative":
       return "non-relative";
     default:
-      return "auto";
+      return void 0;
   }
 }
 function getImportModuleSpecifierEndingPreference(config) {
@@ -5863,15 +7331,16 @@ var WatchProject2 = class {
       import_coc2.window.showMessage(`Local & global tsc not found`, "error");
       return;
     }
-    let find = await import_coc2.workspace.findUp(["tsconfig.json"]);
+    const tsconfigPath = import_coc2.workspace.getConfiguration("tsserver").get("tsconfigPath", "tsconfig.json");
+    let find = await import_coc2.workspace.findUp([tsconfigPath]);
     if (!find) {
-      import_coc2.window.showMessage("tsconfig.json not found!", "error");
+      import_coc2.window.showMessage(`${tsconfigPath} not found!`, "error");
       return;
     }
     let root = import_path.default.dirname(find);
     return {
       cmd: tscPath,
-      args: ["-p", "tsconfig.json", "--watch", "true", "--pretty", "false"],
+      args: ["-p", tsconfigPath, "--watch", "true", "--pretty", "false"],
       cwd: root
     };
   }
@@ -5888,10 +7357,94 @@ var watchBuild_default = WatchProject;
 var import_coc3 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol3 = __toModule(require_main3());
 
+// src/server/protocol.const.ts
+var Kind = class {
+};
+Kind.alias = "alias";
+Kind.callSignature = "call";
+Kind.class = "class";
+Kind.const = "const";
+Kind.constructorImplementation = "constructor";
+Kind.constructSignature = "construct";
+Kind.directory = "directory";
+Kind.enum = "enum";
+Kind.enumMember = "enum member";
+Kind.externalModuleName = "external module name";
+Kind.function = "function";
+Kind.indexSignature = "index";
+Kind.interface = "interface";
+Kind.keyword = "keyword";
+Kind.let = "let";
+Kind.localFunction = "local function";
+Kind.localVariable = "local var";
+Kind.method = "method";
+Kind.memberGetAccessor = "getter";
+Kind.memberSetAccessor = "setter";
+Kind.memberVariable = "property";
+Kind.module = "module";
+Kind.primitiveType = "primitive type";
+Kind.script = "script";
+Kind.type = "type";
+Kind.variable = "var";
+Kind.warning = "warning";
+Kind.string = "string";
+Kind.parameter = "parameter";
+Kind.typeParameter = "type parameter";
+var DiagnosticCategory = class {
+};
+DiagnosticCategory.error = "error";
+DiagnosticCategory.warning = "warning";
+DiagnosticCategory.suggestion = "suggestion";
+var KindModifiers2 = class {
+};
+var KindModifiers = KindModifiers2;
+KindModifiers.optional = "optional";
+KindModifiers.deprecated = "deprecated";
+KindModifiers.color = "color";
+KindModifiers.dtsFile = ".d.ts";
+KindModifiers.tsFile = ".ts";
+KindModifiers.tsxFile = ".tsx";
+KindModifiers.jsFile = ".js";
+KindModifiers.jsxFile = ".jsx";
+KindModifiers.jsonFile = ".json";
+KindModifiers.fileExtensionKindModifiers = [
+  KindModifiers2.dtsFile,
+  KindModifiers2.tsFile,
+  KindModifiers2.tsxFile,
+  KindModifiers2.jsFile,
+  KindModifiers2.jsxFile,
+  KindModifiers2.jsonFile
+];
+var DisplayPartKind = class {
+};
+DisplayPartKind.functionName = "functionName";
+DisplayPartKind.methodName = "methodName";
+DisplayPartKind.parameterName = "parameterName";
+DisplayPartKind.propertyName = "propertyName";
+DisplayPartKind.punctuation = "punctuation";
+DisplayPartKind.text = "text";
+var EventName;
+(function(EventName2) {
+  EventName2["syntaxDiag"] = "syntaxDiag";
+  EventName2["semanticDiag"] = "semanticDiag";
+  EventName2["suggestionDiag"] = "suggestionDiag";
+  EventName2["configFileDiag"] = "configFileDiag";
+  EventName2["telemetry"] = "telemetry";
+  EventName2["projectLanguageServiceState"] = "projectLanguageServiceState";
+  EventName2["projectsUpdatedInBackground"] = "projectsUpdatedInBackground";
+  EventName2["beginInstallTypes"] = "beginInstallTypes";
+  EventName2["endInstallTypes"] = "endInstallTypes";
+  EventName2["typesInstallerInitializationFailed"] = "typesInstallerInitializationFailed";
+  EventName2["surveyReady"] = "surveyReady";
+  EventName2["projectLoadingStart"] = "projectLoadingStart";
+  EventName2["projectLoadingFinish"] = "projectLoadingFinish";
+})(EventName || (EventName = {}));
+
 // src/server/utils/typeConverters.ts
-var Range;
-(function(Range15) {
-  Range15.fromTextSpan = (span) => {
+var language = __toModule(require_main3());
+var Range2;
+(function(Range17) {
+  Range17.fromTextSpan = (span) => {
     return {
       start: {
         line: span.start.line - 1,
@@ -5903,45 +7456,46 @@ var Range;
       }
     };
   };
-  Range15.toFormattingRequestArgs = (file2, range) => ({
+  Range17.fromLocations = (start, end) => language.Range.create(Math.max(0, start.line - 1), Math.max(start.offset - 1, 0), Math.max(0, end.line - 1), Math.max(0, end.offset - 1));
+  Range17.toFormattingRequestArgs = (file2, range) => ({
     file: file2,
     line: range.start.line + 1,
     offset: range.start.character + 1,
     endLine: range.end.line + 1,
     endOffset: range.end.character + 1
   });
-  Range15.toFileRangeRequestArgs = (file2, range) => ({
+  Range17.toFileRangeRequestArgs = (file2, range) => ({
     file: file2,
     startLine: range.start.line + 1,
     startOffset: range.start.character + 1,
     endLine: range.end.line + 1,
     endOffset: range.end.character + 1
   });
-})(Range || (Range = {}));
+})(Range2 || (Range2 = {}));
 var Position;
-(function(Position7) {
-  Position7.fromLocation = (tslocation) => {
+(function(Position10) {
+  Position10.fromLocation = (tslocation) => {
     return {
       line: tslocation.line - 1,
       character: tslocation.offset - 1
     };
   };
-  Position7.toLocation = (position) => ({
+  Position10.toLocation = (position) => ({
     line: position.line + 1,
     offset: position.character + 1
   });
-  Position7.toFileLocationRequestArgs = (file2, position) => ({
+  Position10.toFileLocationRequestArgs = (file2, position) => ({
     file: file2,
     line: position.line + 1,
     offset: position.character + 1
   });
 })(Position || (Position = {}));
 var Location2;
-(function(Location3) {
-  Location3.fromTextSpan = (uri, tsTextSpan) => {
+(function(Location4) {
+  Location4.fromTextSpan = (uri, tsTextSpan) => {
     return {
       uri,
-      range: Range.fromTextSpan(tsTextSpan)
+      range: Range2.fromTextSpan(tsTextSpan)
     };
   };
 })(Location2 || (Location2 = {}));
@@ -5949,7 +7503,7 @@ var TextEdit;
 (function(TextEdit6) {
   TextEdit6.fromCodeEdit = (edit) => {
     return {
-      range: Range.fromTextSpan(edit),
+      range: Range2.fromTextSpan(edit),
       newText: edit.newText
     };
   };
@@ -5968,8 +7522,65 @@ var WorkspaceEdit;
   }
   WorkspaceEdit6.fromFileCodeEdits = fromFileCodeEdits;
 })(WorkspaceEdit || (WorkspaceEdit = {}));
+var SymbolKind2;
+(function(SymbolKind5) {
+  function fromProtocolScriptElementKind(kind) {
+    switch (kind) {
+      case Kind.module:
+        return language.SymbolKind.Module;
+      case Kind.class:
+        return language.SymbolKind.Class;
+      case Kind.enum:
+        return language.SymbolKind.Enum;
+      case Kind.enumMember:
+        return language.SymbolKind.EnumMember;
+      case Kind.interface:
+        return language.SymbolKind.Interface;
+      case Kind.indexSignature:
+        return language.SymbolKind.Method;
+      case Kind.callSignature:
+        return language.SymbolKind.Method;
+      case Kind.method:
+        return language.SymbolKind.Method;
+      case Kind.memberVariable:
+        return language.SymbolKind.Property;
+      case Kind.memberGetAccessor:
+        return language.SymbolKind.Property;
+      case Kind.memberSetAccessor:
+        return language.SymbolKind.Property;
+      case Kind.variable:
+        return language.SymbolKind.Variable;
+      case Kind.let:
+        return language.SymbolKind.Variable;
+      case Kind.const:
+        return language.SymbolKind.Variable;
+      case Kind.localVariable:
+        return language.SymbolKind.Variable;
+      case Kind.alias:
+        return language.SymbolKind.Variable;
+      case Kind.function:
+        return language.SymbolKind.Function;
+      case Kind.localFunction:
+        return language.SymbolKind.Function;
+      case Kind.constructSignature:
+        return language.SymbolKind.Constructor;
+      case Kind.constructorImplementation:
+        return language.SymbolKind.Constructor;
+      case Kind.typeParameter:
+        return language.SymbolKind.TypeParameter;
+      case Kind.string:
+        return language.SymbolKind.String;
+      default:
+        return language.SymbolKind.Variable;
+    }
+  }
+  SymbolKind5.fromProtocolScriptElementKind = fromProtocolScriptElementKind;
+})(SymbolKind2 || (SymbolKind2 = {}));
 
 // src/server/features/workspaceSymbols.ts
+function parseKindModifier(kindModifiers) {
+  return new Set(kindModifiers.split(/,|\s+/g));
+}
 function getSymbolKind(item) {
   switch (item.kind) {
     case "method":
@@ -6023,6 +7634,10 @@ var TypeScriptWorkspaceSymbolProvider = class {
         end: Position.fromLocation(item.end)
       };
       const symbolInfo = import_vscode_languageserver_protocol3.SymbolInformation.create(label, getSymbolKind(item), range, this.client.toResource(item.file));
+      const kindModifiers = item.kindModifiers ? parseKindModifier(item.kindModifiers) : void 0;
+      if (kindModifiers == null ? void 0 : kindModifiers.has(KindModifiers.deprecated)) {
+        symbolInfo.tags = [import_vscode_languageserver_protocol3.SymbolTag.Deprecated];
+      }
       result.push(symbolInfo);
     }
     return result;
@@ -6050,8 +7665,8 @@ var TypeScriptWorkspaceSymbolProvider = class {
 var workspaceSymbols_default = TypeScriptWorkspaceSymbolProvider;
 
 // src/server/languageProvider.ts
-var import_coc18 = __toModule(require("coc.nvim"));
-var import_path4 = __toModule(require("path"));
+var import_coc23 = __toModule(require("coc.nvim"));
+var import_path5 = __toModule(require("path"));
 var import_vscode_languageserver_protocol18 = __toModule(require_main3());
 
 // src/server/features/baseCodeLensProvider.ts
@@ -6135,105 +7750,124 @@ var TypeScriptBaseCodeLensProvider = class {
       return null;
     }
     if (item.nameSpan) {
-      return Range.fromTextSpan(item.nameSpan);
+      return Range2.fromTextSpan(item.nameSpan);
     }
     const span = item.spans && item.spans[0];
     if (!span) {
       return null;
-    }
-    const range = Range.fromTextSpan(span);
-    const text = document.getText(range);
-    const identifierMatch = new RegExp(`^(.*?(\\b|\\W))${escapeRegExp(item.text || "")}(\\b|\\W)`, "gm");
-    const match = identifierMatch.exec(text);
-    const prefixLength = match ? match.index + match[1].length : 0;
-    const startOffset = document.offsetAt(range.start) + prefixLength;
-    return {
-      start: document.positionAt(startOffset),
-      end: document.positionAt(startOffset + item.text.length)
-    };
-  }
-};
-
-// src/server/features/completionItemProvider.ts
-var import_coc5 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol8 = __toModule(require_main3());
-
-// src/server/protocol.const.ts
-var Kind = class {
-};
-Kind.alias = "alias";
-Kind.callSignature = "call";
-Kind.class = "class";
-Kind.const = "const";
-Kind.constructorImplementation = "constructor";
-Kind.constructSignature = "construct";
-Kind.directory = "directory";
-Kind.enum = "enum";
-Kind.enumMember = "enum member";
-Kind.externalModuleName = "external module name";
-Kind.function = "function";
-Kind.indexSignature = "index";
-Kind.interface = "interface";
-Kind.keyword = "keyword";
-Kind.let = "let";
-Kind.localFunction = "local function";
-Kind.localVariable = "local var";
-Kind.method = "method";
-Kind.memberGetAccessor = "getter";
-Kind.memberSetAccessor = "setter";
-Kind.memberVariable = "property";
-Kind.module = "module";
-Kind.primitiveType = "primitive type";
-Kind.script = "script";
-Kind.type = "type";
-Kind.variable = "var";
-Kind.warning = "warning";
-Kind.string = "string";
-Kind.parameter = "parameter";
-Kind.typeParameter = "type parameter";
-var DiagnosticCategory = class {
-};
-DiagnosticCategory.error = "error";
-DiagnosticCategory.warning = "warning";
-DiagnosticCategory.suggestion = "suggestion";
-var KindModifiers2 = class {
-};
-var KindModifiers = KindModifiers2;
-KindModifiers.optional = "optional";
-KindModifiers.color = "color";
-KindModifiers.dtsFile = ".d.ts";
-KindModifiers.tsFile = ".ts";
-KindModifiers.tsxFile = ".tsx";
-KindModifiers.jsFile = ".js";
-KindModifiers.jsxFile = ".jsx";
-KindModifiers.jsonFile = ".json";
-KindModifiers.fileExtensionKindModifiers = [
-  KindModifiers2.dtsFile,
-  KindModifiers2.tsFile,
-  KindModifiers2.tsxFile,
-  KindModifiers2.jsFile,
-  KindModifiers2.jsxFile,
-  KindModifiers2.jsonFile
-];
-var DisplayPartKind = class {
+    }
+    const range = Range2.fromTextSpan(span);
+    const text = document.getText(range);
+    const identifierMatch = new RegExp(`^(.*?(\\b|\\W))${escapeRegExp(item.text || "")}(\\b|\\W)`, "gm");
+    const match = identifierMatch.exec(text);
+    const prefixLength = match ? match.index + match[1].length : 0;
+    const startOffset = document.offsetAt(range.start) + prefixLength;
+    return {
+      start: document.positionAt(startOffset),
+      end: document.positionAt(startOffset + item.text.length)
+    };
+  }
 };
-DisplayPartKind.functionName = "functionName";
-DisplayPartKind.methodName = "methodName";
-DisplayPartKind.parameterName = "parameterName";
-DisplayPartKind.propertyName = "propertyName";
-DisplayPartKind.punctuation = "punctuation";
-DisplayPartKind.text = "text";
 
-// src/server/utils/codeAction.ts
-var import_vscode_languageserver_protocol5 = __toModule(require_main3());
+// src/server/features/callHierarchy.ts
 var import_coc4 = __toModule(require("coc.nvim"));
+var import_path2 = __toModule(require("path"));
+var import_vscode_languageserver_protocol5 = __toModule(require_main3());
+var TypeScriptCallHierarchySupport = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async prepareCallHierarchy(document, position, token) {
+    const filepath = this.client.toOpenedFilePath(document.uri);
+    if (!filepath) {
+      return void 0;
+    }
+    const args = Position.toFileLocationRequestArgs(filepath, position);
+    const response = await this.client.execute("prepareCallHierarchy", args, token);
+    if (response.type !== "response" || !response.body) {
+      return void 0;
+    }
+    return Array.isArray(response.body) ? response.body.map(fromProtocolCallHierarchyItem) : fromProtocolCallHierarchyItem(response.body);
+  }
+  async provideCallHierarchyIncomingCalls(item, token) {
+    const filepath = this.client.toPath(item.uri);
+    if (!filepath) {
+      return void 0;
+    }
+    const args = Position.toFileLocationRequestArgs(filepath, item.selectionRange.start);
+    const response = await this.client.execute("provideCallHierarchyIncomingCalls", args, token);
+    if (response.type !== "response" || !response.body) {
+      return void 0;
+    }
+    return response.body.map(fromProtocolCallHierarchyIncomingCall);
+  }
+  async provideCallHierarchyOutgoingCalls(item, token) {
+    const filepath = this.client.toPath(item.uri);
+    if (!filepath) {
+      return void 0;
+    }
+    const args = Position.toFileLocationRequestArgs(filepath, item.selectionRange.start);
+    const response = await this.client.execute("provideCallHierarchyOutgoingCalls", args, token);
+    if (response.type !== "response" || !response.body) {
+      return void 0;
+    }
+    return response.body.map(fromProtocolCallHierarchyOutgoingCall);
+  }
+};
+TypeScriptCallHierarchySupport.minVersion = api_default.v380;
+var callHierarchy_default = TypeScriptCallHierarchySupport;
+function isSourceFileItem(item) {
+  return item.kind === Kind.script || item.kind === Kind.module && item.selectionSpan.start.line === 1 && item.selectionSpan.start.offset === 1;
+}
+function parseKindModifier2(kindModifiers) {
+  return new Set(kindModifiers.split(/,|\s+/g));
+}
+function fromProtocolCallHierarchyItem(item) {
+  var _a;
+  const useFileName = isSourceFileItem(item);
+  const name = useFileName ? import_path2.default.basename(item.file) : item.name;
+  const detail = useFileName ? import_path2.default.relative(import_coc4.workspace.cwd, import_path2.default.dirname(item.file)) : (_a = item.containerName) != null ? _a : "";
+  const result = {
+    name,
+    detail,
+    uri: import_coc4.Uri.file(item.file).toString(),
+    kind: SymbolKind2.fromProtocolScriptElementKind(item.kind),
+    range: Range2.fromTextSpan(item.span),
+    selectionRange: Range2.fromTextSpan(item.selectionSpan)
+  };
+  const kindModifiers = item.kindModifiers ? parseKindModifier2(item.kindModifiers) : void 0;
+  if (kindModifiers == null ? void 0 : kindModifiers.has(KindModifiers.deprecated)) {
+    result.tags = [import_vscode_languageserver_protocol5.SymbolTag.Deprecated];
+  }
+  return result;
+}
+function fromProtocolCallHierarchyIncomingCall(item) {
+  return {
+    from: fromProtocolCallHierarchyItem(item.from),
+    fromRanges: item.fromSpans.map(Range2.fromTextSpan)
+  };
+}
+function fromProtocolCallHierarchyOutgoingCall(item) {
+  return {
+    to: fromProtocolCallHierarchyItem(item.to),
+    fromRanges: item.fromSpans.map(Range2.fromTextSpan)
+  };
+}
+
+// src/server/features/completionItemProvider.ts
+var import_coc8 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol9 = __toModule(require_main3());
+
+// src/server/utils/codeAction.ts
+var import_vscode_languageserver_protocol6 = __toModule(require_main3());
+var import_coc5 = __toModule(require("coc.nvim"));
 function getEditForCodeAction(client, action) {
   return action.changes && action.changes.length ? WorkspaceEdit.fromFileCodeEdits(client, action.changes) : void 0;
 }
 async function applyCodeAction(client, action) {
   const workspaceEdit = getEditForCodeAction(client, action);
   if (workspaceEdit) {
-    if (!await import_coc4.workspace.applyEdit(workspaceEdit)) {
+    if (!await import_coc5.workspace.applyEdit(workspaceEdit)) {
       return false;
     }
   }
@@ -6242,7 +7876,7 @@ async function applyCodeAction(client, action) {
 async function applyCodeActionCommands(client, action) {
   if (action.commands && action.commands.length) {
     for (const command of action.commands) {
-      const response = await client.execute("applyCodeActionCommand", {command}, import_vscode_languageserver_protocol5.CancellationToken.None);
+      const response = await client.execute("applyCodeActionCommand", {command}, import_vscode_languageserver_protocol6.CancellationToken.None);
       if (!response || response.type != "response" || !response.body) {
         return false;
       }
@@ -6252,7 +7886,8 @@ async function applyCodeActionCommands(client, action) {
 }
 
 // src/server/utils/completionItem.ts
-var import_vscode_languageserver_protocol6 = __toModule(require_main3());
+var import_coc6 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol7 = __toModule(require_main3());
 function convertCompletionEntry(tsEntry, uri, position, context) {
   let label = tsEntry.name;
   let sortText = tsEntry.sortText;
@@ -6261,22 +7896,27 @@ function convertCompletionEntry(tsEntry, uri, position, context) {
   if (tsEntry.isRecommended) {
     preselect = true;
   }
-  if (tsEntry.source) {
+  if (tsEntry.source && tsEntry.hasAction) {
     sortText = "\uFFFF" + sortText;
   } else {
     sortText = tsEntry.sortText;
   }
   let kind = convertKind(tsEntry.kind);
-  let insertTextFormat = context.enableCallCompletions && (kind === import_vscode_languageserver_protocol6.CompletionItemKind.Function || kind === import_vscode_languageserver_protocol6.CompletionItemKind.Method) ? import_vscode_languageserver_protocol6.InsertTextFormat.Snippet : import_vscode_languageserver_protocol6.InsertTextFormat.PlainText;
+  let insertTextFormat = context.enableCallCompletions && (kind === import_coc6.CompletionItemKind.Function || kind === import_coc6.CompletionItemKind.Method) ? import_coc6.InsertTextFormat.Snippet : import_coc6.InsertTextFormat.PlainText;
   let insertText = tsEntry.insertText;
   let commitCharacters = getCommitCharacters(tsEntry, context);
+  let tags;
+  if (tsEntry.isImportStatementCompletion) {
+    insertText = label;
+    insertTextFormat = import_coc6.InsertTextFormat.Snippet;
+  }
   let textEdit = null;
   if (tsEntry.replacementSpan) {
     let {start, end} = tsEntry.replacementSpan;
     if (start.line == end.line) {
       textEdit = {
-        range: import_vscode_languageserver_protocol6.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1),
-        newText: insertText || label
+        range: import_coc6.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1),
+        newText: tsEntry.insertText || label
       };
     }
   }
@@ -6286,8 +7926,11 @@ function convertCompletionEntry(tsEntry, uri, position, context) {
       insertText = label;
       label += "?";
     }
+    if (kindModifiers.has(KindModifiers.deprecated)) {
+      tags = [import_vscode_languageserver_protocol7.CompletionItemTag.Deprecated];
+    }
     if (kindModifiers.has(KindModifiers.color)) {
-      kind = import_vscode_languageserver_protocol6.CompletionItemKind.Color;
+      kind = import_coc6.CompletionItemKind.Color;
     }
     if (tsEntry.kind === Kind.script) {
       for (const extModifier of KindModifiers.fileExtensionKindModifiers) {
@@ -6307,6 +7950,7 @@ function convertCompletionEntry(tsEntry, uri, position, context) {
     insertText,
     textEdit,
     kind,
+    tags,
     preselect,
     insertTextFormat,
     sortText,
@@ -6316,6 +7960,7 @@ function convertCompletionEntry(tsEntry, uri, position, context) {
       uri,
       position,
       name: tsEntry.name,
+      data: tsEntry.data,
       source: tsEntry.source || ""
     }
   };
@@ -6324,42 +7969,42 @@ function convertKind(kind) {
   switch (kind) {
     case Kind.primitiveType:
     case Kind.keyword:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Keyword;
+      return import_coc6.CompletionItemKind.Keyword;
     case Kind.const:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Constant;
+      return import_coc6.CompletionItemKind.Constant;
     case Kind.let:
     case Kind.variable:
     case Kind.localVariable:
     case Kind.alias:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Variable;
+      return import_coc6.CompletionItemKind.Variable;
     case Kind.memberVariable:
     case Kind.memberGetAccessor:
     case Kind.memberSetAccessor:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Field;
+      return import_coc6.CompletionItemKind.Field;
     case Kind.function:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Function;
+      return import_coc6.CompletionItemKind.Function;
     case Kind.method:
     case Kind.constructSignature:
     case Kind.callSignature:
     case Kind.indexSignature:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Method;
+      return import_coc6.CompletionItemKind.Method;
     case Kind.enum:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Enum;
+      return import_coc6.CompletionItemKind.Enum;
     case Kind.module:
     case Kind.externalModuleName:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Module;
+      return import_coc6.CompletionItemKind.Module;
     case Kind.class:
     case Kind.type:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Class;
+      return import_coc6.CompletionItemKind.Class;
     case Kind.interface:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Interface;
+      return import_coc6.CompletionItemKind.Interface;
     case Kind.warning:
     case Kind.script:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.File;
+      return import_coc6.CompletionItemKind.File;
     case Kind.directory:
-      return import_vscode_languageserver_protocol6.CompletionItemKind.Folder;
+      return import_coc6.CompletionItemKind.Folder;
   }
-  return import_vscode_languageserver_protocol6.CompletionItemKind.Variable;
+  return import_coc6.CompletionItemKind.Variable;
 }
 function getCommitCharacters(tsEntry, context) {
   if (context.isNewIdentifierLocation || !context.isInValidCommitCharacterContext) {
@@ -6448,33 +8093,70 @@ function getParameterListParts(displayParts) {
 }
 
 // src/server/utils/previewer.ts
-var import_vscode_languageserver_protocol7 = __toModule(require_main3());
+var import_vscode_languageserver_protocol8 = __toModule(require_main3());
+var import_coc7 = __toModule(require("coc.nvim"));
+function toResource(filepath) {
+  return import_coc7.Uri.file(filepath);
+}
+function replaceLinks(text) {
+  return text.replace(/\{@(link|linkplain|linkcode) (https?:\/\/[^ |}]+?)(?:[| ]([^{}\n]+?))?\}/gi, (_, tag, link, text2) => {
+    switch (tag) {
+      case "linkcode":
+        return `[\`${text2 ? text2.trim() : link}\`](${link})`;
+      default:
+        return `[${text2 ? text2.trim() : link}](${link})`;
+    }
+  });
+}
+function processInlineTags(text) {
+  return replaceLinks(text);
+}
 function getTagBodyText(tag) {
   if (!tag.text) {
     return void 0;
   }
+  function makeCodeblock(text2) {
+    if (text2.match(/^\s*[~`]{3}/g)) {
+      return text2;
+    }
+    return "```\n" + text2 + "\n```";
+  }
+  const text = convertLinkTags(tag.text);
   switch (tag.name) {
     case "example":
-    case "default":
-      if (tag.text.match(/^\s*[~`]{3}/g)) {
-        return tag.text;
+      const captionTagMatches = text.match(/<caption>(.*?)<\/caption>\s*(\r\n|\n)/);
+      if (captionTagMatches && captionTagMatches.index === 0) {
+        return captionTagMatches[1] + "\n\n" + makeCodeblock(text.substr(captionTagMatches[0].length));
+      } else {
+        return makeCodeblock(text);
+      }
+    case "author":
+      const emailMatch = text.match(/(.+)\s<([-.\w]+@[-.\w]+)>/);
+      if (emailMatch === null) {
+        return text;
+      } else {
+        return `${emailMatch[1]} ${emailMatch[2]}`;
       }
-      return "```\n" + tag.text + "\n```";
+    case "default":
+      return makeCodeblock(text);
   }
-  return tag.text;
+  return processInlineTags(text);
 }
 function getTagDocumentation(tag) {
   switch (tag.name) {
+    case "augments":
+    case "extends":
     case "param":
-      const body = (tag.text || "").split(/^([\w\.]+)\s*/);
-      if (body && body.length === 3) {
+    case "template":
+      const body = convertLinkTags(tag.text).split(/^(\S+)\s*-?\s*/);
+      if ((body == null ? void 0 : body.length) === 3) {
         const param = body[1];
         const doc = body[2];
         const label2 = `*@${tag.name}* \`${param}\``;
         if (!doc) {
           return label2;
         }
-        return label2 + (doc.match(/\r\n|\n/g) ? "\n" + doc : ` \u2014 ${doc}`);
+        return label2 + (doc.match(/\r\n|\n/g) ? "  \n" + processInlineTags(doc) : ` \u2014 ${processInlineTags(doc)}`);
       }
   }
   const label = `*@${tag.name}*`;
@@ -6482,7 +8164,7 @@ function getTagDocumentation(tag) {
   if (!text) {
     return label;
   }
-  return label + (text.match(/\r\n|\n/g) ? "\n" + text : ` \u2014 ${text}`);
+  return label + (text.match(/\r\n|\n/g) ? "  \n" + text : ` \u2014 ${text}`);
 }
 function plain(parts) {
   if (!parts || !parts.length)
@@ -6499,10 +8181,67 @@ function markdownDocumentation(documentation, tags) {
     out = out + ("\n\n" + tagsPreview);
   }
   return {
-    kind: import_vscode_languageserver_protocol7.MarkupKind.Markdown,
+    kind: import_vscode_languageserver_protocol8.MarkupKind.Markdown,
     value: out
   };
 }
+function convertLinkTags(parts) {
+  var _a;
+  if (!parts) {
+    return "";
+  }
+  if (typeof parts === "string") {
+    return parts;
+  }
+  const out = [];
+  let currentLink;
+  for (const part of parts) {
+    switch (part.kind) {
+      case "link":
+        if (currentLink) {
+          const text = (_a = currentLink.text) != null ? _a : currentLink.name;
+          if (currentLink.target) {
+            const link = toResource(currentLink.target.file).with({
+              fragment: `L${currentLink.target.start.line},${currentLink.target.start.offset}`
+            });
+            out.push(`[${text}](${link.toString()})`);
+          } else {
+            if (text) {
+              if (/^https?:/.test(text)) {
+                const parts2 = text.split(" ");
+                if (parts2.length === 1) {
+                  out.push(parts2[0]);
+                } else if (parts2.length > 1) {
+                  out.push(`[${parts2.slice(1).join(" ")}](${parts2[0]})`);
+                }
+              } else {
+                out.push(text);
+              }
+            }
+          }
+          currentLink = void 0;
+        } else {
+          currentLink = {};
+        }
+        break;
+      case "linkName":
+        if (currentLink) {
+          currentLink.name = part.text;
+          currentLink.target = part.target;
+        }
+        break;
+      case "linkText":
+        if (currentLink) {
+          currentLink.text = part.text;
+        }
+        break;
+      default:
+        out.push(part.text);
+        break;
+    }
+  }
+  return processInlineTags(out.join(""));
+}
 
 // src/server/utils/SnippetString.ts
 var SnippetString = class {
@@ -6584,7 +8323,7 @@ var ApplyCompletionCodeActionCommand2 = class {
       await applyCodeAction(this.client, codeActions[0]);
       return;
     }
-    const idx = await import_coc5.window.showQuickpick(codeActions.map((o) => o.description), "Select code action to apply");
+    const idx = await import_coc8.window.showQuickpick(codeActions.map((o) => o.description), "Select code action to apply");
     if (idx < 0)
       return;
     const action = codeActions[idx];
@@ -6600,11 +8339,11 @@ var TypeScriptCompletionItemProvider = class {
     this.typingsStatus = typingsStatus;
     this.fileConfigurationManager = fileConfigurationManager;
     this.setCompleteOption(languageId);
-    import_coc5.commands.registerCommand(ApplyCompletionCodeActionCommand.ID, async (codeActions) => {
+    import_coc8.commands.registerCommand(ApplyCompletionCodeActionCommand.ID, async (codeActions) => {
       let cmd = new ApplyCompletionCodeActionCommand(this.client);
       await cmd.execute(codeActions);
     });
-    import_coc5.workspace.onDidChangeConfiguration((_e) => {
+    import_coc8.workspace.onDidChangeConfiguration((_e) => {
       this.setCompleteOption(languageId);
     });
   }
@@ -6659,7 +8398,7 @@ var TypeScriptCompletionItemProvider = class {
         if (isMemberCompletion) {
           const dotMatch = preText.slice(0, position.character).match(/\??\.\s*$/) || void 0;
           if (dotMatch) {
-            const range = import_vscode_languageserver_protocol8.Range.create({
+            const range = import_vscode_languageserver_protocol9.Range.create({
               line: position.line,
               character: position.character - dotMatch.length
             }, position);
@@ -6667,7 +8406,7 @@ var TypeScriptCompletionItemProvider = class {
             dotAccessorContext = {range, text};
           }
         }
-        isIncomplete = response.metadata && response.metadata.isIncomplete;
+        isIncomplete = !!response.body.isIncomplete || response.metadata && response.metadata.isIncomplete;
         entries = response.body.entries;
       } catch (e) {
         if (e.message == "No content available.") {
@@ -6704,6 +8443,8 @@ var TypeScriptCompletionItemProvider = class {
         return this.client.apiVersion.gte(api_default.v310) && this.client.apiVersion.lt(api_default.v320) ? void 0 : "@";
       case "#":
         return this.client.apiVersion.lt(api_default.v381) ? void 0 : "#";
+      case " ":
+        return this.client.apiVersion.gte(api_default.v430) ? " " : void 0;
       case ".":
       case '"':
       case "'":
@@ -6717,16 +8458,16 @@ var TypeScriptCompletionItemProvider = class {
   async resolveCompletionItem(item, token) {
     if (item == null)
       return void 0;
-    let {uri, position, source, name} = item.data;
+    let {uri, position, source, name, data} = item.data;
     const filepath = this.client.toPath(uri);
     if (!filepath)
       return void 0;
-    let document = import_coc5.workspace.getDocument(uri);
+    let document = import_coc8.workspace.getDocument(uri);
     if (!document)
       return void 0;
     const args = {
       ...Position.toFileLocationRequestArgs(filepath, position),
-      entryNames: [source ? {name, source} : name]
+      entryNames: [source ? {name, source, data} : name]
     };
     let response;
     try {
@@ -6750,7 +8491,7 @@ var TypeScriptCompletionItemProvider = class {
     if (command)
       item.command = command;
     item.additionalTextEdits = additionalTextEdits;
-    if (detail && item.insertTextFormat == import_vscode_languageserver_protocol8.InsertTextFormat.Snippet) {
+    if (detail && item.insertTextFormat == import_vscode_languageserver_protocol9.InsertTextFormat.Snippet) {
       const shouldCompleteFunction = await this.isValidFunctionCompletionContext(filepath, position, token);
       if (shouldCompleteFunction) {
         this.createSnippetOfFunctionCall(item, detail);
@@ -6810,6 +8551,12 @@ var TypeScriptCompletionItemProvider = class {
         return false;
       }
     }
+    if (triggerCharacter === " ") {
+      if (!this.completeOption.importStatementSuggestions || !this.client.apiVersion.lt(api_default.v430)) {
+        return false;
+      }
+      return pre === "import ";
+    }
     return true;
   }
   getDocumentation(detail) {
@@ -6828,7 +8575,7 @@ var TypeScriptCompletionItemProvider = class {
     documentation += parts.join("\n\n");
     if (documentation.length) {
       return {
-        kind: import_vscode_languageserver_protocol8.MarkupKind.Markdown,
+        kind: import_vscode_languageserver_protocol9.MarkupKind.Markdown,
         value: documentation
       };
     }
@@ -6871,14 +8618,14 @@ var TypeScriptCompletionItemProvider = class {
   isInValidCommitCharacterContext(document, position) {
     if (this.client.apiVersion.lt(api_default.v320)) {
       if (position.character > 1) {
-        const preText = document.getText(import_vscode_languageserver_protocol8.Range.create(position.line, 0, position.line, position.character));
+        const preText = document.getText(import_vscode_languageserver_protocol9.Range.create(position.line, 0, position.line, position.character));
         return preText.match(/(\s|^)\.$/ig) === null;
       }
     }
     return true;
   }
 };
-TypeScriptCompletionItemProvider.triggerCharacters = [".", '"', "'", "`", "/", "@", "<", "#"];
+TypeScriptCompletionItemProvider.triggerCharacters = [".", '"', "'", "`", "/", "@", "<", "#", " "];
 var completionItemProvider_default = TypeScriptCompletionItemProvider;
 function shouldExcludeCompletionEntry(element, completionConfiguration) {
   return !completionConfiguration.names && element.kind === Kind.warning || !completionConfiguration.paths && (element.kind === Kind.directory || element.kind === Kind.script || element.kind === Kind.externalModuleName) || !completionConfiguration.autoImports && element.hasAction;
@@ -6912,8 +8659,37 @@ var TypeScriptDefinitionProvider = class {
       return [];
     }
   }
-  provideDefinition(document, position, token) {
-    return this.getSymbolLocations("definition", document, position, token);
+  async provideDefinition(document, position, token) {
+    if (this.client.apiVersion.gte(api_default.v270)) {
+      const filepath = this.client.toOpenedFilePath(document.uri);
+      if (!filepath) {
+        return void 0;
+      }
+      const args = Position.toFileLocationRequestArgs(filepath, position);
+      const response = await this.client.execute("definitionAndBoundSpan", args, token);
+      if (response.type !== "response" || !response.body) {
+        return void 0;
+      }
+      const span = response.body.textSpan ? Range2.fromTextSpan(response.body.textSpan) : void 0;
+      return response.body.definitions.map((location) => {
+        const target = Location2.fromTextSpan(this.client.toResource(location.file), location);
+        if (location.contextStart && location.contextEnd) {
+          return {
+            originSelectionRange: span,
+            targetRange: Range2.fromLocations(location.contextStart, location.contextEnd),
+            targetUri: target.uri,
+            targetSelectionRange: target.range
+          };
+        }
+        return {
+          originSelectionRange: span,
+          targetRange: target.range,
+          targetUri: target.uri,
+          targetSelectionRange: target.range
+        };
+      });
+    }
+    return await this.getSymbolLocations("definition", document, position, token);
   }
   provideTypeDefinition(document, position, token) {
     return this.getSymbolLocations("typeDefinition", document, position, token);
@@ -6925,8 +8701,8 @@ var TypeScriptDefinitionProvider = class {
 var definitionProvider_default = TypeScriptDefinitionProvider;
 
 // src/server/features/directiveCommentCompletions.ts
-var import_vscode_languageserver_protocol9 = __toModule(require_main3());
-var import_coc6 = __toModule(require("coc.nvim"));
+var import_coc9 = __toModule(require("coc.nvim"));
+var import_coc10 = __toModule(require("coc.nvim"));
 var tsDirectives = [
   {
     value: "@ts-check",
@@ -6960,18 +8736,18 @@ var DirectiveCommentCompletionProvider = class {
     if (!file2) {
       return [];
     }
-    const doc = import_coc6.workspace.getDocument(document.uri);
+    const doc = import_coc10.workspace.getDocument(document.uri);
     const line = doc.getline(position.line);
     const prefix = line.slice(0, position.character);
     const match = prefix.match(/^\s*\/\/+\s?(@[a-zA-Z\-]*)?$/);
     if (match) {
       const directives = this.client.apiVersion.gte(api_default.v390) ? tsDirectives390 : tsDirectives;
       let items = directives.map((directive) => {
-        const item = import_vscode_languageserver_protocol9.CompletionItem.create(directive.value);
-        item.kind = import_vscode_languageserver_protocol9.CompletionItemKind.Snippet;
+        const item = {label: directive.value};
+        item.kind = import_coc9.CompletionItemKind.Snippet;
         item.detail = directive.description;
         item.textEdit = {
-          range: import_vscode_languageserver_protocol9.Range.create(position.line, Math.max(0, position.character - (match[1] ? match[1].length : 0)), position.line, position.character),
+          range: import_coc9.Range.create(position.line, Math.max(0, position.character - (match[1] ? match[1].length : 0)), position.line, position.character),
           newText: directive.value
         };
         return item;
@@ -7017,7 +8793,7 @@ var documentHighlight_default = TypeScriptDocumentHighlightProvider;
 function convertDocumentHighlight(highlight) {
   return highlight.highlightSpans.map((span) => {
     return {
-      range: Range.fromTextSpan(span),
+      range: Range2.fromTextSpan(span),
       kind: span.kind === "writtenReference" ? import_vscode_languageserver_protocol10.DocumentHighlightKind.Write : import_vscode_languageserver_protocol10.DocumentHighlightKind.Read
     };
   });
@@ -7085,26 +8861,45 @@ var TypeScriptDocumentSymbolProvider = class {
       return [];
     }
   }
-  static convertNavTree(bucket, item) {
+  static convertNavTree(output, item) {
     let shouldInclude = TypeScriptDocumentSymbolProvider.shouldInclueEntry(item);
     const children = new Set(item.childItems || []);
     for (const span of item.spans) {
-      const range = Range.fromTextSpan(span);
-      const symbolInfo = import_vscode_languageserver_protocol11.DocumentSymbol.create(item.text, "", getSymbolKind2(item.kind), range, range);
-      symbolInfo.children = children.size > 0 ? [] : null;
+      const range = Range2.fromTextSpan(span);
+      const symbolInfo = TypeScriptDocumentSymbolProvider.convertSymbol(item, range);
+      if (children.size)
+        symbolInfo.children = [];
       for (const child of children) {
-        if (child.spans.some((span2) => !!containsRange(range, Range.fromTextSpan(span2)))) {
+        if (child.spans.some((span2) => !!containsRange(range, Range2.fromTextSpan(span2)))) {
           const includedChild = TypeScriptDocumentSymbolProvider.convertNavTree(symbolInfo.children, child);
           shouldInclude = shouldInclude || includedChild;
           children.delete(child);
         }
       }
       if (shouldInclude) {
-        bucket.push(symbolInfo);
+        output.push(symbolInfo);
       }
     }
     return shouldInclude;
   }
+  static convertSymbol(item, range) {
+    const selectionRange = item.nameSpan ? Range2.fromTextSpan(item.nameSpan) : range;
+    let label = item.text;
+    switch (item.kind) {
+      case Kind.memberGetAccessor:
+        label = `(get) ${label}`;
+        break;
+      case Kind.memberSetAccessor:
+        label = `(set) ${label}`;
+        break;
+    }
+    const symbolInfo = import_vscode_languageserver_protocol11.DocumentSymbol.create(label, "", getSymbolKind2(item.kind), range, containsRange(range, selectionRange) ? selectionRange : range);
+    const kindModifiers = parseKindModifier3(item.kindModifiers);
+    if (kindModifiers.has(KindModifiers.deprecated)) {
+      symbolInfo.tags = [import_vscode_languageserver_protocol11.SymbolTag.Deprecated];
+    }
+    return symbolInfo;
+  }
   static shouldInclueEntry(item) {
     if (item.kind === Kind.alias) {
       return false;
@@ -7128,9 +8923,12 @@ function containsRange(range, otherRange) {
   }
   return true;
 }
+function parseKindModifier3(kindModifiers) {
+  return new Set(kindModifiers.split(/,|\s+/g));
+}
 
 // src/server/features/folding.ts
-var import_coc7 = __toModule(require("coc.nvim"));
+var import_coc11 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_types = __toModule(require_main2());
 var TypeScriptFoldingProvider = class {
   constructor(client) {
@@ -7153,10 +8951,10 @@ var TypeScriptFoldingProvider = class {
     return body.map((span) => this.convertOutliningSpan(span, document)).filter((foldingRange) => !!foldingRange);
   }
   convertOutliningSpan(span, document) {
-    const range = Range.fromTextSpan(span.textSpan);
+    const range = Range2.fromTextSpan(span.textSpan);
     const kind = TypeScriptFoldingProvider.getFoldingRangeKind(span);
     if (span.kind === "comment") {
-      let doc = import_coc7.workspace.getDocument(document.uri);
+      let doc = import_coc11.workspace.getDocument(document.uri);
       const line = doc.getline(range.start.line);
       if (line.match(/\/\/\s*#endregion/gi)) {
         return void 0;
@@ -7180,7 +8978,7 @@ var TypeScriptFoldingProvider = class {
 var folding_default = TypeScriptFoldingProvider;
 
 // src/server/features/formatting.ts
-var import_coc8 = __toModule(require("coc.nvim"));
+var import_coc12 = __toModule(require("coc.nvim"));
 var TypeScriptFormattingProvider = class {
   constructor(client, formattingOptionsManager) {
     this.client = client;
@@ -7242,7 +9040,7 @@ var TypeScriptFormattingProvider = class {
     if (!file2)
       return [];
     await this.formattingOptionsManager.ensureConfigurationOptions(document, options.insertSpaces, options.tabSize, token);
-    const doc = import_coc8.workspace.getDocument(document.uri);
+    const doc = import_coc12.workspace.getDocument(document.uri);
     const args = {
       ...Position.toFileLocationRequestArgs(file2, position),
       key: ch
@@ -7295,7 +9093,7 @@ var TypeScriptHoverProvider = class {
         const data = response.body;
         return {
           contents: TypeScriptHoverProvider.getContents(data),
-          range: Range.fromTextSpan(data)
+          range: Range2.fromTextSpan(data)
         };
       }
     } catch (e) {
@@ -7377,7 +9175,7 @@ var TypeScriptImplementationsCodeLensProvider = class extends TypeScriptBaseCode
 var implementationsCodeLens_default = TypeScriptImplementationsCodeLensProvider;
 
 // src/server/features/importFix.ts
-var import_coc9 = __toModule(require("coc.nvim"));
+var import_coc13 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol12 = __toModule(require_main3());
 
 // src/server/utils/helper.ts
@@ -7426,7 +9224,7 @@ var ImportFixProvider = class {
       return [];
     let edits = [];
     let names = [];
-    let doc = import_coc9.workspace.getDocument(document.uri);
+    let doc = import_coc13.workspace.getDocument(document.uri);
     let command;
     for (const diagnostic of diagnostics) {
       let {range} = diagnostic;
@@ -7465,14 +9263,14 @@ var ImportFixProvider = class {
 var importFix_default = ImportFixProvider;
 
 // src/server/features/moduleInstall.ts
-var import_coc11 = __toModule(require("coc.nvim"));
+var import_coc15 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol13 = __toModule(require_main3());
 
 // src/server/utils/modules.ts
 var import_child_process = __toModule(require("child_process"));
-var import_coc10 = __toModule(require("coc.nvim"));
+var import_coc14 = __toModule(require("coc.nvim"));
 var import_fs = __toModule(require("fs"));
-var import_path2 = __toModule(require("path"));
+var import_path3 = __toModule(require("path"));
 function runCommand(cmd, cwd, timeout) {
   return new Promise((resolve, reject) => {
     let timer;
@@ -7493,7 +9291,7 @@ function runCommand(cmd, cwd, timeout) {
   });
 }
 async function getManager() {
-  let res = await import_coc10.workspace.findUp(["yarn.lock", "package-lock.json"]);
+  let res = await import_coc14.workspace.findUp(["yarn.lock", "package-lock.json"]);
   if (!res)
     return "yarn";
   return res.endsWith("yarn.lock") ? "yarn" : "npm";
@@ -7530,14 +9328,14 @@ function distinct(array, keyFn) {
 }
 async function installModules(uri, names) {
   names = distinct(names);
-  let workspaceFolder = import_coc10.workspace.getWorkspaceFolder(uri);
-  let root = workspaceFolder ? import_coc10.Uri.parse(workspaceFolder.uri).fsPath : void 0;
-  if (!root || !import_fs.default.existsSync(import_path2.default.join(root, "package.json"))) {
-    import_coc10.window.showMessage(`package.json not found from workspaceFolder: ${root}`, "error");
+  let workspaceFolder = import_coc14.workspace.getWorkspaceFolder(uri);
+  let root = workspaceFolder ? import_coc14.Uri.parse(workspaceFolder.uri).fsPath : void 0;
+  if (!root || !import_fs.default.existsSync(import_path3.default.join(root, "package.json"))) {
+    import_coc14.window.showMessage(`package.json not found from workspaceFolder: ${root}`, "error");
     return;
   }
   let arr = names.concat(names.map((s) => `@types/${s}`));
-  let statusItem = import_coc10.window.createStatusBarItem(99, {progress: true});
+  let statusItem = import_coc14.window.createStatusBarItem(99, {progress: true});
   statusItem.text = `Checking module ${arr.join(" ")}`;
   statusItem.show();
   let exists = await Promise.all(arr.map((name) => {
@@ -7559,23 +9357,23 @@ async function installModules(uri, names) {
     await runCommand(cmd, root);
   } catch (e) {
     statusItem.dispose();
-    import_coc10.window.showMessage(`Install error ${e.message}`, "error");
+    import_coc14.window.showMessage(`Install error ${e.message}`, "error");
     return;
   }
   statusItem.dispose();
-  import_coc10.window.showMessage(`Installed: ${exists.join(" ")}`, "more");
+  import_coc14.window.showMessage(`Installed: ${exists.join(" ")}`, "more");
 }
 
 // src/server/features/moduleInstall.ts
 var InstallModuleProvider = class {
   constructor(client) {
     this.client = client;
-    import_coc11.commands.registerCommand("_tsserver.installModule", async (uri, name) => {
+    import_coc15.commands.registerCommand("_tsserver.installModule", async (uri, name) => {
       await installModules(uri, [name]);
     });
   }
   async provideCodeActions(document, _range, context, _token) {
-    const uri = import_coc11.Uri.parse(document.uri);
+    const uri = import_coc15.Uri.parse(document.uri);
     if (uri.scheme != "file")
       return null;
     let {diagnostics} = context;
@@ -7604,11 +9402,11 @@ var InstallModuleProvider = class {
 var moduleInstall_default = InstallModuleProvider;
 
 // src/server/features/quickfix.ts
-var import_coc13 = __toModule(require("coc.nvim"));
+var import_coc17 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol14 = __toModule(require_main3());
 
 // src/server/commands.ts
-var import_coc12 = __toModule(require("coc.nvim"));
+var import_coc16 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_types2 = __toModule(require_main2());
 var ReloadProjectsCommand = class {
   constructor(service) {
@@ -7618,7 +9416,7 @@ var ReloadProjectsCommand = class {
   async execute() {
     let client = await this.service.getClientHost();
     client.reloadProjects();
-    import_coc12.window.showMessage("projects reloaded");
+    import_coc16.window.showMessage("projects reloaded");
   }
 };
 var OpenTsServerLogCommand = class {
@@ -7638,7 +9436,7 @@ var TypeScriptGoToProjectConfigCommand = class {
   }
   async execute() {
     let client = await this.service.getClientHost();
-    let doc = await import_coc12.workspace.document;
+    let doc = await import_coc16.workspace.document;
     let {languageId} = doc.textDocument;
     if (client.serviceClient.modeIds.indexOf(languageId) == -1) {
       throw new Error(`Could not determine TypeScript or JavaScript project. Unsupported file type: ${languageId}`);
@@ -7652,19 +9450,19 @@ async function goToProjectConfig(clientHost, uri) {
   const file2 = client.toPath(uri);
   let res;
   try {
-    res = await client.execute("projectInfo", {file: file2, needFileNameList: false}, import_coc12.CancellationToken.None);
+    res = await client.execute("projectInfo", {file: file2, needFileNameList: false}, import_coc16.CancellationToken.None);
   } catch {
   }
   if (!res || !res.body) {
-    import_coc12.window.showMessage("Could not determine TypeScript or JavaScript project.", "warning");
+    import_coc16.window.showMessage("Could not determine TypeScript or JavaScript project.", "warning");
     return;
   }
   const {configFileName} = res.body;
   if (configFileName && !isImplicitProjectConfigFile(configFileName)) {
-    await import_coc12.workspace.openResource(import_coc12.Uri.file(configFileName).toString());
+    await import_coc16.workspace.openResource(import_coc16.Uri.file(configFileName).toString());
     return;
   }
-  import_coc12.window.showMessage("Config file not found", "warning");
+  import_coc16.window.showMessage("Config file not found", "warning");
 }
 function isImplicitProjectConfigFile(configFileName) {
   return configFileName.indexOf("/dev/null/") === 0;
@@ -7680,19 +9478,19 @@ var AutoFixCommand = class {
     this.id = "tsserver.executeAutofix";
   }
   async execute() {
-    if (this.service.state != import_coc12.ServiceStat.Running) {
+    if (this.service.state != import_coc16.ServiceStat.Running) {
       throw new Error("service not running");
       return;
     }
     let client = await this.service.getClientHost();
-    let document = await import_coc12.workspace.document;
+    let document = await import_coc16.workspace.document;
     let handles = await client.handles(document.textDocument);
     if (!handles) {
       throw new Error(`Document ${document.uri} is not handled by tsserver.`);
       return;
     }
     let file2 = client.serviceClient.toPath(document.uri);
-    let diagnostics = import_coc12.diagnosticManager.getDiagnostics(document.uri).slice();
+    let diagnostics = client.serviceClient.diagnosticsManager.getDiagnostics(document.uri);
     let missingDiagnostics = diagnostics.filter((o) => o.code == 2307);
     if (missingDiagnostics.length) {
       let names2 = missingDiagnostics.map((o) => {
@@ -7720,10 +9518,10 @@ var AutoFixCommand = class {
     let names = [];
     for (let diagnostic of diagnostics) {
       const args = {
-        ...Range.toFileRangeRequestArgs(file2, diagnostic.range),
+        ...Range2.toFileRangeRequestArgs(file2, diagnostic.range),
         errorCodes: [+diagnostic.code]
       };
-      const response = await client.serviceClient.execute("getCodeFixes", args, import_coc12.CancellationToken.None);
+      const response = await client.serviceClient.execute("getCodeFixes", args, import_coc16.CancellationToken.None);
       if (response.type !== "response" || !response.body || response.body.length < 1) {
         if (diagnostic.code == 2304) {
           let {range} = diagnostic;
@@ -7747,7 +9545,7 @@ var AutoFixCommand = class {
           continue;
         for (let ch of change.textChanges) {
           edits.push({
-            range: Range.fromTextSpan(ch),
+            range: Range2.fromTextSpan(ch),
             newText: ch.newText
           });
         }
@@ -7756,7 +9554,7 @@ var AutoFixCommand = class {
     if (edits.length)
       await document.applyEdits(edits);
     if (command)
-      import_coc12.commands.executeCommand(command);
+      import_coc16.commands.executeCommand(command);
   }
 };
 var ConfigurePluginCommand = class {
@@ -7768,9 +9566,36 @@ var ConfigurePluginCommand = class {
     this.pluginManager.setConfiguration(pluginId, configuration);
   }
 };
+var FileReferencesCommand2 = class {
+  constructor(service) {
+    this.service = service;
+    this.id = "tsserver.findAllFileReferences";
+  }
+  async execute() {
+    const client = await this.service.getClientHost();
+    if (client.serviceClient.apiVersion.lt(FileReferencesCommand2.minVersion)) {
+      import_coc16.window.showMessage("Find file references failed. Requires TypeScript 4.2+.", "error");
+      return;
+    }
+    const doc = await import_coc16.workspace.document;
+    let {languageId} = doc.textDocument;
+    if (client.serviceClient.modeIds.indexOf(languageId) == -1)
+      return;
+    const openedFiledPath = client.serviceClient.toOpenedFilePath(doc.uri);
+    if (!openedFiledPath)
+      return;
+    const response = await client.serviceClient.execute("fileReferences", {file: openedFiledPath}, import_coc16.CancellationToken.None);
+    if (response.type !== "response" || !response.body)
+      return;
+    const locations = response.body.refs.map((r) => Location2.fromTextSpan(client.serviceClient.toResource(r.file), r));
+    await import_coc16.commands.executeCommand("editor.action.showReferences", doc.uri, import_vscode_languageserver_types2.Position.create(0, 0), locations);
+  }
+};
+var FileReferencesCommand = FileReferencesCommand2;
+FileReferencesCommand.minVersion = api_default.v420;
 function registCommand(cmd) {
   let {id, execute} = cmd;
-  return import_coc12.commands.registerCommand(id, execute, cmd);
+  return import_coc16.commands.registerCommand(id, execute, cmd);
 }
 
 // src/server/features/quickfix.ts
@@ -7811,7 +9636,7 @@ var ApplyFixAllCodeAction2 = class {
       }
       let {body} = res;
       const edit = WorkspaceEdit.fromFileCodeEdits(this.client, body.changes);
-      await import_coc13.workspace.applyEdit(edit);
+      await import_coc17.workspace.applyEdit(edit);
       const token = import_vscode_languageserver_protocol14.CancellationToken.None;
       const {commands: commands7} = body;
       if (commands7 && commands7.length) {
@@ -7898,7 +9723,7 @@ var TypeScriptQuickFixProvider = class {
   }
   async getFixesForDiagnostic(document, file2, diagnostic, token) {
     const args = {
-      ...Range.toFileRangeRequestArgs(file2, diagnostic.range),
+      ...Range2.toFileRangeRequestArgs(file2, diagnostic.range),
       errorCodes: [+diagnostic.code]
     };
     const codeFixesResponse = await this.client.execute("getCodeFixes", args, token);
@@ -7959,7 +9784,7 @@ var TypeScriptQuickFixProvider = class {
 var quickfix_default = TypeScriptQuickFixProvider;
 
 // src/server/features/refactor.ts
-var import_coc14 = __toModule(require("coc.nvim"));
+var import_coc18 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol15 = __toModule(require_main3());
 var ApplyRefactoringCommand2 = class {
   constructor(client) {
@@ -7968,7 +9793,7 @@ var ApplyRefactoringCommand2 = class {
   }
   async execute(document, file2, refactor, action, range) {
     const args = {
-      ...Range.toFileRangeRequestArgs(file2, range),
+      ...Range2.toFileRangeRequestArgs(file2, range),
       refactor,
       action
     };
@@ -7978,18 +9803,18 @@ var ApplyRefactoringCommand2 = class {
       return false;
     }
     const workspaceEdit = await this.toWorkspaceEdit(body);
-    if (!await import_coc14.workspace.applyEdit(workspaceEdit)) {
+    if (!await import_coc18.workspace.applyEdit(workspaceEdit)) {
       return false;
     }
     const renameLocation = body.renameLocation;
     if (renameLocation) {
-      import_coc14.commands.executeCommand("editor.action.rename", document.uri, Position.fromLocation(renameLocation));
+      import_coc18.commands.executeCommand("editor.action.rename", document.uri, Position.fromLocation(renameLocation));
     }
     return true;
   }
   async toWorkspaceEdit(body) {
     for (const edit of body.edits) {
-      await import_coc14.workspace.createFile(edit.fileName, {ignoreIfExists: true});
+      await import_coc18.workspace.createFile(edit.fileName, {ignoreIfExists: true});
     }
     let workspaceEdit = WorkspaceEdit.fromFileCodeEdits(this.client, body.edits);
     return workspaceEdit;
@@ -8004,7 +9829,7 @@ var SelectRefactorCommand2 = class {
   }
   async execute(document, file2, info, range) {
     let {actions} = info;
-    const idx = actions.length == 1 ? 0 : await import_coc14.window.showQuickpick(actions.map((action) => action.description || action.name));
+    const idx = actions.length == 1 ? 0 : await import_coc18.window.showQuickpick(actions.map((action) => action.description || action.name));
     if (idx == -1)
       return false;
     let label = info.actions[idx].name;
@@ -8031,7 +9856,7 @@ var TypeScriptRefactorProvider2 = class {
     if (!file2)
       return void 0;
     await this.formattingOptionsManager.ensureConfigurationForDocument(document, token);
-    const args = Range.toFileRangeRequestArgs(file2, range);
+    const args = Range2.toFileRangeRequestArgs(file2, range);
     let response;
     try {
       response = await this.client.interruptGetErr(() => {
@@ -8225,8 +10050,8 @@ var TypeScriptReferencesCodeLensProvider = class extends TypeScriptBaseCodeLensP
 var referencesCodeLens_default = TypeScriptReferencesCodeLensProvider;
 
 // src/server/features/rename.ts
-var import_coc15 = __toModule(require("coc.nvim"));
-var import_path3 = __toModule(require("path"));
+var import_coc19 = __toModule(require("coc.nvim"));
+var import_path4 = __toModule(require("path"));
 var TypeScriptRenameProvider = class {
   constructor(client, fileConfigurationManager) {
     this.client = client;
@@ -8244,7 +10069,7 @@ var TypeScriptRenameProvider = class {
     if (this.client.apiVersion.gte(api_default.v310)) {
       const triggerSpan = renameInfo.triggerSpan;
       if (triggerSpan) {
-        const range = Range.fromTextSpan(triggerSpan);
+        const range = Range2.fromTextSpan(triggerSpan);
         return range;
       }
     }
@@ -8293,7 +10118,7 @@ var TypeScriptRenameProvider = class {
         changes[uri] = [];
         for (const textSpan of spanGroup.locs) {
           changes[uri].push({
-            range: Range.fromTextSpan(textSpan),
+            range: Range2.fromTextSpan(textSpan),
             newText: (textSpan.prefixText || "") + newName + (textSpan.suffixText || "")
           });
         }
@@ -8302,11 +10127,11 @@ var TypeScriptRenameProvider = class {
     return {changes};
   }
   async renameFile(fileToRename, newName, token) {
-    if (!import_path3.default.extname(newName)) {
-      newName += import_path3.default.extname(fileToRename);
+    if (!import_path4.default.extname(newName)) {
+      newName += import_path4.default.extname(fileToRename);
     }
-    const dirname = import_path3.default.dirname(fileToRename);
-    const newFilePath = import_path3.default.join(dirname, newName);
+    const dirname = import_path4.default.dirname(fileToRename);
+    const newFilePath = import_path4.default.join(dirname, newName);
     const args = {
       file: fileToRename,
       oldFilePath: fileToRename,
@@ -8320,8 +10145,8 @@ var TypeScriptRenameProvider = class {
     edits.documentChanges = edits.documentChanges || [];
     edits.documentChanges.push({
       kind: "rename",
-      oldUri: import_coc15.Uri.file(fileToRename).toString(),
-      newUri: import_coc15.Uri.file(newFilePath).toString(),
+      oldUri: import_coc19.Uri.file(fileToRename).toString(),
+      newUri: import_coc19.Uri.file(newFilePath).toString(),
       options: {
         overwrite: false,
         ignoreIfExists: true
@@ -8412,15 +10237,117 @@ var SmartSelection = class {
   }
   static convertSelectionRange(selectionRange) {
     return {
-      range: Range.fromTextSpan(selectionRange.textSpan),
+      range: Range2.fromTextSpan(selectionRange.textSpan),
       parent: selectionRange.parent ? SmartSelection.convertSelectionRange(selectionRange.parent) : void 0
     };
   }
 };
 var smartSelect_default = SmartSelection;
 
+// src/server/features/tagClosing.ts
+var import_coc20 = __toModule(require("coc.nvim"));
+var TagClosing2 = class {
+  constructor(client, descriptionLanguageId) {
+    this.client = client;
+    this.descriptionLanguageId = descriptionLanguageId;
+    this._disposables = [];
+    this._disposed = false;
+    this._timeout = void 0;
+    this._cancel = void 0;
+    import_coc20.events.on("InsertCharPre", (character) => {
+      this.lastInsert = character;
+    }, null, this._disposables);
+    import_coc20.events.on("TextChangedI", this.onChange, this, this._disposables);
+    import_coc20.events.on("TextChangedP", this.onChange, this, this._disposables);
+  }
+  async onChange(bufnr, change) {
+    let doc = import_coc20.workspace.getDocument(bufnr);
+    if (!doc || !doc.attached)
+      return;
+    let enabled = this.isEnabled(doc.filetype, doc.uri);
+    if (!enabled)
+      return;
+    let {pre, changedtick, lnum} = change;
+    if (!pre.endsWith("/") && !pre.endsWith(">"))
+      return;
+    if (!pre.endsWith(this.lastInsert))
+      return;
+    if (pre.length > 1 && pre[pre.length - 2] == ">")
+      return;
+    const filepath = this.client.toOpenedFilePath(doc.uri);
+    if (!filepath)
+      return;
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    if (this._cancel) {
+      this._cancel.cancel();
+      this._cancel.dispose();
+      this._cancel = void 0;
+    }
+    await doc.patchChange();
+    this._timeout = setTimeout(async () => {
+      this._timeout = void 0;
+      if (this._disposed)
+        return;
+      if (doc.changedtick > changedtick)
+        return;
+      const position = import_coc20.Position.create(lnum - 1, pre.length);
+      const args = Position.toFileLocationRequestArgs(filepath, position);
+      this._cancel = new import_coc20.CancellationTokenSource();
+      const response = await this.client.execute("jsxClosingTag", args, this._cancel.token);
+      if (response.type !== "response" || !response.body) {
+        return;
+      }
+      if (this._disposed)
+        return;
+      const insertion = response.body;
+      if (doc.changedtick === changedtick) {
+        import_coc20.snippetManager.insertSnippet(this.getTagSnippet(insertion).value, false, import_coc20.Range.create(position, position));
+      }
+    }, 50);
+  }
+  isEnabled(languageId, uri) {
+    const configLang = TagClosing2._configurationLanguages[languageId];
+    if (!configLang || configLang !== this.descriptionLanguageId) {
+      return false;
+    }
+    if (!import_coc20.workspace.getConfiguration(void 0, uri).get(`${configLang}.autoClosingTags`)) {
+      return false;
+    }
+    return true;
+  }
+  dispose() {
+    this._disposed = true;
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this._timeout = void 0;
+    }
+    if (this._cancel) {
+      this._cancel.cancel();
+      this._cancel.dispose();
+      this._cancel = void 0;
+    }
+    import_coc20.disposeAll(this._disposables);
+    this._disposables = [];
+  }
+  getTagSnippet(closingTag) {
+    const snippet = new SnippetString_default();
+    snippet.appendPlaceholder("", 0);
+    snippet.appendText(closingTag.newText);
+    return snippet;
+  }
+};
+var TagClosing = TagClosing2;
+TagClosing.minVersion = api_default.v300;
+TagClosing._configurationLanguages = {
+  javascriptreact: "javascript",
+  typescriptreact: "typescript"
+};
+var tagClosing_default = TagClosing;
+
 // src/server/features/updatePathOnRename.ts
-var import_coc16 = __toModule(require("coc.nvim"));
+var import_coc21 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol16 = __toModule(require_main3());
 
 // src/server/utils/mutex.ts
@@ -8482,7 +10409,7 @@ var UpdateImportsOnFileRenameHandler = class {
     this.fileConfigurationManager = fileConfigurationManager;
     this.disposables = [];
     let glob = languageId == "typescript" ? "**/*.{ts,tsx}" : "**/*.{js,jsx}";
-    const watcher = import_coc16.workspace.createFileSystemWatcher(glob);
+    const watcher = import_coc21.workspace.createFileSystemWatcher(glob);
     this.disposables.push(watcher);
     let mutex = new Mutex();
     watcher.onDidRename(async (e) => {
@@ -8497,7 +10424,7 @@ var UpdateImportsOnFileRenameHandler = class {
     }, null, this.disposables);
   }
   dispose() {
-    import_coc16.disposeAll(this.disposables);
+    import_coc21.disposeAll(this.disposables);
   }
   async doRename(oldResource, newResource) {
     if (oldResource.scheme !== "file" || newResource.scheme !== "file") {
@@ -8506,16 +10433,16 @@ var UpdateImportsOnFileRenameHandler = class {
     const targetFile = newResource.fsPath;
     const oldFile = oldResource.fsPath;
     const newUri = newResource.toString();
-    let oldDocument = import_coc16.workspace.getDocument(oldResource.toString());
+    let oldDocument = import_coc21.workspace.getDocument(oldResource.toString());
     if (oldDocument) {
-      await import_coc16.workspace.nvim.command(`silent ${oldDocument.bufnr}bwipeout!`);
+      await import_coc21.workspace.nvim.command(`silent ${oldDocument.bufnr}bwipeout!`);
     }
-    let document = import_coc16.workspace.getDocument(newUri);
+    let document = import_coc21.workspace.getDocument(newUri);
     if (document) {
-      await import_coc16.workspace.nvim.command(`silent ${document.bufnr}bwipeout!`);
+      await import_coc21.workspace.nvim.command(`silent ${document.bufnr}bwipeout!`);
       await wait(30);
     }
-    document = await import_coc16.workspace.loadFile(newUri);
+    document = await import_coc21.workspace.loadFile(newUri);
     if (!document)
       return;
     await wait(50);
@@ -8523,11 +10450,11 @@ var UpdateImportsOnFileRenameHandler = class {
     if (!edits)
       return;
     if (await this.promptUser(newResource)) {
-      await import_coc16.workspace.applyEdit(edits);
+      await import_coc21.workspace.applyEdit(edits);
     }
   }
   async promptUser(newResource) {
-    return await import_coc16.window.showPrompt(`Update imports for moved file: ${newResource.fsPath}?`);
+    return await import_coc21.window.showPrompt(`Update imports for moved file: ${newResource.fsPath}?`);
   }
   async getEditsForFileRename(document, oldFile, newFile) {
     await this.fileConfigurationManager.ensureConfigurationForDocument(document, import_vscode_languageserver_protocol16.CancellationToken.None);
@@ -8559,7 +10486,7 @@ var UpdateImportsOnFileRenameHandler = class {
 var updatePathOnRename_default = UpdateImportsOnFileRenameHandler;
 
 // src/server/organizeImports.ts
-var import_coc17 = __toModule(require("coc.nvim"));
+var import_coc22 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol17 = __toModule(require_main3());
 var OrganizeImportsCommand = class {
   constructor(service) {
@@ -8583,19 +10510,19 @@ var OrganizeImportsCommand = class {
     const edit = WorkspaceEdit.fromFileCodeEdits(client, response.body);
     let keys = Object.keys(edit.changes);
     if (keys.length == 1) {
-      let doc = import_coc17.workspace.getDocument(keys[0]);
+      let doc = import_coc22.workspace.getDocument(keys[0]);
       if (doc) {
         await doc.applyEdits(edit.changes[keys[0]]);
         return;
       }
     }
     if (edit)
-      await import_coc17.workspace.applyEdit(edit);
+      await import_coc22.workspace.applyEdit(edit);
   }
   async execute(document) {
     let client = await this.service.getClientHost();
     if (!document) {
-      let doc = await import_coc17.workspace.document;
+      let doc = await import_coc22.workspace.document;
       if (!doc.attached) {
         throw new Error(`Document not attached.`);
       }
@@ -8638,9 +10565,8 @@ var LanguageProvider = class {
     this.client = client;
     this.fileConfigurationManager = fileConfigurationManager;
     this.description = description;
-    this.typingsStatus = typingsStatus;
     this.disposables = [];
-    import_coc18.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
+    import_coc23.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
     this.configurationChanged();
     let initialized = false;
     client.onTsServerStarted(async () => {
@@ -8651,11 +10577,11 @@ var LanguageProvider = class {
     });
   }
   configurationChanged() {
-    const config = import_coc18.workspace.getConfiguration(this.id, null);
+    const config = import_coc23.workspace.getConfiguration(this.id, null);
     this.client.diagnosticsManager.setEnableSuggestions(this.id, config.get(suggestionSetting, true));
   }
   dispose() {
-    import_coc18.disposeAll(this.disposables);
+    import_coc23.disposeAll(this.disposables);
   }
   _register(disposable) {
     this.disposables.push(disposable);
@@ -8663,25 +10589,28 @@ var LanguageProvider = class {
   registerProviders(client, typingsStatus) {
     let languageIds = this.description.modeIds;
     let clientId = `tsserver-${this.description.id}`;
-    this._register(import_coc18.languages.registerCompletionItemProvider(clientId, "TSC", languageIds, new completionItemProvider_default(client, typingsStatus, this.fileConfigurationManager, this.description.id), completionItemProvider_default.triggerCharacters));
+    this._register(import_coc23.languages.registerCompletionItemProvider(clientId, "TSC", languageIds, new completionItemProvider_default(client, typingsStatus, this.fileConfigurationManager, this.description.id), completionItemProvider_default.triggerCharacters));
     if (this.client.apiVersion.gte(api_default.v230)) {
-      this._register(import_coc18.languages.registerCompletionItemProvider(`${this.description.id}-directive`, "TSC", languageIds, new directiveCommentCompletions_default(client), ["@"]));
+      this._register(import_coc23.languages.registerCompletionItemProvider(`${this.description.id}-directive`, "TSC", languageIds, new directiveCommentCompletions_default(client), ["@"]));
     }
     let definitionProvider = new definitionProvider_default(client);
-    this._register(import_coc18.languages.registerDefinitionProvider(languageIds, definitionProvider));
-    this._register(import_coc18.languages.registerTypeDefinitionProvider(languageIds, definitionProvider));
-    this._register(import_coc18.languages.registerImplementationProvider(languageIds, definitionProvider));
-    this._register(import_coc18.languages.registerReferencesProvider(languageIds, new references_default(client)));
-    this._register(import_coc18.languages.registerHoverProvider(languageIds, new hover_default(client)));
-    this._register(import_coc18.languages.registerDocumentHighlightProvider(languageIds, new documentHighlight_default(this.client)));
-    this._register(import_coc18.languages.registerSignatureHelpProvider(languageIds, new signatureHelp_default(client), ["(", ",", "<", ")"]));
-    this._register(import_coc18.languages.registerDocumentSymbolProvider(languageIds, new documentSymbol_default(client)));
-    this._register(import_coc18.languages.registerRenameProvider(languageIds, new rename_default(client, this.fileConfigurationManager)));
+    this._register(import_coc23.languages.registerDefinitionProvider(languageIds, definitionProvider));
+    this._register(import_coc23.languages.registerTypeDefinitionProvider(languageIds, definitionProvider));
+    this._register(import_coc23.languages.registerImplementationProvider(languageIds, definitionProvider));
+    this._register(import_coc23.languages.registerReferencesProvider(languageIds, new references_default(client)));
+    this._register(import_coc23.languages.registerHoverProvider(languageIds, new hover_default(client)));
+    this._register(import_coc23.languages.registerDocumentHighlightProvider(languageIds, new documentHighlight_default(this.client)));
+    this._register(import_coc23.languages.registerSignatureHelpProvider(languageIds, new signatureHelp_default(client), ["(", ",", "<", ")"]));
+    this._register(import_coc23.languages.registerDocumentSymbolProvider(languageIds, new documentSymbol_default(client)));
+    this._register(import_coc23.languages.registerRenameProvider(languageIds, new rename_default(client, this.fileConfigurationManager)));
     let formatProvider = new formatting_default(client, this.fileConfigurationManager);
-    this._register(import_coc18.languages.registerDocumentFormatProvider(languageIds, formatProvider));
-    this._register(import_coc18.languages.registerDocumentRangeFormatProvider(languageIds, formatProvider));
-    this._register(import_coc18.languages.registerOnTypeFormattingEditProvider(languageIds, formatProvider, [";", "}", "\n", String.fromCharCode(27)]));
-    this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new moduleInstall_default(client), "tsserver"));
+    this._register(import_coc23.languages.registerDocumentFormatProvider(languageIds, formatProvider));
+    this._register(import_coc23.languages.registerDocumentRangeFormatProvider(languageIds, formatProvider));
+    this._register(import_coc23.languages.registerOnTypeFormattingEditProvider(languageIds, formatProvider, [";", "}", "\n", String.fromCharCode(27)]));
+    this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new moduleInstall_default(client), "tsserver"));
+    if (typeof import_coc23.languages["registerCallHierarchyProvider"] === "function") {
+      this._register(import_coc23.languages.registerCallHierarchyProvider(languageIds, new callHierarchy_default(client)));
+    }
     let {fileConfigurationManager} = this;
     let conf = fileConfigurationManager.getLanguageConfiguration(this.id);
     if (["javascript", "typescript"].includes(this.id)) {
@@ -8690,30 +10619,33 @@ var LanguageProvider = class {
       }
     }
     if (this.client.apiVersion.gte(api_default.v280)) {
-      this._register(import_coc18.languages.registerFoldingRangeProvider(languageIds, new folding_default(this.client)));
-      this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new OrganizeImportsCodeActionProvider(this.client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.SourceOrganizeImports]));
+      this._register(import_coc23.languages.registerFoldingRangeProvider(languageIds, new folding_default(this.client)));
+      this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new OrganizeImportsCodeActionProvider(this.client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.SourceOrganizeImports]));
     }
     if (this.client.apiVersion.gte(api_default.v240)) {
-      this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new refactor_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.Refactor]));
+      this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new refactor_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.Refactor]));
     }
-    this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new quickfix_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
-    this._register(import_coc18.languages.registerCodeActionProvider(languageIds, new importFix_default(this.client.bufferSyncSupport), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
+    this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new quickfix_default(client, this.fileConfigurationManager), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
+    this._register(import_coc23.languages.registerCodeActionProvider(languageIds, new importFix_default(this.client.bufferSyncSupport), "tsserver", [import_vscode_languageserver_protocol18.CodeActionKind.QuickFix]));
     let cachedResponse = new CachedNavTreeResponse();
     if (this.client.apiVersion.gte(api_default.v206) && conf.get("referencesCodeLens.enable")) {
-      this._register(import_coc18.languages.registerCodeLensProvider(languageIds, new referencesCodeLens_default(client, cachedResponse)));
+      this._register(import_coc23.languages.registerCodeLensProvider(languageIds, new referencesCodeLens_default(client, cachedResponse)));
     }
     if (this.client.apiVersion.gte(api_default.v220) && conf.get("implementationsCodeLens.enable")) {
-      this._register(import_coc18.languages.registerCodeLensProvider(languageIds, new implementationsCodeLens_default(client, cachedResponse)));
+      this._register(import_coc23.languages.registerCodeLensProvider(languageIds, new implementationsCodeLens_default(client, cachedResponse)));
     }
     if (this.client.apiVersion.gte(api_default.v350)) {
-      this._register(import_coc18.languages.registerSelectionRangeProvider(languageIds, new smartSelect_default(this.client)));
+      this._register(import_coc23.languages.registerSelectionRangeProvider(languageIds, new smartSelect_default(this.client)));
+    }
+    if (this.client.apiVersion.gte(api_default.v300)) {
+      this._register(new tagClosing_default(this.client, this.description.id));
     }
   }
   handles(resource, doc) {
     if (doc && this.description.modeIds.indexOf(doc.languageId) >= 0) {
       return true;
     }
-    const base = import_path4.default.basename(import_coc18.Uri.parse(resource).fsPath);
+    const base = import_path5.default.basename(import_coc23.Uri.parse(resource).fsPath);
     return !!base && (!!this.description.configFilePattern && this.description.configFilePattern.test(base));
   }
   get id() {
@@ -8726,15 +10658,20 @@ var LanguageProvider = class {
     this.client.bufferSyncSupport.requestAllDiagnostics();
   }
   diagnosticsReceived(diagnosticsKind, file2, diagnostics) {
-    const config = import_coc18.workspace.getConfiguration(this.id, file2.toString());
+    const config = import_coc23.workspace.getConfiguration(this.id, file2.toString());
     const reportUnnecessary = config.get("showUnused", true);
+    const reportDeprecated = config.get("showDeprecated", true);
     this.client.diagnosticsManager.diagnosticsReceived(diagnosticsKind, file2.toString(), diagnostics.filter((diag) => {
       if (!reportUnnecessary) {
-        diag.tags = void 0;
         if (diag.reportUnnecessary && diag.severity === import_vscode_languageserver_protocol18.DiagnosticSeverity.Information) {
           return false;
         }
       }
+      if (!reportDeprecated) {
+        if (diag.reportDeprecated && diag.severity === import_vscode_languageserver_protocol18.DiagnosticSeverity.Hint) {
+          return false;
+        }
+      }
       return true;
     }));
   }
@@ -8742,11 +10679,11 @@ var LanguageProvider = class {
 var languageProvider_default = LanguageProvider;
 
 // src/server/typescriptServiceClient.ts
-var import_coc27 = __toModule(require("coc.nvim"));
+var import_coc32 = __toModule(require("coc.nvim"));
 var import_fs4 = __toModule(require("fs"));
 var import_os2 = __toModule(require("os"));
-var import_path7 = __toModule(require("path"));
-var import_vscode_languageserver_protocol20 = __toModule(require_main3());
+var import_path8 = __toModule(require("path"));
+var import_vscode_languageserver_protocol21 = __toModule(require_main3());
 
 // src/utils/fileSchemess.ts
 var file = "file";
@@ -8816,7 +10753,7 @@ var CallbackMap = class {
 };
 
 // src/server/features/bufferSyncSupport.ts
-var import_coc20 = __toModule(require("coc.nvim"));
+var import_coc25 = __toModule(require("coc.nvim"));
 var import_vscode_languageserver_protocol19 = __toModule(require_main3());
 
 // src/server/utils/async.ts
@@ -8889,9 +10826,9 @@ function mode2ScriptKind(mode) {
 }
 
 // src/server/features/resourceMap.ts
-var import_coc19 = __toModule(require("coc.nvim"));
+var import_coc24 = __toModule(require("coc.nvim"));
 function defaultPathNormalizer(resource) {
-  let u = import_coc19.Uri.parse(resource);
+  let u = import_coc24.Uri.parse(resource);
   if (u.scheme === "file") {
     return u.fsPath;
   }
@@ -8947,11 +10884,11 @@ var ResourceMap = class {
     }
     return this.isCaseInsensitivePath(key) ? key.toLowerCase() : key;
   }
-  isCaseInsensitivePath(path8) {
-    if (isWindowsPath(path8)) {
+  isCaseInsensitivePath(path9) {
+    if (isWindowsPath(path9)) {
       return true;
     }
-    return path8[0] === "/" && this.onIsCaseInsenitiveFileSystem;
+    return path9[0] === "/" && this.onIsCaseInsenitiveFileSystem;
   }
   get onIsCaseInsenitiveFileSystem() {
     if (process.platform === "win32") {
@@ -8963,8 +10900,8 @@ var ResourceMap = class {
     return false;
   }
 };
-function isWindowsPath(path8) {
-  return /^[a-zA-Z]:\\/.test(path8);
+function isWindowsPath(path9) {
+  return /^[a-zA-Z]:\\/.test(path9);
 }
 
 // src/server/features/bufferSyncSupport.ts
@@ -9050,16 +10987,16 @@ var SyncedBuffer = class {
     this.state = 2;
     return this.synchronizer.close(this.resource, this.filepath);
   }
-  onContentChanged(events2) {
+  onContentChanged(events3) {
     if (this.state !== 2) {
       console.error(`Unexpected buffer state: ${this.state}`);
     }
-    this.synchronizer.change(this.resource, this.filepath, events2);
+    this.synchronizer.change(this.resource, this.filepath, events3);
   }
 };
 var SyncedBufferMap = class extends ResourceMap {
   getForPath(filePath) {
-    return this.get(import_coc20.Uri.file(filePath).toString());
+    return this.get(import_coc25.Uri.file(filePath).toString());
   }
   get allBuffers() {
     return this.values;
@@ -9096,24 +11033,24 @@ var BufferSynchronizer = class {
       return true;
     }
   }
-  change(resource, filepath, events2) {
-    if (!events2.length) {
+  change(resource, filepath, events3) {
+    if (!events3.length) {
       return;
     }
     if (this.supportsBatching) {
       this.updatePending(resource, new ChangeOperation({
         fileName: filepath,
-        textChanges: events2.map((change) => ({
+        textChanges: events3.map((change) => ({
           newText: change.text,
           start: Position.toLocation(change.range.start),
           end: Position.toLocation(change.range.end)
         })).reverse()
       }));
     } else {
-      for (const {range, text} of events2) {
+      for (const {range, text} of events3) {
         const args = {
           insertString: text,
-          ...Range.toFormattingRequestArgs(filepath, range)
+          ...Range2.toFormattingRequestArgs(filepath, range)
         };
         this.client.executeWithoutWaitingForResponse("change", args);
       }
@@ -9218,29 +11155,29 @@ var BufferSyncSupport = class {
     this.client = client;
     this.modeIds = new Set(modeIds);
     this.diagnosticDelayer = new Delayer(300);
-    const pathNormalizer = (path8) => this.client.toPath(path8);
+    const pathNormalizer = (path9) => this.client.toPath(path9);
     this.syncedBuffers = new SyncedBufferMap(pathNormalizer);
     this.pendingDiagnostics = new PendingDiagnostics(pathNormalizer);
     this.synchronizer = new BufferSynchronizer(client, pathNormalizer);
     this.updateConfiguration();
-    import_coc20.workspace.onDidChangeConfiguration(this.updateConfiguration, this, this.disposables);
+    import_coc25.workspace.onDidChangeConfiguration(this.updateConfiguration, this, this.disposables);
   }
   listen() {
     if (this.listening) {
       return;
     }
     this.listening = true;
-    import_coc20.workspace.onDidOpenTextDocument(this.openTextDocument, this, this.disposables);
-    import_coc20.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, this.disposables);
-    import_coc20.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, this.disposables);
-    import_coc20.workspace.textDocuments.forEach(this.openTextDocument, this);
+    import_coc25.workspace.onDidOpenTextDocument(this.openTextDocument, this, this.disposables);
+    import_coc25.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, this.disposables);
+    import_coc25.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, this.disposables);
+    import_coc25.workspace.textDocuments.forEach(this.openTextDocument, this);
   }
   handles(resource) {
     return this.syncedBuffers.has(resource);
   }
   dispose() {
     this.pendingDiagnostics.clear();
-    import_coc20.disposeAll(this.disposables);
+    import_coc25.disposeAll(this.disposables);
     this._onWillChange.dispose();
     this._onDelete.dispose();
   }
@@ -9248,7 +11185,7 @@ var BufferSyncSupport = class {
     if (this.syncedBuffers.has(resource)) {
       return true;
     }
-    const existingDocument = import_coc20.workspace.textDocuments.find((doc) => doc.uri.toString() === resource);
+    const existingDocument = import_coc25.workspace.textDocuments.find((doc) => doc.uri.toString() === resource);
     if (existingDocument) {
       return this.openTextDocument(existingDocument);
     }
@@ -9258,7 +11195,7 @@ var BufferSyncSupport = class {
     const buffer = this.syncedBuffers.getForPath(filePath);
     if (buffer)
       return buffer.resource;
-    return import_coc20.Uri.file(filePath).toString();
+    return import_coc25.Uri.file(filePath).toString();
   }
   reset() {
     var _a;
@@ -9277,7 +11214,7 @@ var BufferSyncSupport = class {
       return false;
     }
     const resource = document.uri;
-    const filepath = this.client.normalizePath(import_coc20.Uri.parse(resource));
+    const filepath = this.client.normalizePath(import_coc25.Uri.parse(resource));
     if (!filepath) {
       return false;
     }
@@ -9392,7 +11329,7 @@ var BufferSyncSupport = class {
       }
     }
     if (orderedFileSet.size) {
-      let uris = Array.from(orderedFileSet.uris).map((uri) => import_coc20.Uri.parse(uri));
+      let uris = Array.from(orderedFileSet.uris).map((uri) => import_coc25.Uri.parse(uri));
       const getErr = this.pendingGetErr = GetErrRequest.executeGetErrRequest(this.client, uris, () => {
         if (this.pendingGetErr === getErr) {
           this.pendingGetErr = void 0;
@@ -9402,8 +11339,8 @@ var BufferSyncSupport = class {
     this.pendingDiagnostics.clear();
   }
   updateConfiguration() {
-    const jsConfig = import_coc20.workspace.getConfiguration("javascript", null);
-    const tsConfig = import_coc20.workspace.getConfiguration("typescript", null);
+    const jsConfig = import_coc25.workspace.getConfiguration("javascript", null);
+    const tsConfig = import_coc25.workspace.getConfiguration("typescript", null);
     this._validateJavaScript = jsConfig.get("validate.enable", true);
     this._validateTypeScript = tsConfig.get("validate.enable", true);
   }
@@ -9420,7 +11357,8 @@ var BufferSyncSupport = class {
 var bufferSyncSupport_default = BufferSyncSupport;
 
 // src/server/features/diagnostics.ts
-var import_coc21 = __toModule(require("coc.nvim"));
+var import_coc26 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol20 = __toModule(require_main3());
 var DiagnosticSet = class {
   constructor() {
     this._map = new ResourceMap();
@@ -9456,7 +11394,7 @@ var DiagnosticsManager = class {
     for (const kind of allDiagnosticKinds) {
       this._diagnostics.set(kind, new DiagnosticSet());
     }
-    this._currentDiagnostics = import_coc21.languages.createDiagnosticCollection("tsserver");
+    this._currentDiagnostics = import_coc26.languages.createDiagnosticCollection("tsserver");
   }
   dispose() {
     this._currentDiagnostics.dispose();
@@ -9486,7 +11424,7 @@ var DiagnosticsManager = class {
     const collection = this._diagnostics.get(kind);
     if (!collection)
       return;
-    let doc = import_coc21.workspace.getDocument(uri);
+    let doc = import_coc26.workspace.getDocument(uri);
     if (doc)
       uri = doc.uri;
     if (diagnostics.length === 0) {
@@ -9529,13 +11467,13 @@ var DiagnosticsManager = class {
     const enabled = this.suggestionsEnabled(uri);
     return this._diagnostics.get(2).get(uri).filter((x) => {
       if (!enabled) {
-        return x.code == 6133;
+        return x.tags && (x.tags.includes(import_vscode_languageserver_protocol20.DiagnosticTag.Unnecessary) || x.tags.includes(import_vscode_languageserver_protocol20.DiagnosticTag.Deprecated));
       }
       return enabled;
     });
   }
   suggestionsEnabled(uri) {
-    let doc = import_coc21.workspace.getDocument(uri);
+    let doc = import_coc26.workspace.getDocument(uri);
     if (!doc)
       return false;
     if (doc.filetype.startsWith("javascript")) {
@@ -9600,7 +11538,7 @@ var RequestQueue = class {
 };
 
 // src/server/utils/configuration.ts
-var import_coc22 = __toModule(require("coc.nvim"));
+var import_coc27 = __toModule(require("coc.nvim"));
 var import_which = __toModule(require_which());
 var TsServerLogLevel;
 (function(TsServerLogLevel2) {
@@ -9641,9 +11579,9 @@ var TsServerLogLevel;
 })(TsServerLogLevel || (TsServerLogLevel = {}));
 var TypeScriptServiceConfiguration = class {
   constructor() {
-    this._configuration = import_coc22.workspace.getConfiguration("tsserver");
-    import_coc22.workspace.onDidChangeConfiguration(() => {
-      this._configuration = import_coc22.workspace.getConfiguration("tsserver");
+    this._configuration = import_coc27.workspace.getConfiguration("tsserver");
+    import_coc27.workspace.onDidChangeConfiguration(() => {
+      this._configuration = import_coc27.workspace.getConfiguration("tsserver");
     });
   }
   get locale() {
@@ -9686,15 +11624,15 @@ var TypeScriptServiceConfiguration = class {
     return this._configuration.get("debugPort", parseInt(process.env["TSS_DEBUG"], 10));
   }
   get npmLocation() {
-    let path8 = this._configuration.get("npm", "");
-    if (path8)
-      return import_coc22.workspace.expand(path8);
+    let path9 = this._configuration.get("npm", "");
+    if (path9)
+      return import_coc27.workspace.expand(path9);
     try {
-      path8 = import_which.default.sync("npm");
+      path9 = import_which.default.sync("npm");
     } catch (e) {
       return null;
     }
-    return path8;
+    return path9;
   }
   static loadFromWorkspace() {
     return new TypeScriptServiceConfiguration();
@@ -9702,7 +11640,7 @@ var TypeScriptServiceConfiguration = class {
 };
 
 // src/server/utils/logger.ts
-var import_coc23 = __toModule(require("coc.nvim"));
+var import_coc28 = __toModule(require("coc.nvim"));
 
 // src/server/utils/is.ts
 var toString = Object.prototype.toString;
@@ -9719,7 +11657,7 @@ var Logger = class {
     if (this._channel) {
       return this._channel;
     }
-    this._channel = import_coc23.window.createOutputChannel("tsserver");
+    this._channel = import_coc28.window.createOutputChannel("tsserver");
     return this._channel;
   }
   dispose() {
@@ -9767,7 +11705,7 @@ var logger_default = Logger;
 var import_child_process2 = __toModule(require("child_process"));
 var import_net = __toModule(require("net"));
 var import_os = __toModule(require("os"));
-var import_path5 = __toModule(require("path"));
+var import_path6 = __toModule(require("path"));
 var import_fs2 = __toModule(require("fs"));
 function makeRandomHexString(length) {
   let chars = ["0", "1", "2", "3", "4", "5", "6", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
@@ -9779,7 +11717,7 @@ function makeRandomHexString(length) {
   return result;
 }
 function getTempDirectory() {
-  let dir = import_path5.default.join(import_os.default.tmpdir(), `coc.nvim-${process.pid}`);
+  let dir = import_path6.default.join(import_os.default.tmpdir(), `coc.nvim-${process.pid}`);
   if (!import_fs2.default.existsSync(dir)) {
     import_fs2.default.mkdirSync(dir);
   }
@@ -9794,18 +11732,18 @@ function getPipeName(name) {
     return "\\\\.\\pipe\\" + fullName + "-sock";
   }
   const tmpdir = getTempDirectory();
-  return import_path5.default.join(tmpdir, fullName + ".sock");
+  return import_path6.default.join(tmpdir, fullName + ".sock");
 }
 function getTempFile(name) {
   const fullName = "coc-nvim-" + name;
-  return import_path5.default.join(getTempDirectory(), fullName + ".sock");
+  return import_path6.default.join(getTempDirectory(), fullName + ".sock");
 }
 function generatePatchedEnv(env, stdInPipeName, stdOutPipeName, stdErrPipeName) {
   const newEnv = Object.assign({}, env);
   newEnv["STDIN_PIPE_NAME"] = stdInPipeName;
   newEnv["STDOUT_PIPE_NAME"] = stdOutPipeName;
   newEnv["STDERR_PIPE_NAME"] = stdErrPipeName;
-  newEnv["TSS_LOG"] = `-level verbose -file ${import_path5.default.join(import_os.default.tmpdir(), "coc-nvim-tsc.log")}`;
+  newEnv["TSS_LOG"] = `-level verbose -file ${import_path6.default.join(import_os.default.tmpdir(), "coc-nvim-tsc.log")}`;
   newEnv["PATH"] = newEnv["PATH"] || process.env.PATH;
   return newEnv;
 }
@@ -9829,7 +11767,7 @@ function fork(modulePath, args, options, logger, callback) {
   const stdOutPipeName = generatePipeName();
   const stdErrPipeName = generatePipeName();
   const newEnv = generatePatchedEnv(process.env, stdInPipeName, stdOutPipeName, stdErrPipeName);
-  newEnv["NODE_PATH"] = import_path5.default.join(modulePath, "..", "..", "..");
+  newEnv["NODE_PATH"] = import_path6.default.join(modulePath, "..", "..", "..");
   let childProcess;
   let stdErrServer = import_net.default.createServer((stdErrStream) => {
     childProcess.stderr = stdErrStream;
@@ -9853,7 +11791,7 @@ function fork(modulePath, args, options, logger, callback) {
     stdErrServer.close();
   };
   logger.info("Forking TSServer", `PATH: ${newEnv["PATH"]} `);
-  const bootstrapperPath = import_path5.default.resolve(__dirname, "../bin/tsserverForkStart");
+  const bootstrapperPath = import_path6.default.resolve(__dirname, "../bin/tsserverForkStart");
   childProcess = import_child_process2.default.fork(bootstrapperPath, [modulePath].concat(args), {
     silent: true,
     env: newEnv,
@@ -9870,7 +11808,7 @@ function fork(modulePath, args, options, logger, callback) {
 }
 
 // src/server/utils/tracer.ts
-var import_coc24 = __toModule(require("coc.nvim"));
+var import_coc29 = __toModule(require("coc.nvim"));
 var Trace;
 (function(Trace2) {
   Trace2[Trace2["Off"] = 0] = "Off";
@@ -9900,7 +11838,7 @@ var Tracer = class {
     this.trace = Tracer.readTrace();
   }
   static readTrace() {
-    let result = Trace.fromString(import_coc24.workspace.getConfiguration("tsserver").get("trace.server", "off"));
+    let result = Trace.fromString(import_coc29.workspace.getConfiguration("tsserver").get("trace.server", "off"));
     if (result === 0 && !!process.env.TSS_TRACE) {
       result = 1;
     }
@@ -9966,20 +11904,20 @@ function inferredProjectConfig(config) {
 }
 
 // src/server/utils/versionProvider.ts
-var import_coc25 = __toModule(require("coc.nvim"));
+var import_coc30 = __toModule(require("coc.nvim"));
 var import_fs3 = __toModule(require("fs"));
-var import_path6 = __toModule(require("path"));
+var import_path7 = __toModule(require("path"));
 var TypeScriptVersion = class {
-  constructor(path8, _pathLabel) {
-    this.path = path8;
+  constructor(path9, _pathLabel) {
+    this.path = path9;
     this._pathLabel = _pathLabel;
     this._api = null;
   }
   get tscPath() {
-    return import_path6.default.resolve(this.path, "../bin/tsc");
+    return import_path7.default.resolve(this.path, "../bin/tsc");
   }
   get tsServerPath() {
-    return import_path6.default.resolve(this.path, "tsserver.js");
+    return import_path7.default.resolve(this.path, "tsserver.js");
   }
   get pathLabel() {
     return typeof this._pathLabel === "undefined" ? this.path : this._pathLabel;
@@ -10001,16 +11939,16 @@ var TypeScriptVersion = class {
     if (!import_fs3.default.existsSync(serverPath)) {
       return void 0;
     }
-    const p = serverPath.split(import_path6.default.sep);
+    const p = serverPath.split(import_path7.default.sep);
     if (p.length <= 2) {
       return void 0;
     }
     const p2 = p.slice(0, -2);
-    const modulePath = p2.join(import_path6.default.sep);
-    let fileName = import_path6.default.join(modulePath, "package.json");
+    const modulePath = p2.join(import_path7.default.sep);
+    let fileName = import_path7.default.join(modulePath, "package.json");
     if (!import_fs3.default.existsSync(fileName)) {
-      if (import_path6.default.basename(modulePath) === "built") {
-        fileName = import_path6.default.join(modulePath, "..", "package.json");
+      if (import_path7.default.basename(modulePath) === "built") {
+        fileName = import_path7.default.join(modulePath, "..", "package.json");
       }
     }
     if (!import_fs3.default.existsSync(fileName)) {
@@ -10046,14 +11984,14 @@ var TypeScriptVersionProvider = class {
   get globalVersion() {
     let {globalTsdk} = this.configuration;
     if (globalTsdk)
-      return new TypeScriptVersion(import_coc25.workspace.expand(globalTsdk));
+      return new TypeScriptVersion(import_coc30.workspace.expand(globalTsdk));
     return void 0;
   }
   getLocalVersion() {
-    let folders = import_coc25.workspace.workspaceFolders.map((f) => import_coc25.Uri.parse(f.uri).fsPath);
+    let folders = import_coc30.workspace.workspaceFolders.map((f) => import_coc30.Uri.parse(f.uri).fsPath);
     for (let p of folders) {
       for (let folder of MODULE_FOLDERS) {
-        let libFolder = import_path6.default.join(p, folder);
+        let libFolder = import_path7.default.join(p, folder);
         if (import_fs3.default.existsSync(libFolder)) {
           let version = new TypeScriptVersion(libFolder);
           if (version.isValid)
@@ -10066,24 +12004,24 @@ var TypeScriptVersionProvider = class {
   get bundledVersion() {
     try {
       const file2 = require.resolve("typescript");
-      const bundledVersion = new TypeScriptVersion(import_path6.default.dirname(file2), "");
+      const bundledVersion = new TypeScriptVersion(import_path7.default.dirname(file2), "");
       return bundledVersion;
     } catch (e) {
-      import_coc25.window.showMessage("Bundled typescript module not found", "error");
+      import_coc30.window.showMessage("Bundled typescript module not found", "error");
       return null;
     }
   }
 };
 
 // src/server/utils/versionStatus.ts
-var import_coc26 = __toModule(require("coc.nvim"));
+var import_coc31 = __toModule(require("coc.nvim"));
 var VersionStatus = class {
   constructor(_normalizePath, enableJavascript) {
     this._normalizePath = _normalizePath;
     this.enableJavascript = enableJavascript;
     this._versionString = "";
-    this._versionBarEntry = import_coc26.window.createStatusBarItem(99);
-    this._onChangeEditorSub = import_coc26.events.on("BufEnter", this.onBufEnter, this);
+    this._versionBarEntry = import_coc31.window.createStatusBarItem(99);
+    this._onChangeEditorSub = import_coc31.events.on("BufEnter", this.onBufEnter, this);
     this._versionBarEntry.show();
   }
   dispose() {
@@ -10095,7 +12033,7 @@ var VersionStatus = class {
   }
   set loading(isLoading) {
     if (isLoading) {
-      this._versionBarEntry.text = `Initialing tsserver ${this._versionString}`;
+      this._versionBarEntry.text = `Initializing tsserver ${this._versionString}`;
     } else {
       this._versionBarEntry.text = `TSC ${this._versionString}`;
     }
@@ -10108,7 +12046,7 @@ var VersionStatus = class {
     return filetype.startsWith("typescript");
   }
   async onBufEnter(bufnr) {
-    let filetype = await import_coc26.workspace.nvim.call("getbufvar", [bufnr, "&filetype", ""]);
+    let filetype = await import_coc31.workspace.nvim.call("getbufvar", [bufnr, "&filetype", ""]);
     if (this.checkFiletype(filetype)) {
       this._versionBarEntry.show();
     } else {
@@ -10248,24 +12186,24 @@ var TypeScriptServiceClient = class {
   constructor(pluginManager, modeIds) {
     this.pluginManager = pluginManager;
     this.modeIds = modeIds;
-    this.state = import_coc27.ServiceStat.Initial;
+    this.state = import_coc32.ServiceStat.Initial;
     this.logger = new logger_default();
     this.tsServerLogFile = null;
     this.cancellationPipeName = null;
     this._callbacks = new CallbackMap();
     this._requestQueue = new RequestQueue();
     this._pendingResponses = new Set();
-    this._onTsServerStarted = new import_vscode_languageserver_protocol20.Emitter();
-    this._onProjectLanguageServiceStateChanged = new import_vscode_languageserver_protocol20.Emitter();
-    this._onDidBeginInstallTypings = new import_vscode_languageserver_protocol20.Emitter();
-    this._onDidEndInstallTypings = new import_vscode_languageserver_protocol20.Emitter();
-    this._onTypesInstallerInitializationFailed = new import_vscode_languageserver_protocol20.Emitter();
+    this._onTsServerStarted = new import_vscode_languageserver_protocol21.Emitter();
+    this._onProjectLanguageServiceStateChanged = new import_vscode_languageserver_protocol21.Emitter();
+    this._onDidBeginInstallTypings = new import_vscode_languageserver_protocol21.Emitter();
+    this._onDidEndInstallTypings = new import_vscode_languageserver_protocol21.Emitter();
+    this._onTypesInstallerInitializationFailed = new import_vscode_languageserver_protocol21.Emitter();
     this.disposables = [];
     this.isRestarting = false;
-    this._onDiagnosticsReceived = new import_vscode_languageserver_protocol20.Emitter();
-    this._onConfigDiagnosticsReceived = new import_vscode_languageserver_protocol20.Emitter();
-    this._onResendModelsRequested = new import_vscode_languageserver_protocol20.Emitter();
-    this.pathSeparator = import_path7.default.sep;
+    this._onDiagnosticsReceived = new import_vscode_languageserver_protocol21.Emitter();
+    this._onConfigDiagnosticsReceived = new import_vscode_languageserver_protocol21.Emitter();
+    this._onResendModelsRequested = new import_vscode_languageserver_protocol21.Emitter();
+    this.pathSeparator = import_path8.default.sep;
     this.lastStart = Date.now();
     this.servicePromise = null;
     this.lastError = null;
@@ -10332,7 +12270,7 @@ var TypeScriptServiceClient = class {
     };
     if (this.servicePromise) {
       return Promise.resolve(this.servicePromise.then((childProcess) => {
-        this.state = import_coc27.ServiceStat.Stopping;
+        this.state = import_coc32.ServiceStat.Stopping;
         this.info("Killing TS Server");
         this.isRestarting = true;
         childProcess.kill();
@@ -10347,7 +12285,7 @@ var TypeScriptServiceClient = class {
       return;
     return new Promise((resolve, reject) => {
       this.servicePromise.then((childProcess) => {
-        if (this.state == import_coc27.ServiceStat.Running) {
+        if (this.state == import_coc32.ServiceStat.Running) {
           this.info("Killing TS Server");
           childProcess.onExit(() => {
             resolve();
@@ -10397,7 +12335,7 @@ var TypeScriptServiceClient = class {
   ensureServiceStarted() {
     if (!this.servicePromise) {
       this.startService().catch((err) => {
-        import_coc27.window.showMessage(`TSServer start failed: ${err.message}`, "error");
+        import_coc32.window.showMessage(`TSServer start failed: ${err.message}`, "error");
         this.error(`Service start failed: ${err.stack}`);
       });
     }
@@ -10412,9 +12350,9 @@ var TypeScriptServiceClient = class {
     }
     if (!currentVersion || !currentVersion.isValid) {
       if (this.configuration.globalTsdk) {
-        import_coc27.window.showMessage(`Can not find typescript module, in 'tsserver.tsdk': ${this.configuration.globalTsdk}`, "error");
+        import_coc32.window.showMessage(`Can not find typescript module, in 'tsserver.tsdk': ${this.configuration.globalTsdk}`, "error");
       } else {
-        import_coc27.window.showMessage(`Can not find typescript module, run ':CocInstall coc-tsserver' to fix it!`, "error");
+        import_coc32.window.showMessage(`Can not find typescript module, run ':CocInstall coc-tsserver' to fix it!`, "error");
       }
       return;
     }
@@ -10430,23 +12368,23 @@ var TypeScriptServiceClient = class {
         ...debugPort ? [`--inspect=${debugPort}`] : [],
         ...maxTsServerMemory ? [`--max-old-space-size=${maxTsServerMemory}`] : []
       ],
-      cwd: import_coc27.workspace.root
+      cwd: import_coc32.workspace.root
     };
     this.servicePromise = this.startProcess(currentVersion, tsServerForkArgs, options, resendModels);
     return this.servicePromise;
   }
   startProcess(currentVersion, args, options, resendModels) {
-    this.state = import_coc27.ServiceStat.Starting;
+    this.state = import_coc32.ServiceStat.Starting;
     return new Promise((resolve, reject) => {
       try {
         fork(currentVersion.tsServerPath, args, options, this.logger, (err, childProcess) => {
           if (err || !childProcess) {
-            this.state = import_coc27.ServiceStat.StartFailed;
+            this.state = import_coc32.ServiceStat.StartFailed;
             this.lastError = err;
             this.error("Starting TSServer failed with error.", err.stack);
             return;
           }
-          this.state = import_coc27.ServiceStat.Running;
+          this.state = import_coc32.ServiceStat.Running;
           this.info("Started TSServer", JSON.stringify(currentVersion, null, 2));
           const handle = new ForkedTsServerProcess(childProcess);
           this.tsServerProcess = handle;
@@ -10455,7 +12393,7 @@ var TypeScriptServiceClient = class {
             this.lastError = err2;
             this.error("TSServer errored with error.", err2);
             this.error(`TSServer log file: ${this.tsServerLogFile || ""}`);
-            import_coc27.window.showMessage(`TSServer errored with error. ${err2.message}`, "error");
+            import_coc32.window.showMessage(`TSServer errored with error. ${err2.message}`, "error");
             this.serviceExited(false);
           });
           handle.onExit((code) => {
@@ -10485,7 +12423,7 @@ var TypeScriptServiceClient = class {
   async openTsServerLogFile() {
     const isRoot = process.getuid && process.getuid() == 0;
     let echoErr = (msg) => {
-      import_coc27.window.showMessage(msg, "error");
+      import_coc32.window.showMessage(msg, "error");
     };
     if (isRoot) {
       echoErr("Log disabled for root user.");
@@ -10504,7 +12442,7 @@ var TypeScriptServiceClient = class {
       return false;
     }
     try {
-      await import_coc27.workspace.nvim.command(`edit ${this.tsServerLogFile}`);
+      await import_coc32.workspace.nvim.command(`edit ${this.tsServerLogFile}`);
       return true;
     } catch {
       echoErr("Could not open TS Server log file");
@@ -10551,7 +12489,7 @@ var TypeScriptServiceClient = class {
     };
   }
   serviceExited(restart) {
-    this.state = import_coc27.ServiceStat.Stopped;
+    this.state = import_coc32.ServiceStat.Stopped;
     this.servicePromise = null;
     this.tsServerLogFile = null;
     this._callbacks.destroy("Service died.");
@@ -10567,10 +12505,10 @@ var TypeScriptServiceClient = class {
         if (diff < 10 * 1e3) {
           this.lastStart = Date.now();
           startService = false;
-          import_coc27.window.showMessage("The TypeScript language service died 5 times right after it got started.", "error");
+          import_coc32.window.showMessage("The TypeScript language service died 5 times right after it got started.", "error");
         } else if (diff < 60 * 1e3) {
           this.lastStart = Date.now();
-          import_coc27.window.showMessage("The TypeScript language service died unexpectedly 5 times in the last 5 Minutes.", "error");
+          import_coc32.window.showMessage("The TypeScript language service died unexpectedly 5 times in the last 5 Minutes.", "error");
         }
       }
       if (startService) {
@@ -10579,7 +12517,7 @@ var TypeScriptServiceClient = class {
     }
   }
   toPath(uri) {
-    return this.normalizePath(import_coc27.Uri.parse(uri));
+    return this.normalizePath(import_coc32.Uri.parse(uri));
   }
   toOpenedFilePath(uri, options = {}) {
     if (!this.bufferSyncSupport.ensureHasBuffer(uri)) {
@@ -10593,18 +12531,18 @@ var TypeScriptServiceClient = class {
   toResource(filepath) {
     if (this._apiVersion.gte(api_default.v213)) {
       if (filepath.startsWith(this.inMemoryResourcePrefix + "untitled:")) {
-        let resource = import_coc27.Uri.parse(filepath);
+        let resource = import_coc32.Uri.parse(filepath);
         if (this.inMemoryResourcePrefix) {
-          const dirName = import_path7.default.dirname(resource.path);
-          const fileName = import_path7.default.basename(resource.path);
+          const dirName = import_path8.default.dirname(resource.path);
+          const fileName = import_path8.default.basename(resource.path);
           if (fileName.startsWith(this.inMemoryResourcePrefix)) {
-            resource = resource.with({path: import_path7.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))});
+            resource = resource.with({path: import_path8.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))});
           }
         }
         return resource.toString();
       }
     }
-    return import_coc27.Uri.file(filepath).toString();
+    return import_coc32.Uri.file(filepath).toString();
   }
   normalizePath(resource) {
     if (disabledSchemes.has(resource.scheme)) {
@@ -10615,7 +12553,7 @@ var TypeScriptServiceClient = class {
         let result = resource.fsPath;
         if (!result)
           return void 0;
-        result = import_path7.default.normalize(result);
+        result = import_path8.default.normalize(result);
         return result.replace(new RegExp("\\" + this.pathSeparator, "g"), "/");
       }
       default: {
@@ -10626,9 +12564,9 @@ var TypeScriptServiceClient = class {
   getDocument(resource) {
     if (resource.startsWith("untitled:")) {
       let bufnr = parseInt(resource.split(":", 2)[1], 10);
-      return import_coc27.workspace.getDocument(bufnr);
+      return import_coc32.workspace.getDocument(bufnr);
     }
-    return import_coc27.workspace.getDocument(resource);
+    return import_coc32.workspace.getDocument(resource);
   }
   get inMemoryResourcePrefix() {
     return this._apiVersion.gte(api_default.v270) ? "^" : "";
@@ -10636,26 +12574,26 @@ var TypeScriptServiceClient = class {
   asUrl(filepath) {
     if (this._apiVersion.gte(api_default.v213)) {
       if (filepath.startsWith(this.inMemoryResourcePrefix + "untitled:")) {
-        let resource = import_coc27.Uri.parse(filepath.slice(this.inMemoryResourcePrefix.length));
+        let resource = import_coc32.Uri.parse(filepath.slice(this.inMemoryResourcePrefix.length));
         if (this.inMemoryResourcePrefix) {
-          const dirName = import_path7.default.dirname(resource.path);
-          const fileName = import_path7.default.basename(resource.path);
+          const dirName = import_path8.default.dirname(resource.path);
+          const fileName = import_path8.default.basename(resource.path);
           if (fileName.startsWith(this.inMemoryResourcePrefix)) {
             resource = resource.with({
-              path: import_path7.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))
+              path: import_path8.default.posix.join(dirName, fileName.slice(this.inMemoryResourcePrefix.length))
             });
           }
         }
         return resource;
       }
     }
-    return import_coc27.Uri.file(filepath);
+    return import_coc32.Uri.file(filepath);
   }
   execute(command, args, token, config) {
     var _a;
     let execution;
     if (config == null ? void 0 : config.cancelOnResourceChange) {
-      const source = new import_vscode_languageserver_protocol20.CancellationTokenSource();
+      const source = new import_vscode_languageserver_protocol21.CancellationTokenSource();
       token.onCancellationRequested(() => source.cancel());
       const inFlight = {
         resource: config.cancelOnResourceChange,
@@ -10687,7 +12625,7 @@ var TypeScriptServiceClient = class {
   }
   fatalError(command, error) {
     console.error(`A non-recoverable error occured while executing tsserver command: ${command}`);
-    if (this.state === import_coc27.ServiceStat.Running) {
+    if (this.state === import_coc32.ServiceStat.Running) {
       this.info("Killing TS Server by fatal error:", error);
       this.service().then((service) => {
         service.kill();
@@ -10868,7 +12806,7 @@ var TypeScriptServiceClient = class {
         break;
       case "projectsUpdatedInBackground":
         const body = event.body;
-        const resources = body.openFiles.map(import_coc27.Uri.file);
+        const resources = body.openFiles.map(import_coc32.Uri.file);
         this.bufferSyncSupport.getErr(resources);
         break;
       case "typesInstallerInitializationFailed":
@@ -10904,7 +12842,7 @@ var TypeScriptServiceClient = class {
       if (this._configuration.tsServerLogLevel !== TsServerLogLevel.Off && !isRoot) {
         const logDir = getTempDirectory();
         if (logDir) {
-          this.tsServerLogFile = import_path7.default.join(logDir, `tsserver.log`);
+          this.tsServerLogFile = import_path8.default.join(logDir, `tsserver.log`);
           this.info("TSServer log file :", this.tsServerLogFile);
         } else {
           this.tsServerLogFile = null;
@@ -10920,11 +12858,11 @@ var TypeScriptServiceClient = class {
       const pluginNames = this.pluginManager.plugins.map((x) => x.name);
       let pluginPaths = this._configuration.tsServerPluginPaths;
       pluginPaths = pluginPaths.reduce((p, c) => {
-        if (import_path7.default.isAbsolute(c)) {
+        if (import_path8.default.isAbsolute(c)) {
           p.push(c);
         } else {
-          let roots = import_coc27.workspace.workspaceFolders.map((o) => import_coc27.Uri.parse(o.uri).fsPath);
-          p.push(...roots.map((r) => import_path7.default.join(r, c)));
+          let roots = import_coc32.workspace.workspaceFolders.map((o) => import_coc32.Uri.parse(o.uri).fsPath);
+          p.push(...roots.map((r) => import_path8.default.join(r, c)));
         }
         return p;
       }, []);
@@ -10963,17 +12901,17 @@ var TypeScriptServiceClient = class {
     return args;
   }
   getProjectRootPath(uri) {
-    let root = import_coc27.workspace.cwd;
-    let u = import_coc27.Uri.parse(uri);
+    let root = import_coc32.workspace.cwd;
+    let u = import_coc32.Uri.parse(uri);
     if (u.scheme !== "file")
       return void 0;
-    let folder = import_coc27.workspace.getWorkspaceFolder(uri);
+    let folder = import_coc32.workspace.getWorkspaceFolder(uri);
     if (folder) {
-      root = import_coc27.Uri.parse(folder.uri).fsPath;
+      root = import_coc32.Uri.parse(folder.uri).fsPath;
     } else {
-      let filepath = import_coc27.Uri.parse(uri).fsPath;
+      let filepath = import_coc32.Uri.parse(uri).fsPath;
       if (!filepath.startsWith(root)) {
-        root = import_path7.default.dirname(filepath);
+        root = import_path8.default.dirname(filepath);
       }
     }
     if (root == import_os2.default.homedir())
@@ -10993,7 +12931,7 @@ var TypeScriptServiceClient = class {
     return this.bufferSyncSupport.interuptGetErr(f);
   }
   cancelInflightRequestsForResource(resource) {
-    if (this.state !== import_coc27.ServiceStat.Running || !this.tsServerProcess) {
+    if (this.state !== import_coc32.ServiceStat.Running || !this.tsServerProcess) {
       return;
     }
     for (const request of this.tsServerProcess.toCancelOnResourceChange) {
@@ -11056,8 +12994,8 @@ var standardLanguageDescriptions = [
 ];
 
 // src/server/utils/typingsStatus.ts
-var import_coc28 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol21 = __toModule(require_main3());
+var import_coc33 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol22 = __toModule(require_main3());
 var typingsInstallTimeout = 30 * 1e3;
 var TypingsStatus = class {
   constructor(client) {
@@ -11097,12 +13035,12 @@ var AtaProgressReporter = class {
   constructor(client) {
     this._promises = new Map();
     this._invalid = false;
-    this.statusItem = import_coc28.window.createStatusBarItem(10, {progress: true});
+    this.statusItem = import_coc33.window.createStatusBarItem(10, {progress: true});
     const disposables = [];
     disposables.push(client.onDidBeginInstallTypings((e) => this._onBegin(e.eventId)));
     disposables.push(client.onDidEndInstallTypings((e) => this._onEndOrTimeout(e.eventId)));
     disposables.push(client.onTypesInstallerInitializationFailed((_) => this.onTypesInstallerInitializationFailed()));
-    this._disposable = import_vscode_languageserver_protocol21.Disposable.create(() => {
+    this._disposable = import_vscode_languageserver_protocol22.Disposable.create(() => {
       disposables.forEach((disposable) => {
         disposable.dispose();
       });
@@ -11134,7 +13072,7 @@ var AtaProgressReporter = class {
   onTypesInstallerInitializationFailed() {
     this.statusItem.hide();
     if (!this._invalid) {
-      import_coc28.window.showMessage("Could not install typings files for JavaScript language features. Please ensure that NPM is installed", "error");
+      import_coc33.window.showMessage("Could not install typings files for JavaScript language features. Please ensure that NPM is installed", "error");
     }
     this._invalid = true;
   }
@@ -11162,12 +13100,12 @@ var TypeScriptServiceClientHost = class {
         this.triggerAllDiagnostics();
       }, 1500);
     };
-    const configFileWatcher = import_coc29.workspace.createFileSystemWatcher("**/[tj]sconfig.json");
+    const configFileWatcher = import_coc34.workspace.createFileSystemWatcher("**/[tj]sconfig.json");
     this.disposables.push(configFileWatcher);
     configFileWatcher.onDidCreate(this.reloadProjects, this, this.disposables);
     configFileWatcher.onDidDelete(this.reloadProjects, this, this.disposables);
     configFileWatcher.onDidChange(handleProjectChange, this, this.disposables);
-    const packageFileWatcher = import_coc29.workspace.createFileSystemWatcher("**/package.json");
+    const packageFileWatcher = import_coc34.workspace.createFileSystemWatcher("**/package.json");
     packageFileWatcher.onDidCreate(this.reloadProjects, this, this.disposables);
     packageFileWatcher.onDidChange(handleProjectChange, this, this.disposables);
     const allModeIds = this.getAllModeIds(descriptions, pluginManager);
@@ -11179,12 +13117,12 @@ var TypeScriptServiceClientHost = class {
       });
     }, null, this.disposables);
     this.disposables.push(new watchBuild_default(this.client));
-    this.disposables.push(import_coc29.languages.registerWorkspaceSymbolProvider(new workspaceSymbols_default(this.client, allModeIds)));
+    this.disposables.push(import_coc34.languages.registerWorkspaceSymbolProvider(new workspaceSymbols_default(this.client, allModeIds)));
     this.client.onConfigDiagnosticsReceived((diag) => {
       let {body} = diag;
       if (body) {
         let {configFile, diagnostics} = body;
-        let uri = import_coc29.Uri.file(configFile);
+        let uri = import_coc34.Uri.file(configFile);
         if (diagnostics.length == 0) {
           this.client.diagnosticsManager.configFileDiagnosticsReceived(uri.toString(), []);
         } else {
@@ -11192,12 +13130,12 @@ var TypeScriptServiceClientHost = class {
             let {text, code, category, start, end} = o;
             let range;
             if (!start || !end) {
-              range = import_vscode_languageserver_protocol22.Range.create(import_vscode_languageserver_protocol22.Position.create(0, 0), import_vscode_languageserver_protocol22.Position.create(0, 1));
+              range = import_vscode_languageserver_protocol23.Range.create(import_vscode_languageserver_protocol23.Position.create(0, 0), import_vscode_languageserver_protocol23.Position.create(0, 1));
             } else {
-              range = import_vscode_languageserver_protocol22.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1);
+              range = import_vscode_languageserver_protocol23.Range.create(start.line - 1, start.offset - 1, end.line - 1, end.offset - 1);
             }
-            let severity = category == "error" ? import_vscode_languageserver_protocol22.DiagnosticSeverity.Error : import_vscode_languageserver_protocol22.DiagnosticSeverity.Warning;
-            return import_vscode_languageserver_protocol22.Diagnostic.create(range, text, severity, code);
+            let severity = category == "error" ? import_vscode_languageserver_protocol23.DiagnosticSeverity.Error : import_vscode_languageserver_protocol23.DiagnosticSeverity.Warning;
+            return import_vscode_languageserver_protocol23.Diagnostic.create(range, text, severity, code);
           });
           this.client.diagnosticsManager.configFileDiagnosticsReceived(uri.toString(), diagnosticList);
         }
@@ -11222,8 +13160,8 @@ var TypeScriptServiceClientHost = class {
           isExternal: true
         });
       } else {
-        for (const language of plugin.languages) {
-          languageIds.add(language);
+        for (const language2 of plugin.languages) {
+          languageIds.add(language2);
         }
       }
     }
@@ -11241,7 +13179,7 @@ var TypeScriptServiceClientHost = class {
     this.client.onTsServerStarted(() => {
       this.triggerAllDiagnostics();
     });
-    import_coc29.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
+    import_coc34.workspace.onDidChangeConfiguration(this.configurationChanged, this, this.disposables);
     this.configurationChanged();
   }
   registerExtensionLanguageProvider(description) {
@@ -11249,9 +13187,9 @@ var TypeScriptServiceClientHost = class {
     this.languagePerId.set(description.id, manager);
   }
   dispose() {
-    import_coc29.disposeAll(this.disposables);
-    for (let language of this.languagePerId.values()) {
-      language.dispose();
+    import_coc34.disposeAll(this.disposables);
+    for (let language2 of this.languagePerId.values()) {
+      language2.dispose();
     }
     this.languagePerId.clear();
     this.fileConfigurationManager.dispose();
@@ -11266,14 +13204,14 @@ var TypeScriptServiceClientHost = class {
   }
   reloadProjects() {
     this.client.diagnosticsManager.reInitialize();
-    this.client.execute("reloadProjects", null, import_vscode_languageserver_protocol22.CancellationToken.None);
+    this.client.execute("reloadProjects", null, import_vscode_languageserver_protocol23.CancellationToken.None);
     this.triggerAllDiagnostics();
   }
   getProvider(languageId) {
     return this.languagePerId.get(languageId);
   }
   configurationChanged() {
-    const config = import_coc29.workspace.getConfiguration("tsserver");
+    const config = import_coc34.workspace.getConfiguration("tsserver");
     this.reportStyleCheckAsWarnings = config.get("reportStyleChecksAsWarnings", true);
   }
   async findLanguage(uri) {
@@ -11282,27 +13220,27 @@ var TypeScriptServiceClientHost = class {
       if (!doc)
         return void 0;
       let languages4 = Array.from(this.languagePerId.values());
-      return languages4.find((language) => language.handles(uri, doc.textDocument));
+      return languages4.find((language2) => language2.handles(uri, doc.textDocument));
     } catch {
       return void 0;
     }
   }
   async handles(doc) {
     let languages4 = Array.from(this.languagePerId.values());
-    let idx = languages4.findIndex((language) => language.handles(doc.uri, doc));
+    let idx = languages4.findIndex((language2) => language2.handles(doc.uri, doc));
     if (idx != -1)
       return true;
     return this.client.bufferSyncSupport.handles(doc.uri);
   }
   triggerAllDiagnostics() {
-    for (const language of this.languagePerId.values()) {
-      language.triggerAllDiagnostics();
+    for (const language2 of this.languagePerId.values()) {
+      language2.triggerAllDiagnostics();
     }
   }
   async diagnosticsReceived(kind, resource, diagnostics) {
-    const language = await this.findLanguage(resource.toString());
-    if (language) {
-      language.diagnosticsReceived(kind, resource, this.createMarkerDatas(diagnostics));
+    const language2 = await this.findLanguage(resource.toString());
+    if (language2) {
+      language2.diagnosticsReceived(kind, resource, this.createMarkerDatas(diagnostics));
     }
   }
   createMarkerDatas(diagnostics) {
@@ -11324,11 +13262,21 @@ var TypeScriptServiceClientHost = class {
         };
       });
     }
+    let tags = [];
+    if (diagnostic.reportsUnnecessary) {
+      tags.push(import_vscode_languageserver_protocol23.DiagnosticTag.Unnecessary);
+    }
+    if (diagnostic.reportsDeprecated) {
+      tags.push(import_vscode_languageserver_protocol23.DiagnosticTag.Deprecated);
+    }
+    tags = tags.length ? tags : void 0;
     return {
       range,
+      tags,
       message: text,
       code: diagnostic.code ? diagnostic.code : null,
       severity: this.getDiagnosticSeverity(diagnostic),
+      reportDeprecated: diagnostic.reportsDeprecated,
       reportUnnecessary: diagnostic.reportsUnnecessary,
       source: diagnostic.source || "tsserver",
       relatedInformation
@@ -11336,17 +13284,17 @@ var TypeScriptServiceClientHost = class {
   }
   getDiagnosticSeverity(diagnostic) {
     if (this.reportStyleCheckAsWarnings && this.isStyleCheckDiagnostic(diagnostic.code) && diagnostic.category === DiagnosticCategory.error) {
-      return import_vscode_languageserver_protocol22.DiagnosticSeverity.Warning;
+      return import_vscode_languageserver_protocol23.DiagnosticSeverity.Warning;
     }
     switch (diagnostic.category) {
       case DiagnosticCategory.error:
-        return import_vscode_languageserver_protocol22.DiagnosticSeverity.Error;
+        return import_vscode_languageserver_protocol23.DiagnosticSeverity.Error;
       case DiagnosticCategory.warning:
-        return import_vscode_languageserver_protocol22.DiagnosticSeverity.Warning;
+        return import_vscode_languageserver_protocol23.DiagnosticSeverity.Warning;
       case DiagnosticCategory.suggestion:
-        return import_vscode_languageserver_protocol22.DiagnosticSeverity.Information;
+        return import_vscode_languageserver_protocol23.DiagnosticSeverity.Information;
       default:
-        return import_vscode_languageserver_protocol22.DiagnosticSeverity.Error;
+        return import_vscode_languageserver_protocol23.DiagnosticSeverity.Error;
     }
   }
   isStyleCheckDiagnostic(code) {
@@ -11368,12 +13316,12 @@ var TsserverService = class {
     this.pluginManager = pluginManager;
     this.id = "tsserver";
     this.name = "tsserver";
-    this.state = import_coc30.ServiceStat.Initial;
-    this._onDidServiceReady = new import_vscode_languageserver_protocol23.Emitter();
+    this.state = import_coc35.ServiceStat.Initial;
+    this._onDidServiceReady = new import_vscode_languageserver_protocol24.Emitter();
     this.onServiceReady = this._onDidServiceReady.event;
     this.disposables = [];
     this.descriptions = [];
-    const config = import_coc30.workspace.getConfiguration("tsserver");
+    const config = import_coc35.workspace.getConfiguration("tsserver");
     const enableJavascript = !!config.get("enableJavascript");
     this.enable = config.get("enable");
     this.descriptions = standardLanguageDescriptions.filter((o) => {
@@ -11384,10 +13332,10 @@ var TsserverService = class {
     }, []);
   }
   get config() {
-    return import_coc30.workspace.getConfiguration("tsserver");
+    return import_coc35.workspace.getConfiguration("tsserver");
   }
   getClientHost() {
-    if (this.state == import_coc30.ServiceStat.Running)
+    if (this.state == import_coc35.ServiceStat.Running)
       return Promise.resolve(this.clientHost);
     this.start();
     return new Promise((resolve, reject) => {
@@ -11404,7 +13352,7 @@ var TsserverService = class {
   start() {
     if (this.clientHost)
       return;
-    this.state = import_coc30.ServiceStat.Starting;
+    this.state = import_coc35.ServiceStat.Starting;
     this.clientHost = new typescriptServiceClientHost_default(this.descriptions, this.pluginManager);
     this.disposables.push(this.clientHost);
     let client = this.clientHost.serviceClient;
@@ -11425,7 +13373,7 @@ var TsserverService = class {
     });
   }
   dispose() {
-    import_coc30.disposeAll(this.disposables);
+    import_coc35.disposeAll(this.disposables);
   }
   async restart() {
     if (!this.clientHost)
@@ -11445,8 +13393,8 @@ var TsserverService = class {
 var server_default = TsserverService;
 
 // src/utils/plugins.ts
-var import_coc31 = __toModule(require("coc.nvim"));
-var import_vscode_languageserver_protocol24 = __toModule(require_main3());
+var import_coc36 = __toModule(require("coc.nvim"));
+var import_vscode_languageserver_protocol25 = __toModule(require_main3());
 var TypeScriptServerPlugin;
 (function(TypeScriptServerPlugin2) {
   function equals2(a, b) {
@@ -11458,9 +13406,9 @@ var PluginManager = class {
   constructor() {
     this._pluginConfigurations = new Map();
     this._disposables = [];
-    this._onDidUpdatePlugins = this._register(new import_vscode_languageserver_protocol24.Emitter());
+    this._onDidUpdatePlugins = this._register(new import_vscode_languageserver_protocol25.Emitter());
     this.onDidChangePlugins = this._onDidUpdatePlugins.event;
-    this._onDidUpdateConfig = this._register(new import_vscode_languageserver_protocol24.Emitter());
+    this._onDidUpdateConfig = this._register(new import_vscode_languageserver_protocol25.Emitter());
     this.onDidUpdateConfig = this._onDidUpdateConfig.event;
     let loadPlugins = () => {
       if (!this._plugins) {
@@ -11472,11 +13420,11 @@ var PluginManager = class {
         this._onDidUpdatePlugins.fire(this);
       }
     };
-    import_coc31.extensions.onDidActiveExtension(loadPlugins, void 0, this._disposables);
-    import_coc31.extensions.onDidUnloadExtension(loadPlugins, void 0, this._disposables);
+    import_coc36.extensions.onDidActiveExtension(loadPlugins, void 0, this._disposables);
+    import_coc36.extensions.onDidUnloadExtension(loadPlugins, void 0, this._disposables);
   }
   dispose() {
-    import_coc31.disposeAll(this._disposables);
+    import_coc36.disposeAll(this._disposables);
   }
   get plugins() {
     if (!this._plugins) {
@@ -11497,7 +13445,7 @@ var PluginManager = class {
   }
   readPlugins() {
     const pluginMap = new Map();
-    for (const extension of import_coc31.extensions.all) {
+    for (const extension of import_coc36.extensions.all) {
       const pack = extension.packageJSON;
       if (pack.contributes && Array.isArray(pack.contributes.typescriptServerPlugins)) {
         const plugins = [];
@@ -11521,18 +13469,19 @@ var PluginManager = class {
 // src/index.ts
 async function activate(context) {
   let {subscriptions, logger} = context;
-  const config = import_coc32.workspace.getConfiguration().get("tsserver", {});
+  const config = import_coc37.workspace.getConfiguration().get("tsserver", {});
   if (!config.enable)
     return;
   const pluginManager = new PluginManager();
   const service = new server_default(pluginManager);
   function registCommand2(cmd) {
     let {id, execute} = cmd;
-    subscriptions.push(import_coc32.commands.registerCommand(id, execute, cmd));
+    subscriptions.push(import_coc37.commands.registerCommand(id, execute, cmd));
   }
   registCommand2(new ConfigurePluginCommand(pluginManager));
   registCommand2(new AutoFixCommand(service));
   registCommand2(new ReloadProjectsCommand(service));
+  registCommand2(new FileReferencesCommand(service));
   registCommand2(new OpenTsServerLogCommand(service));
   registCommand2(new TypeScriptGoToProjectConfigCommand(service));
   registCommand2(new OrganizeImportsCommand(service));
@@ -11547,7 +13496,7 @@ async function activate(context) {
     }
   });
   service.start().then(() => {
-    subscriptions.push(import_coc32.services.regist(service));
+    subscriptions.push(import_coc37.services.regist(service));
   }, (e) => {
     logger.error(`Error on service start:`, e);
   });