https://cowcalfeconomictool.github.io/shinylive/Editor.js

28// node_modules/events/events.js
29var require_events = __commonJS({
30  "node_modules/events/events.js"(exports, module) {
31    "use strict";
32    var R = typeof Reflect === "object" ? Reflect : null;
33    var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
34      return Function.prototype.apply.call(target, receiver, args);
35    };
36    var ReflectOwnKeys;
37    if (R && typeof R.ownKeys === "function") {
38      ReflectOwnKeys = R.ownKeys;
39    } else if (Object.getOwnPropertySymbols) {
40      ReflectOwnKeys = function ReflectOwnKeys2(target) {
41        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
42      };
43    } else {
44      ReflectOwnKeys = function ReflectOwnKeys2(target) {
45        return Object.getOwnPropertyNames(target);
46      };
47    }
48    function ProcessEmitWarning(warning) {
49      if (console && console.warn)
50        console.warn(warning);
51    }
52    var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
53      return value !== value;
54    };
55    function EventEmitter2() {
56      EventEmitter2.init.call(this);
57    }
58    module.exports = EventEmitter2;
59    module.exports.once = once;
60    EventEmitter2.EventEmitter = EventEmitter2;
61    EventEmitter2.prototype._events = void 0;
62    EventEmitter2.prototype._eventsCount = 0;
63    EventEmitter2.prototype._maxListeners = void 0;
64    var defaultMaxListeners = 10;
65    function checkListener(listener) {
66      if (typeof listener !== "function") {
67        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
68      }
69    }
70    Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
71      enumerable: true,
72      get: function() {
73        return defaultMaxListeners;
74      },
75      set: function(arg) {
76        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
77          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
78        }
79        defaultMaxListeners = arg;
80      }
81    });
82    EventEmitter2.init = function() {
83      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
84        this._events = /* @__PURE__ */ Object.create(null);
85        this._eventsCount = 0;
86      }
87      this._maxListeners = this._maxListeners || void 0;
88    };
89    EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n3) {
90      if (typeof n3 !== "number" || n3 < 0 || NumberIsNaN(n3)) {
91        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n3 + ".");
92      }
93      this._maxListeners = n3;
94      return this;
95    };
96    function _getMaxListeners(that) {
97      if (that._maxListeners === void 0)
98        return EventEmitter2.defaultMaxListeners;
99      return that._maxListeners;
100    }
101    EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
102      return _getMaxListeners(this);
103    };
104    EventEmitter2.prototype.emit = function emit(type) {
105      var args = [];
106      for (var i2 = 1; i2 < arguments.length; i2++)
107        args.push(arguments[i2]);
108      var doError = type === "error";
109      var events = this._events;
110      if (events !== void 0)
111        doError = doError && events.error === void 0;
112      else if (!doError)
113        return false;
114      if (doError) {
115        var er;
116        if (args.length > 0)
117          er = args[0];
118        if (er instanceof Error) {
119          throw er;
120        }
121        var err2 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
122        err2.context = er;
123        throw err2;
124      }
125      var handler = events[type];
126      if (handler === void 0)
127        return false;
128      if (typeof handler === "function") {
129        ReflectApply(handler, this, args);
130      } else {
131        var len = handler.length;
132        var listeners = arrayClone(handler, len);
133        for (var i2 = 0; i2 < len; ++i2)
134          ReflectApply(listeners[i2], this, args);
135      }
136      return true;
137    };
138    function _addListener(target, type, listener, prepend) {
139      var m2;
140      var events;
141      var existing;
142      checkListener(listener);
143      events = target._events;
144      if (events === void 0) {
145        events = target._events = /* @__PURE__ */ Object.create(null);
146        target._eventsCount = 0;
147      } else {
148        if (events.newListener !== void 0) {
149          target.emit(
150            "newListener",
151            type,
152            listener.listener ? listener.listener : listener
153          );
154          events = target._events;
155        }
156        existing = events[type];
157      }
158      if (existing === void 0) {
159        existing = events[type] = listener;
160        ++target._eventsCount;
161      } else {
162        if (typeof existing === "function") {
163          existing = events[type] = prepend ? [listener, existing] : [existing, listener];
164        } else if (prepend) {
165          existing.unshift(listener);
166        } else {
167          existing.push(listener);
168        }
169        m2 = _getMaxListeners(target);
170        if (m2 > 0 && existing.length > m2 && !existing.warned) {
171          existing.warned = true;
172          var w2 = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
173          w2.name = "MaxListenersExceededWarning";
174          w2.emitter = target;
175          w2.type = type;
176          w2.count = existing.length;
177          ProcessEmitWarning(w2);
178        }
179      }
180      return target;
181    }
182    EventEmitter2.prototype.addListener = function addListener(type, listener) {
183      return _addListener(this, type, listener, false);
184    };
185    EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
186    EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
187      return _addListener(this, type, listener, true);
188    };
189    function onceWrapper() {
190      if (!this.fired) {
191        this.target.removeListener(this.type, this.wrapFn);
192        this.fired = true;
193        if (arguments.length === 0)
194          return this.listener.call(this.target);
195        return this.listener.apply(this.target, arguments);
196      }
197    }
198    function _onceWrap(target, type, listener) {
199      var state = { fired: false, wrapFn: void 0, target, type, listener };
200      var wrapped = onceWrapper.bind(state);
201      wrapped.listener = listener;
202      state.wrapFn = wrapped;
203      return wrapped;
204    }
205    EventEmitter2.prototype.once = function once2(type, listener) {
206      checkListener(listener);
207      this.on(type, _onceWrap(this, type, listener));
208      return this;
209    };
210    EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
211      checkListener(listener);
212      this.prependListener(type, _onceWrap(this, type, listener));
213      return this;
214    };
215    EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
216      var list, events, position, i2, originalListener;
217      checkListener(listener);
218      events = this._events;
219      if (events === void 0)
220        return this;
221      list = events[type];
222      if (list === void 0)
223        return this;
224      if (list === listener || list.listener === listener) {
225        if (--this._eventsCount === 0)
226          this._events = /* @__PURE__ */ Object.create(null);
227        else {
228          delete events[type];
229          if (events.removeListener)
230            this.emit("removeListener", type, list.listener || listener);
231        }
232      } else if (typeof list !== "function") {
233        position = -1;
234        for (i2 = list.length - 1; i2 >= 0; i2--) {
235          if (list[i2] === listener || list[i2].listener === listener) {
236            originalListener = list[i2].listener;
237            position = i2;
238            break;
239          }
240        }
241        if (position < 0)
242          return this;
243        if (position === 0)
244          list.shift();
245        else {
246          spliceOne(list, position);
247        }
248        if (list.length === 1)
249          events[type] = list[0];
250        if (events.removeListener !== void 0)
251          this.emit("removeListener", type, originalListener || listener);
252      }
253      return this;
254    };
255    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
256    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
257      var listeners, events, i2;
258      events = this._events;
259      if (events === void 0)
260        return this;
261      if (events.removeListener === void 0) {
262        if (arguments.length === 0) {
263          this._events = /* @__PURE__ */ Object.create(null);
264          this._eventsCount = 0;
265        } else if (events[type] !== void 0) {
266          if (--this._eventsCount === 0)
267            this._events = /* @__PURE__ */ Object.create(null);
268          else
269            delete events[type];
270        }
271        return this;
272      }
273      if (arguments.length === 0) {
274        var keys = Object.keys(events);
275        var key;
276        for (i2 = 0; i2 < keys.length; ++i2) {
277          key = keys[i2];
278          if (key === "removeListener")
279            continue;
280          this.removeAllListeners(key);
281        }
282        this.removeAllListeners("removeListener");
283        this._events = /* @__PURE__ */ Object.create(null);
284        this._eventsCount = 0;
285        return this;
286      }
287      listeners = events[type];
288      if (typeof listeners === "function") {
289        this.removeListener(type, listeners);
290      } else if (listeners !== void 0) {
291        for (i2 = listeners.length - 1; i2 >= 0; i2--) {
292          this.removeListener(type, listeners[i2]);
293        }
294      }
295      return this;
296    };
297    function _listeners(target, type, unwrap) {
298      var events = target._events;
299      if (events === void 0)
300        return [];
301      var evlistener = events[type];
302      if (evlistener === void 0)
303        return [];
304      if (typeof evlistener === "function")
305        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
306      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
307    }
308    EventEmitter2.prototype.listeners = function listeners(type) {
309      return _listeners(this, type, true);
310    };
311    EventEmitter2.prototype.rawListeners = function rawListeners(type) {
312      return _listeners(this, type, false);
313    };
314    EventEmitter2.listenerCount = function(emitter, type) {
315      if (typeof emitter.listenerCount === "function") {
316        return emitter.listenerCount(type);
317      } else {
318        return listenerCount.call(emitter, type);
319      }
320    };
321    EventEmitter2.prototype.listenerCount = listenerCount;
322    function listenerCount(type) {
323      var events = this._events;
324      if (events !== void 0) {
325        var evlistener = events[type];
326        if (typeof evlistener === "function") {
327          return 1;
328        } else if (evlistener !== void 0) {
329          return evlistener.length;
330        }
331      }
332      return 0;
333    }
334    EventEmitter2.prototype.eventNames = function eventNames() {
335      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
336    };
337    function arrayClone(arr, n3) {
338      var copy = new Array(n3);
339      for (var i2 = 0; i2 < n3; ++i2)
340        copy[i2] = arr[i2];
341      return copy;
342    }
343    function spliceOne(list, index) {
344      for (; index + 1 < list.length; index++)
345        list[index] = list[index + 1];
346      list.pop();
347    }
348    function unwrapListeners(arr) {
349      var ret = new Array(arr.length);
350      for (var i2 = 0; i2 < ret.length; ++i2) {
351        ret[i2] = arr[i2].listener || arr[i2];
352      }
353      return ret;
354    }
355    function once(emitter, name2) {
356      return new Promise(function(resolve, reject) {
357        function errorListener(err2) {
358          emitter.removeListener(name2, resolver);
359          reject(err2);
360        }
361        function resolver() {
362          if (typeof emitter.removeListener === "function") {
363            emitter.removeListener("error", errorListener);
364          }
365          resolve([].slice.call(arguments));
366        }
367        ;
368        eventTargetAgnosticAddListener(emitter, name2, resolver, { once: true });
369        if (name2 !== "error") {
370          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
371        }
372      });
373    }
374    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
375      if (typeof emitter.on === "function") {
376        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
377      }
378    }
379    function eventTargetAgnosticAddListener(emitter, name2, listener, flags) {
380      if (typeof emitter.on === "function") {
381        if (flags.once) {
382          emitter.once(name2, listener);
383        } else {
384          emitter.on(name2, listener);
385        }
386      } else if (typeof emitter.addEventListener === "function") {
387        emitter.addEventListener(name2, function wrapListener(arg) {
388          if (flags.once) {
389            emitter.removeEventListener(name2, wrapListener);
390          }
391          listener(arg);
392        });
393      } else {
394        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
395      }
396    }
397  }
398});
399

400// node_modules/vscode-jsonrpc/lib/common/is.js
401var require_is = __commonJS({
402  "node_modules/vscode-jsonrpc/lib/common/is.js"(exports) {
403    "use strict";
404    Object.defineProperty(exports, "__esModule", { value: true });
405    exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
406    function boolean(value) {
407      return value === true || value === false;
408    }
409    exports.boolean = boolean;
410    function string2(value) {
411      return typeof value === "string" || value instanceof String;
412    }
413    exports.string = string2;
414    function number2(value) {
415      return typeof value === "number" || value instanceof Number;
416    }
417    exports.number = number2;
418    function error(value) {
419      return value instanceof Error;
420    }
421    exports.error = error;
422    function func(value) {
423      return typeof value === "function";
424    }
425    exports.func = func;
426    function array(value) {
427      return Array.isArray(value);
428    }
429    exports.array = array;
430    function stringArray(value) {
431      return array(value) && value.every((elem) => string2(elem));
432    }
433    exports.stringArray = stringArray;
434  }
435});
436

437// node_modules/vscode-jsonrpc/lib/common/messages.js
438var require_messages = __commonJS({
439  "node_modules/vscode-jsonrpc/lib/common/messages.js"(exports) {
440    "use strict";
441    Object.defineProperty(exports, "__esModule", { value: true });
442    exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
443    var is = require_is();
444    var ErrorCodes;
445    (function(ErrorCodes2) {
446      ErrorCodes2.ParseError = -32700;
447      ErrorCodes2.InvalidRequest = -32600;
448      ErrorCodes2.MethodNotFound = -32601;
449      ErrorCodes2.InvalidParams = -32602;
450      ErrorCodes2.InternalError = -32603;
451      ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
452      ErrorCodes2.serverErrorStart = -32099;
453      ErrorCodes2.MessageWriteError = -32099;
454      ErrorCodes2.MessageReadError = -32098;
455      ErrorCodes2.PendingResponseRejected = -32097;
456      ErrorCodes2.ConnectionInactive = -32096;
457      ErrorCodes2.ServerNotInitialized = -32002;
458      ErrorCodes2.UnknownErrorCode = -32001;
459      ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
460      ErrorCodes2.serverErrorEnd = -32e3;
461    })(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
462    var ResponseError = class _ResponseError extends Error {
463      constructor(code, message, data) {
464        super(message);
465        this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
466        this.data = data;
467        Object.setPrototypeOf(this, _ResponseError.prototype);
468      }
469      toJson() {
470        const result = {
471          code: this.code,
472          message: this.message
473        };
474        if (this.data !== void 0) {
475          result.data = this.data;
476        }
477        return result;
478      }
479    };
480    exports.ResponseError = ResponseError;
481    var ParameterStructures = class _ParameterStructures {
482      constructor(kind) {
483        this.kind = kind;
484      }
485      static is(value) {
486        return value === _ParameterStructures.auto || value === _ParameterStructures.byName || value === _ParameterStructures.byPosition;
487      }
488      toString() {
489        return this.kind;
490      }
491    };
492    exports.ParameterStructures = ParameterStructures;
493    ParameterStructures.auto = new ParameterStructures("auto");
494    ParameterStructures.byPosition = new ParameterStructures("byPosition");
495    ParameterStructures.byName = new ParameterStructures("byName");
496    var AbstractMessageSignature = class {
497      constructor(method, numberOfParams) {
498        this.method = method;
499        this.numberOfParams = numberOfParams;
500      }
501      get parameterStructures() {
502        return ParameterStructures.auto;
503      }
504    };
505    exports.AbstractMessageSignature = AbstractMessageSignature;
506    var RequestType0 = class extends AbstractMessageSignature {
507      constructor(method) {
508        super(method, 0);
509      }
510    };
511    exports.RequestType0 = RequestType0;
512    var RequestType = class extends AbstractMessageSignature {
513      constructor(method, _parameterStructures = ParameterStructures.auto) {
514        super(method, 1);
515        this._parameterStructures = _parameterStructures;
516      }
517      get parameterStructures() {
518        return this._parameterStructures;
519      }
520    };
521    exports.RequestType = RequestType;
522    var RequestType1 = class extends AbstractMessageSignature {
523      constructor(method, _parameterStructures = ParameterStructures.auto) {
524        super(method, 1);
525        this._parameterStructures = _parameterStructures;
526      }
527      get parameterStructures() {
528        return this._parameterStructures;
529      }
530    };
531    exports.RequestType1 = RequestType1;
532    var RequestType2 = class extends AbstractMessageSignature {
533      constructor(method) {
534        super(method, 2);
535      }
536    };
537    exports.RequestType2 = RequestType2;
538    var RequestType3 = class extends AbstractMessageSignature {
539      constructor(method) {
540        super(method, 3);
541      }
542    };
543    exports.RequestType3 = RequestType3;
544    var RequestType4 = class extends AbstractMessageSignature {
545      constructor(method) {
546        super(method, 4);
547      }
548    };
549    exports.RequestType4 = RequestType4;
550    var RequestType5 = class extends AbstractMessageSignature {
551      constructor(method) {
552        super(method, 5);
553      }
554    };
555    exports.RequestType5 = RequestType5;
556    var RequestType6 = class extends AbstractMessageSignature {
557      constructor(method) {
558        super(method, 6);
559      }
560    };
561    exports.RequestType6 = RequestType6;
562    var RequestType7 = class extends AbstractMessageSignature {
563      constructor(method) {
564        super(method, 7);
565      }
566    };
567    exports.RequestType7 = RequestType7;
568    var RequestType8 = class extends AbstractMessageSignature {
569      constructor(method) {
570        super(method, 8);
571      }
572    };
573    exports.RequestType8 = RequestType8;
574    var RequestType9 = class extends AbstractMessageSignature {
575      constructor(method) {
576        super(method, 9);
577      }
578    };
579    exports.RequestType9 = RequestType9;
580    var NotificationType = class extends AbstractMessageSignature {
581      constructor(method, _parameterStructures = ParameterStructures.auto) {
582        super(method, 1);
583        this._parameterStructures = _parameterStructures;
584      }
585      get parameterStructures() {
586        return this._parameterStructures;
587      }
588    };
589    exports.NotificationType = NotificationType;
590    var NotificationType0 = class extends AbstractMessageSignature {
591      constructor(method) {
592        super(method, 0);
593      }
594    };
595    exports.NotificationType0 = NotificationType0;
596    var NotificationType1 = class extends AbstractMessageSignature {
597      constructor(method, _parameterStructures = ParameterStructures.auto) {
598        super(method, 1);
599        this._parameterStructures = _parameterStructures;
600      }
601      get parameterStructures() {
602        return this._parameterStructures;
603      }
604    };
605    exports.NotificationType1 = NotificationType1;
606    var NotificationType2 = class extends AbstractMessageSignature {
607      constructor(method) {
608        super(method, 2);
609      }
610    };
611    exports.NotificationType2 = NotificationType2;
612    var NotificationType3 = class extends AbstractMessageSignature {
613      constructor(method) {
614        super(method, 3);
615      }
616    };
617    exports.NotificationType3 = NotificationType3;
618    var NotificationType4 = class extends AbstractMessageSignature {
619      constructor(method) {
620        super(method, 4);
621      }
622    };
623    exports.NotificationType4 = NotificationType4;
624    var NotificationType5 = class extends AbstractMessageSignature {
625      constructor(method) {
626        super(method, 5);
627      }
628    };
629    exports.NotificationType5 = NotificationType5;
630    var NotificationType6 = class extends AbstractMessageSignature {
631      constructor(method) {
632        super(method, 6);
633      }
634    };
635    exports.NotificationType6 = NotificationType6;
636    var NotificationType7 = class extends AbstractMessageSignature {
637      constructor(method) {
638        super(method, 7);
639      }
640    };
641    exports.NotificationType7 = NotificationType7;
642    var NotificationType8 = class extends AbstractMessageSignature {
643      constructor(method) {
644        super(method, 8);
645      }
646    };
647    exports.NotificationType8 = NotificationType8;
648    var NotificationType9 = class extends AbstractMessageSignature {
649      constructor(method) {
650        super(method, 9);
651      }
652    };
653    exports.NotificationType9 = NotificationType9;
654    var Message;
655    (function(Message2) {
656      function isRequest(message) {
657        const candidate = message;
658        return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
659      }
660      Message2.isRequest = isRequest;
661      function isNotification(message) {
662        const candidate = message;
663        return candidate && is.string(candidate.method) && message.id === void 0;
664      }
665      Message2.isNotification = isNotification;
666      function isResponse(message) {
667        const candidate = message;
668        return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
669      }
670      Message2.isResponse = isResponse;
671    })(Message || (exports.Message = Message = {}));
672  }
673});
674

675// node_modules/vscode-jsonrpc/lib/common/linkedMap.js
676var require_linkedMap = __commonJS({
677  "node_modules/vscode-jsonrpc/lib/common/linkedMap.js"(exports) {
678    "use strict";
679    var _a3;
680    Object.defineProperty(exports, "__esModule", { value: true });
681    exports.LRUCache = exports.LinkedMap = exports.Touch = void 0;
682    var Touch;
683    (function(Touch2) {
684      Touch2.None = 0;
685      Touch2.First = 1;
686      Touch2.AsOld = Touch2.First;
687      Touch2.Last = 2;
688      Touch2.AsNew = Touch2.Last;
689    })(Touch || (exports.Touch = Touch = {}));
690    var LinkedMap = class {
691      constructor() {
692        this[_a3] = "LinkedMap";
693        this._map = /* @__PURE__ */ new Map();
694        this._head = void 0;
695        this._tail = void 0;
696        this._size = 0;
697        this._state = 0;
698      }
699      clear() {
700        this._map.clear();
701        this._head = void 0;
702        this._tail = void 0;
703        this._size = 0;
704        this._state++;
705      }
706      isEmpty() {
707        return !this._head && !this._tail;
708      }
709      get size() {
710        return this._size;
711      }
712      get first() {
713        return this._head?.value;
714      }
715      get last() {
716        return this._tail?.value;
717      }
718      has(key) {
719        return this._map.has(key);
720      }
721      get(key, touch = Touch.None) {
722        const item = this._map.get(key);
723        if (!item) {
724          return void 0;
725        }
726        if (touch !== Touch.None) {
727          this.touch(item, touch);
728        }
729        return item.value;
730      }
731      set(key, value, touch = Touch.None) {
732        let item = this._map.get(key);
733        if (item) {
734          item.value = value;
735          if (touch !== Touch.None) {
736            this.touch(item, touch);
737          }
738        } else {
739          item = { key, value, next: void 0, previous: void 0 };
740          switch (touch) {
741            case Touch.None:
742              this.addItemLast(item);
743              break;
744            case Touch.First:
745              this.addItemFirst(item);
746              break;
747            case Touch.Last:
748              this.addItemLast(item);
749              break;
750            default:
751              this.addItemLast(item);
752              break;
753          }
754          this._map.set(key, item);
755          this._size++;
756        }
757        return this;
758      }
759      delete(key) {
760        return !!this.remove(key);
761      }
762      remove(key) {
763        const item = this._map.get(key);
764        if (!item) {
765          return void 0;
766        }
767        this._map.delete(key);
768        this.removeItem(item);
769        this._size--;
770        return item.value;
771      }
772      shift() {
773        if (!this._head && !this._tail) {
774          return void 0;
775        }
776        if (!this._head || !this._tail) {
777          throw new Error("Invalid list");
778        }
779        const item = this._head;
780        this._map.delete(item.key);
781        this.removeItem(item);
782        this._size--;
783        return item.value;
784      }
785      forEach(callbackfn, thisArg) {
786        const state = this._state;
787        let current = this._head;
788        while (current) {
789          if (thisArg) {
790            callbackfn.bind(thisArg)(current.value, current.key, this);
791          } else {
792            callbackfn(current.value, current.key, this);
793          }
794          if (this._state !== state) {
795            throw new Error(`LinkedMap got modified during iteration.`);
796          }
797          current = current.next;
798        }
799      }
800      keys() {
801        const state = this._state;
802        let current = this._head;
803        const iterator = {
804          [Symbol.iterator]: () => {
805            return iterator;
806          },
807          next: () => {
808            if (this._state !== state) {
809              throw new Error(`LinkedMap got modified during iteration.`);
810            }
811            if (current) {
812              const result = { value: current.key, done: false };
813              current = current.next;
814              return result;
815            } else {
816              return { value: void 0, done: true };
817            }
818          }
819        };
820        return iterator;
821      }
822      values() {
823        const state = this._state;
824        let current = this._head;
825        const iterator = {
826          [Symbol.iterator]: () => {
827            return iterator;
828          },
829          next: () => {
830            if (this._state !== state) {
831              throw new Error(`LinkedMap got modified during iteration.`);
832            }
833            if (current) {
834              const result = { value: current.value, done: false };
835              current = current.next;
836              return result;
837            } else {
838              return { value: void 0, done: true };
839            }
840          }
841        };
842        return iterator;
843      }
844      entries() {
845        const state = this._state;
846        let current = this._head;
847        const iterator = {
848          [Symbol.iterator]: () => {
849            return iterator;
850          },
851          next: () => {
852            if (this._state !== state) {
853              throw new Error(`LinkedMap got modified during iteration.`);
854            }
855            if (current) {
856              const result = { value: [current.key, current.value], done: false };
857              current = current.next;
858              return result;
859            } else {
860              return { value: void 0, done: true };
861            }
862          }
863        };
864        return iterator;
865      }
866      [(_a3 = Symbol.toStringTag, Symbol.iterator)]() {
867        return this.entries();
868      }
869      trimOld(newSize) {
870        if (newSize >= this.size) {
871          return;
872        }
873        if (newSize === 0) {
874          this.clear();
875          return;
876        }
877        let current = this._head;
878        let currentSize = this.size;
879        while (current && currentSize > newSize) {
880          this._map.delete(current.key);
881          current = current.next;
882          currentSize--;
883        }
884        this._head = current;
885        this._size = currentSize;
886        if (current) {
887          current.previous = void 0;
888        }
889        this._state++;
890      }
891      addItemFirst(item) {
892        if (!this._head && !this._tail) {
893          this._tail = item;
894        } else if (!this._head) {
895          throw new Error("Invalid list");
896        } else {
897          item.next = this._head;
898          this._head.previous = item;
899        }
900        this._head = item;
901        this._state++;
902      }
903      addItemLast(item) {
904        if (!this._head && !this._tail) {
905          this._head = item;
906        } else if (!this._tail) {
907          throw new Error("Invalid list");
908        } else {
909          item.previous = this._tail;
910          this._tail.next = item;
911        }
912        this._tail = item;
913        this._state++;
914      }
915      removeItem(item) {
916        if (item === this._head && item === this._tail) {
917          this._head = void 0;
918          this._tail = void 0;
919        } else if (item === this._head) {
920          if (!item.next) {
921            throw new Error("Invalid list");
922          }
923          item.next.previous = void 0;
924          this._head = item.next;
925        } else if (item === this._tail) {
926          if (!item.previous) {
927            throw new Error("Invalid list");
928          }
929          item.previous.next = void 0;
930          this._tail = item.previous;
931        } else {
932          const next = item.next;
933          const previous = item.previous;
934          if (!next || !previous) {
935            throw new Error("Invalid list");
936          }
937          next.previous = previous;
938          previous.next = next;
939        }
940        item.next = void 0;
941        item.previous = void 0;
942        this._state++;
943      }
944      touch(item, touch) {
945        if (!this._head || !this._tail) {
946          throw new Error("Invalid list");
947        }
948        if (touch !== Touch.First && touch !== Touch.Last) {
949          return;
950        }
951        if (touch === Touch.First) {
952          if (item === this._head) {
953            return;
954          }
955          const next = item.next;
956          const previous = item.previous;
957          if (item === this._tail) {
958            previous.next = void 0;
959            this._tail = previous;
960          } else {
961            next.previous = previous;
962            previous.next = next;
963          }
964          item.previous = void 0;
965          item.next = this._head;
966          this._head.previous = item;
967          this._head = item;
968          this._state++;
969        } else if (touch === Touch.Last) {
970          if (item === this._tail) {
971            return;
972          }
973          const next = item.next;
974          const previous = item.previous;
975          if (item === this._head) {
976            next.previous = void 0;
977            this._head = next;
978          } else {
979            next.previous = previous;
980            previous.next = next;
981          }
982          item.next = void 0;
983          item.previous = this._tail;
984          this._tail.next = item;
985          this._tail = item;
986          this._state++;
987        }
988      }
989      toJSON() {
990        const data = [];
991        this.forEach((value, key) => {
992          data.push([key, value]);
993        });
994        return data;
995      }
996      fromJSON(data) {
997        this.clear();
998        for (const [key, value] of data) {
999          this.set(key, value);
1000        }
1001      }
1002    };
1003    exports.LinkedMap = LinkedMap;
1004    var LRUCache = class extends LinkedMap {
1005      constructor(limit, ratio = 1) {
1006        super();
1007        this._limit = limit;
1008        this._ratio = Math.min(Math.max(0, ratio), 1);
1009      }
1010      get limit() {
1011        return this._limit;
1012      }
1013      set limit(limit) {
1014        this._limit = limit;
1015        this.checkTrim();
1016      }
1017      get ratio() {
1018        return this._ratio;
1019      }
1020      set ratio(ratio) {
1021        this._ratio = Math.min(Math.max(0, ratio), 1);
1022        this.checkTrim();
1023      }
1024      get(key, touch = Touch.AsNew) {
1025        return super.get(key, touch);
1026      }
1027      peek(key) {
1028        return super.get(key, Touch.None);
1029      }
1030      set(key, value) {
1031        super.set(key, value, Touch.Last);
1032        this.checkTrim();
1033        return this;
1034      }
1035      checkTrim() {
1036        if (this.size > this._limit) {
1037          this.trimOld(Math.round(this._limit * this._ratio));
1038        }
1039      }
1040    };
1041    exports.LRUCache = LRUCache;
1042  }
1043});
1044

1045// node_modules/vscode-jsonrpc/lib/common/disposable.js
1046var require_disposable = __commonJS({
1047  "node_modules/vscode-jsonrpc/lib/common/disposable.js"(exports) {
1048    "use strict";
1049    Object.defineProperty(exports, "__esModule", { value: true });
1050    exports.Disposable = void 0;
1051    var Disposable;
1052    (function(Disposable2) {
1053      function create(func) {
1054        return {
1055          dispose: func
1056        };
1057      }
1058      Disposable2.create = create;
1059    })(Disposable || (exports.Disposable = Disposable = {}));
1060  }
1061});
1062

1063// node_modules/vscode-jsonrpc/lib/common/ral.js
1064var require_ral = __commonJS({
1065  "node_modules/vscode-jsonrpc/lib/common/ral.js"(exports) {
1066    "use strict";
1067    Object.defineProperty(exports, "__esModule", { value: true });
1068    var _ral;
1069    function RAL() {
1070      if (_ral === void 0) {
1071        throw new Error(`No runtime abstraction layer installed`);
1072      }
1073      return _ral;
1074    }
1075    (function(RAL2) {
1076      function install(ral) {
1077        if (ral === void 0) {
1078          throw new Error(`No runtime abstraction layer provided`);
1079        }
1080        _ral = ral;
1081      }
1082      RAL2.install = install;
1083    })(RAL || (RAL = {}));
1084    exports.default = RAL;
1085  }
1086});
1087

1088// node_modules/vscode-jsonrpc/lib/common/events.js
1089var require_events2 = __commonJS({
1090  "node_modules/vscode-jsonrpc/lib/common/events.js"(exports) {
1091    "use strict";
1092    Object.defineProperty(exports, "__esModule", { value: true });
1093    exports.Emitter = exports.Event = void 0;
1094    var ral_1 = require_ral();
1095    var Event;
1096    (function(Event2) {
1097      const _disposable = { dispose() {
1098      } };
1099      Event2.None = function() {
1100        return _disposable;
1101      };
1102    })(Event || (exports.Event = Event = {}));
1103    var CallbackList = class {
1104      add(callback, context = null, bucket) {
1105        if (!this._callbacks) {
1106          this._callbacks = [];
1107          this._contexts = [];
1108        }
1109        this._callbacks.push(callback);
1110        this._contexts.push(context);
1111        if (Array.isArray(bucket)) {
1112          bucket.push({ dispose: () => this.remove(callback, context) });
1113        }
1114      }
1115      remove(callback, context = null) {
1116        if (!this._callbacks) {
1117          return;
1118        }
1119        let foundCallbackWithDifferentContext = false;
1120        for (let i2 = 0, len = this._callbacks.length; i2 < len; i2++) {
1121          if (this._callbacks[i2] === callback) {
1122            if (this._contexts[i2] === context) {
1123              this._callbacks.splice(i2, 1);
1124              this._contexts.splice(i2, 1);
1125              return;
1126            } else {
1127              foundCallbackWithDifferentContext = true;
1128            }
1129          }
1130        }
1131        if (foundCallbackWithDifferentContext) {
1132          throw new Error("When adding a listener with a context, you should remove it with the same context");
1133        }
1134      }
1135      invoke(...args) {
1136        if (!this._callbacks) {
1137          return [];
1138        }
1139        const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
1140        for (let i2 = 0, len = callbacks.length; i2 < len; i2++) {
1141          try {
1142            ret.push(callbacks[i2].apply(contexts[i2], args));
1143          } catch (e2) {
1144            (0, ral_1.default)().console.error(e2);
1145          }
1146        }
1147        return ret;
1148      }
1149      isEmpty() {
1150        return !this._callbacks || this._callbacks.length === 0;
1151      }
1152      dispose() {
1153        this._callbacks = void 0;
1154        this._contexts = void 0;
1155      }
1156    };
1157    var Emitter = class _Emitter {
1158      constructor(_options) {
1159        this._options = _options;
1160      }
1161      /**
1162       * For the public to allow to subscribe
1163       * to events from this Emitter
1164       */
1165      get event() {
1166        if (!this._event) {
1167          this._event = (listener, thisArgs, disposables) => {
1168            if (!this._callbacks) {
1169              this._callbacks = new CallbackList();
1170            }
1171            if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
1172              this._options.onFirstListenerAdd(this);
1173            }
1174            this._callbacks.add(listener, thisArgs);
1175            const result = {
1176              dispose: () => {
1177                if (!this._callbacks) {
1178                  return;
1179                }
1180                this._callbacks.remove(listener, thisArgs);
1181                result.dispose = _Emitter._noop;
1182                if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
1183                  this._options.onLastListenerRemove(this);
1184                }
1185              }
1186            };
1187            if (Array.isArray(disposables)) {
1188              disposables.push(result);
1189            }
1190            return result;
1191          };
1192        }
1193        return this._event;
1194      }
1195      /**
1196       * To be kept private to fire an event to
1197       * subscribers
1198       */
1199      fire(event) {
1200        if (this._callbacks) {
1201          this._callbacks.invoke.call(this._callbacks, event);
1202        }
1203      }
1204      dispose() {
1205        if (this._callbacks) {
1206          this._callbacks.dispose();
1207          this._callbacks = void 0;
1208        }
1209      }
1210    };
1211    exports.Emitter = Emitter;
1212    Emitter._noop = function() {
1213    };
1214  }
1215});
1216

1217// node_modules/vscode-jsonrpc/lib/common/cancellation.js
1218var require_cancellation = __commonJS({
1219  "node_modules/vscode-jsonrpc/lib/common/cancellation.js"(exports) {
1220    "use strict";
1221    Object.defineProperty(exports, "__esModule", { value: true });
1222    exports.CancellationTokenSource = exports.CancellationToken = void 0;
1223    var ral_1 = require_ral();
1224    var Is2 = require_is();
1225    var events_1 = require_events2();
1226    var CancellationToken;
1227    (function(CancellationToken2) {
1228      CancellationToken2.None = Object.freeze({
1229        isCancellationRequested: false,
1230        onCancellationRequested: events_1.Event.None
1231      });
1232      CancellationToken2.Cancelled = Object.freeze({
1233        isCancellationRequested: true,
1234        onCancellationRequested: events_1.Event.None
1235      });
1236      function is(value) {
1237        const candidate = value;
1238        return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is2.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
1239      }
1240      CancellationToken2.is = is;
1241    })(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
1242    var shortcutEvent = Object.freeze(function(callback, context) {
1243      const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
1244      return { dispose() {
1245        handle.dispose();
1246      } };
1247    });
1248    var MutableToken = class {
1249      constructor() {
1250        this._isCancelled = false;
1251      }
1252      cancel() {
1253        if (!this._isCancelled) {
1254          this._isCancelled = true;
1255          if (this._emitter) {
1256            this._emitter.fire(void 0);
1257            this.dispose();
1258          }
1259        }
1260      }
1261      get isCancellationRequested() {
1262        return this._isCancelled;
1263      }
1264      get onCancellationRequested() {
1265        if (this._isCancelled) {
1266          return shortcutEvent;
1267        }
1268        if (!this._emitter) {
1269          this._emitter = new events_1.Emitter();
1270        }
1271        return this._emitter.event;
1272      }
1273      dispose() {
1274        if (this._emitter) {
1275          this._emitter.dispose();
1276          this._emitter = void 0;
1277        }
1278      }
1279    };
1280    var CancellationTokenSource = class {
1281      get token() {
1282        if (!this._token) {
1283          this._token = new MutableToken();
1284        }
1285        return this._token;
1286      }
1287      cancel() {
1288        if (!this._token) {
1289          this._token = CancellationToken.Cancelled;
1290        } else {
1291          this._token.cancel();
1292        }
1293      }
1294      dispose() {
1295        if (!this._token) {
1296          this._token = CancellationToken.None;
1297        } else if (this._token instanceof MutableToken) {
1298          this._token.dispose();
1299        }
1300      }
1301    };
1302    exports.CancellationTokenSource = CancellationTokenSource;
1303  }
1304});
1305

1306// node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js
1307var require_sharedArrayCancellation = __commonJS({
1308  "node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js"(exports) {
1309    "use strict";
1310    Object.defineProperty(exports, "__esModule", { value: true });
1311    exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
1312    var cancellation_1 = require_cancellation();
1313    var CancellationState;
1314    (function(CancellationState2) {
1315      CancellationState2.Continue = 0;
1316      CancellationState2.Cancelled = 1;
1317    })(CancellationState || (CancellationState = {}));
1318    var SharedArraySenderStrategy = class {
1319      constructor() {
1320        this.buffers = /* @__PURE__ */ new Map();
1321      }
1322      enableCancellation(request) {
1323        if (request.id === null) {
1324          return;
1325        }
1326        const buffer = new SharedArrayBuffer(4);
1327        const data = new Int32Array(buffer, 0, 1);
1328        data[0] = CancellationState.Continue;
1329        this.buffers.set(request.id, buffer);
1330        request.$cancellationData = buffer;
1331      }
1332      async sendCancellation(_conn, id2) {
1333        const buffer = this.buffers.get(id2);
1334        if (buffer === void 0) {
1335          return;
1336        }
1337        const data = new Int32Array(buffer, 0, 1);
1338        Atomics.store(data, 0, CancellationState.Cancelled);
1339      }
1340      cleanup(id2) {
1341        this.buffers.delete(id2);
1342      }
1343      dispose() {
1344        this.buffers.clear();
1345      }
1346    };
1347    exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
1348    var SharedArrayBufferCancellationToken = class {
1349      constructor(buffer) {
1350        this.data = new Int32Array(buffer, 0, 1);
1351      }
1352      get isCancellationRequested() {
1353        return Atomics.load(this.data, 0) === CancellationState.Cancelled;
1354      }
1355      get onCancellationRequested() {
1356        throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
1357      }
1358    };
1359    var SharedArrayBufferCancellationTokenSource = class {
1360      constructor(buffer) {
1361        this.token = new SharedArrayBufferCancellationToken(buffer);
1362      }
1363      cancel() {
1364      }
1365      dispose() {
1366      }
1367    };
1368    var SharedArrayReceiverStrategy = class {
1369      constructor() {
1370        this.kind = "request";
1371      }
1372      createCancellationTokenSource(request) {
1373        const buffer = request.$cancellationData;
1374        if (buffer === void 0) {
1375          return new cancellation_1.CancellationTokenSource();
1376        }
1377        return new SharedArrayBufferCancellationTokenSource(buffer);
1378      }
1379    };
1380    exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
1381  }
1382});
1383

1384// node_modules/vscode-jsonrpc/lib/common/semaphore.js
1385var require_semaphore = __commonJS({
1386  "node_modules/vscode-jsonrpc/lib/common/semaphore.js"(exports) {
1387    "use strict";
1388    Object.defineProperty(exports, "__esModule", { value: true });
1389    exports.Semaphore = void 0;
1390    var ral_1 = require_ral();
1391    var Semaphore = class {
1392      constructor(capacity = 1) {
1393        if (capacity <= 0) {
1394          throw new Error("Capacity must be greater than 0");
1395        }
1396        this._capacity = capacity;
1397        this._active = 0;
1398        this._waiting = [];
1399      }
1400      lock(thunk) {
1401        return new Promise((resolve, reject) => {
1402          this._waiting.push({ thunk, resolve, reject });
1403          this.runNext();
1404        });
1405      }
1406      get active() {
1407        return this._active;
1408      }
1409      runNext() {
1410        if (this._waiting.length === 0 || this._active === this._capacity) {
1411          return;
1412        }
1413        (0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
1414      }
1415      doRunNext() {
1416        if (this._waiting.length === 0 || this._active === this._capacity) {
1417          return;
1418        }
1419        const next = this._waiting.shift();
1420        this._active++;
1421        if (this._active > this._capacity) {
1422          throw new Error(`To many thunks active`);
1423        }
1424        try {
1425          const result = next.thunk();
1426          if (result instanceof Promise) {
1427            result.then((value) => {
1428              this._active--;
1429              next.resolve(value);
1430              this.runNext();
1431            }, (err2) => {
1432              this._active--;
1433              next.reject(err2);
1434              this.runNext();
1435            });
1436          } else {
1437            this._active--;
1438            next.resolve(result);
1439            this.runNext();
1440          }
1441        } catch (err2) {
1442          this._active--;
1443          next.reject(err2);
1444          this.runNext();
1445        }
1446      }
1447    };
1448    exports.Semaphore = Semaphore;
1449  }
1450});
1451

1452// node_modules/vscode-jsonrpc/lib/common/messageReader.js
1453var require_messageReader = __commonJS({
1454  "node_modules/vscode-jsonrpc/lib/common/messageReader.js"(exports) {
1455    "use strict";
1456    Object.defineProperty(exports, "__esModule", { value: true });
1457    exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
1458    var ral_1 = require_ral();
1459    var Is2 = require_is();
1460    var events_1 = require_events2();
1461    var semaphore_1 = require_semaphore();
1462    var MessageReader;
1463    (function(MessageReader2) {
1464      function is(value) {
1465        let candidate = value;
1466        return candidate && Is2.func(candidate.listen) && Is2.func(candidate.dispose) && Is2.func(candidate.onError) && Is2.func(candidate.onClose) && Is2.func(candidate.onPartialMessage);
1467      }
1468      MessageReader2.is = is;
1469    })(MessageReader || (exports.MessageReader = MessageReader = {}));
1470    var AbstractMessageReader2 = class {
1471      constructor() {
1472        this.errorEmitter = new events_1.Emitter();
1473        this.closeEmitter = new events_1.Emitter();
1474        this.partialMessageEmitter = new events_1.Emitter();
1475      }
1476      dispose() {
1477        this.errorEmitter.dispose();
1478        this.closeEmitter.dispose();
1479      }
1480      get onError() {
1481        return this.errorEmitter.event;
1482      }
1483      fireError(error) {
1484        this.errorEmitter.fire(this.asError(error));
1485      }
1486      get onClose() {
1487        return this.closeEmitter.event;
1488      }
1489      fireClose() {
1490        this.closeEmitter.fire(void 0);
1491      }
1492      get onPartialMessage() {
1493        return this.partialMessageEmitter.event;
1494      }
1495      firePartialMessage(info) {
1496        this.partialMessageEmitter.fire(info);
1497      }
1498      asError(error) {
1499        if (error instanceof Error) {
1500          return error;
1501        } else {
1502          return new Error(`Reader received error. Reason: ${Is2.string(error.message) ? error.message : "unknown"}`);
1503        }
1504      }
1505    };
1506    exports.AbstractMessageReader = AbstractMessageReader2;
1507    var ResolvedMessageReaderOptions;
1508    (function(ResolvedMessageReaderOptions2) {
1509      function fromOptions(options2) {
1510        let charset;
1511        let result;
1512        let contentDecoder;
1513        const contentDecoders = /* @__PURE__ */ new Map();
1514        let contentTypeDecoder;
1515        const contentTypeDecoders = /* @__PURE__ */ new Map();
1516        if (options2 === void 0 || typeof options2 === "string") {
1517          charset = options2 ?? "utf-8";
1518        } else {
1519          charset = options2.charset ?? "utf-8";
1520          if (options2.contentDecoder !== void 0) {
1521            contentDecoder = options2.contentDecoder;
1522            contentDecoders.set(contentDecoder.name, contentDecoder);
1523          }
1524          if (options2.contentDecoders !== void 0) {
1525            for (const decoder of options2.contentDecoders) {
1526              contentDecoders.set(decoder.name, decoder);
1527            }
1528          }
1529          if (options2.contentTypeDecoder !== void 0) {
1530            contentTypeDecoder = options2.contentTypeDecoder;
1531            contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
1532          }
1533          if (options2.contentTypeDecoders !== void 0) {
1534            for (const decoder of options2.contentTypeDecoders) {
1535              contentTypeDecoders.set(decoder.name, decoder);
1536            }
1537          }
1538        }
1539        if (contentTypeDecoder === void 0) {
1540          contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
1541          contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
1542        }
1543        return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
1544      }
1545      ResolvedMessageReaderOptions2.fromOptions = fromOptions;
1546    })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
1547    var ReadableStreamMessageReader = class extends AbstractMessageReader2 {
1548      constructor(readable, options2) {
1549        super();
1550        this.readable = readable;
1551        this.options = ResolvedMessageReaderOptions.fromOptions(options2);
1552        this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
1553        this._partialMessageTimeout = 1e4;
1554        this.nextMessageLength = -1;
1555        this.messageToken = 0;
1556        this.readSemaphore = new semaphore_1.Semaphore(1);
1557      }
1558      set partialMessageTimeout(timeout) {
1559        this._partialMessageTimeout = timeout;
1560      }
1561      get partialMessageTimeout() {
1562        return this._partialMessageTimeout;
1563      }
1564      listen(callback) {
1565        this.nextMessageLength = -1;
1566        this.messageToken = 0;
1567        this.partialMessageTimer = void 0;
1568        this.callback = callback;
1569        const result = this.readable.onData((data) => {
1570          this.onData(data);
1571        });
1572        this.readable.onError((error) => this.fireError(error));
1573        this.readable.onClose(() => this.fireClose());
1574        return result;
1575      }
1576      onData(data) {
1577        try {
1578          this.buffer.append(data);
1579          while (true) {
1580            if (this.nextMessageLength === -1) {
1581              const headers = this.buffer.tryReadHeaders(true);
1582              if (!headers) {
1583                return;
1584              }
1585              const contentLength = headers.get("content-length");
1586              if (!contentLength) {
1587                this.fireError(new Error(`Header must provide a Content-Length property.
1588${JSON.stringify(Object.fromEntries(headers))}`));
1589                return;
1590              }
1591              const length = parseInt(contentLength);
1592              if (isNaN(length)) {
1593                this.fireError(new Error(`Content-Length value must be a number. Got ${contentLength}`));
1594                return;
1595              }
1596              this.nextMessageLength = length;
1597            }
1598            const body = this.buffer.tryReadBody(this.nextMessageLength);
1599            if (body === void 0) {
1600              this.setPartialMessageTimer();
1601              return;
1602            }
1603            this.clearPartialMessageTimer();
1604            this.nextMessageLength = -1;
1605            this.readSemaphore.lock(async () => {
1606              const bytes = this.options.contentDecoder !== void 0 ? await this.options.contentDecoder.decode(body) : body;
1607              const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
1608              this.callback(message);
1609            }).catch((error) => {
1610              this.fireError(error);
1611            });
1612          }
1613        } catch (error) {
1614          this.fireError(error);
1615        }
1616      }
1617      clearPartialMessageTimer() {
1618        if (this.partialMessageTimer) {
1619          this.partialMessageTimer.dispose();
1620          this.partialMessageTimer = void 0;
1621        }
1622      }
1623      setPartialMessageTimer() {
1624        this.clearPartialMessageTimer();
1625        if (this._partialMessageTimeout <= 0) {
1626          return;
1627        }
1628        this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
1629          this.partialMessageTimer = void 0;
1630          if (token === this.messageToken) {
1631            this.firePartialMessage({ messageToken: token, waitingTime: timeout });
1632            this.setPartialMessageTimer();
1633          }
1634        }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
1635      }
1636    };
1637    exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
1638  }
1639});
1640

1641// node_modules/vscode-jsonrpc/lib/common/messageWriter.js
1642var require_messageWriter = __commonJS({
1643  "node_modules/vscode-jsonrpc/lib/common/messageWriter.js"(exports) {
1644    "use strict";
1645    Object.defineProperty(exports, "__esModule", { value: true });
1646    exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
1647    var ral_1 = require_ral();
1648    var Is2 = require_is();
1649    var semaphore_1 = require_semaphore();
1650    var events_1 = require_events2();
1651    var ContentLength = "Content-Length: ";
1652    var CRLF = "\r\n";
1653    var MessageWriter;
1654    (function(MessageWriter2) {
1655      function is(value) {
1656        let candidate = value;
1657        return candidate && Is2.func(candidate.dispose) && Is2.func(candidate.onClose) && Is2.func(candidate.onError) && Is2.func(candidate.write);
1658      }
1659      MessageWriter2.is = is;
1660    })(MessageWriter || (exports.MessageWriter = MessageWriter = {}));
1661    var AbstractMessageWriter2 = class {
1662      constructor() {
1663        this.errorEmitter = new events_1.Emitter();
1664        this.closeEmitter = new events_1.Emitter();
1665      }
1666      dispose() {
1667        this.errorEmitter.dispose();
1668        this.closeEmitter.dispose();
1669      }
1670      get onError() {
1671        return this.errorEmitter.event;
1672      }
1673      fireError(error, message, count) {
1674        this.errorEmitter.fire([this.asError(error), message, count]);
1675      }
1676      get onClose() {
1677        return this.closeEmitter.event;
1678      }
1679      fireClose() {
1680        this.closeEmitter.fire(void 0);
1681      }
1682      asError(error) {
1683        if (error instanceof Error) {
1684          return error;
1685        } else {
1686          return new Error(`Writer received error. Reason: ${Is2.string(error.message) ? error.message : "unknown"}`);
1687        }
1688      }
1689    };
1690    exports.AbstractMessageWriter = AbstractMessageWriter2;
1691    var ResolvedMessageWriterOptions;
1692    (function(ResolvedMessageWriterOptions2) {
1693      function fromOptions(options2) {
1694        if (options2 === void 0 || typeof options2 === "string") {
1695          return { charset: options2 ?? "utf-8", contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
1696        } else {
1697          return { charset: options2.charset ?? "utf-8", contentEncoder: options2.contentEncoder, contentTypeEncoder: options2.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
1698        }
1699      }
1700      ResolvedMessageWriterOptions2.fromOptions = fromOptions;
1701    })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
1702    var WriteableStreamMessageWriter = class extends AbstractMessageWriter2 {
1703      constructor(writable, options2) {
1704        super();
1705        this.writable = writable;
1706        this.options = ResolvedMessageWriterOptions.fromOptions(options2);
1707        this.errorCount = 0;
1708        this.writeSemaphore = new semaphore_1.Semaphore(1);
1709        this.writable.onError((error) => this.fireError(error));
1710        this.writable.onClose(() => this.fireClose());
1711      }
1712      async write(msg) {
1713        return this.writeSemaphore.lock(async () => {
1714          const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
1715            if (this.options.contentEncoder !== void 0) {
1716              return this.options.contentEncoder.encode(buffer);
1717            } else {
1718              return buffer;
1719            }
1720          });
1721          return payload.then((buffer) => {
1722            const headers = [];
1723            headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
1724            headers.push(CRLF);
1725            return this.doWrite(msg, headers, buffer);
1726          }, (error) => {
1727            this.fireError(error);
1728            throw error;
1729          });
1730        });
1731      }
1732      async doWrite(msg, headers, data) {
1733        try {
1734          await this.writable.write(headers.join(""), "ascii");
1735          return this.writable.write(data);
1736        } catch (error) {
1737          this.handleError(error, msg);
1738          return Promise.reject(error);
1739        }
1740      }
1741      handleError(error, msg) {
1742        this.errorCount++;
1743        this.fireError(error, msg, this.errorCount);
1744      }
1745      end() {
1746        this.writable.end();
1747      }
1748    };
1749    exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
1750  }
1751});
1752

1753// node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
1754var require_messageBuffer = __commonJS({
1755  "node_modules/vscode-jsonrpc/lib/common/messageBuffer.js"(exports) {
1756    "use strict";
1757    Object.defineProperty(exports, "__esModule", { value: true });
1758    exports.AbstractMessageBuffer = void 0;
1759    var CR = 13;
1760    var LF = 10;
1761    var CRLF = "\r\n";
1762    var AbstractMessageBuffer = class {
1763      constructor(encoding = "utf-8") {
1764        this._encoding = encoding;
1765        this._chunks = [];
1766        this._totalLength = 0;
1767      }
1768      get encoding() {
1769        return this._encoding;
1770      }
1771      append(chunk) {
1772        const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
1773        this._chunks.push(toAppend);
1774        this._totalLength += toAppend.byteLength;
1775      }
1776      tryReadHeaders(lowerCaseKeys = false) {
1777        if (this._chunks.length === 0) {
1778          return void 0;
1779        }
1780        let state = 0;
1781        let chunkIndex = 0;
1782        let offset = 0;
1783        let chunkBytesRead = 0;
1784        row:
1785          while (chunkIndex < this._chunks.length) {
1786            const chunk = this._chunks[chunkIndex];
1787            offset = 0;
1788            column:
1789              while (offset < chunk.length) {
1790                const value = chunk[offset];
1791                switch (value) {
1792                  case CR:
1793                    switch (state) {
1794                      case 0:
1795                        state = 1;
1796                        break;
1797                      case 2:
1798                        state = 3;
1799                        break;
1800                      default:
1801                        state = 0;
1802                    }
1803                    break;
1804                  case LF:
1805                    switch (state) {
1806                      case 1:
1807                        state = 2;
1808                        break;
1809                      case 3:
1810                        state = 4;
1811                        offset++;
1812                        break row;
1813                      default:
1814                        state = 0;
1815                    }
1816                    break;
1817                  default:
1818                    state = 0;
1819                }
1820                offset++;
1821              }
1822            chunkBytesRead += chunk.byteLength;
1823            chunkIndex++;
1824          }
1825        if (state !== 4) {
1826          return void 0;
1827        }
1828        const buffer = this._read(chunkBytesRead + offset);
1829        const result = /* @__PURE__ */ new Map();
1830        const headers = this.toString(buffer, "ascii").split(CRLF);
1831        if (headers.length < 2) {
1832          return result;
1833        }
1834        for (let i2 = 0; i2 < headers.length - 2; i2++) {
1835          const header = headers[i2];
1836          const index = header.indexOf(":");
1837          if (index === -1) {
1838            throw new Error(`Message header must separate key and value using ':'
1839${header}`);
1840          }
1841          const key = header.substr(0, index);
1842          const value = header.substr(index + 1).trim();
1843          result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
1844        }
1845        return result;
1846      }
1847      tryReadBody(length) {
1848        if (this._totalLength < length) {
1849          return void 0;
1850        }
1851        return this._read(length);
1852      }
1853      get numberOfBytes() {
1854        return this._totalLength;
1855      }
1856      _read(byteCount) {
1857        if (byteCount === 0) {
1858          return this.emptyBuffer();
1859        }
1860        if (byteCount > this._totalLength) {
1861          throw new Error(`Cannot read so many bytes!`);
1862        }
1863        if (this._chunks[0].byteLength === byteCount) {
1864          const chunk = this._chunks[0];
1865          this._chunks.shift();
1866          this._totalLength -= byteCount;
1867          return this.asNative(chunk);
1868        }
1869        if (this._chunks[0].byteLength > byteCount) {
1870          const chunk = this._chunks[0];
1871          const result2 = this.asNative(chunk, byteCount);
1872          this._chunks[0] = chunk.slice(byteCount);
1873          this._totalLength -= byteCount;
1874          return result2;
1875        }
1876        const result = this.allocNative(byteCount);
1877        let resultOffset = 0;
1878        let chunkIndex = 0;
1879        while (byteCount > 0) {
1880          const chunk = this._chunks[chunkIndex];
1881          if (chunk.byteLength > byteCount) {
1882            const chunkPart = chunk.slice(0, byteCount);
1883            result.set(chunkPart, resultOffset);
1884            resultOffset += byteCount;
1885            this._chunks[chunkIndex] = chunk.slice(byteCount);
1886            this._totalLength -= byteCount;
1887            byteCount -= byteCount;
1888          } else {
1889            result.set(chunk, resultOffset);
1890            resultOffset += chunk.byteLength;
1891            this._chunks.shift();
1892            this._totalLength -= chunk.byteLength;
1893            byteCount -= chunk.byteLength;
1894          }
1895        }
1896        return result;
1897      }
1898    };
1899    exports.AbstractMessageBuffer = AbstractMessageBuffer;
1900  }
1901});
1902

1903// node_modules/vscode-jsonrpc/lib/common/connection.js
1904var require_connection = __commonJS({
1905  "node_modules/vscode-jsonrpc/lib/common/connection.js"(exports) {
1906    "use strict";
1907    Object.defineProperty(exports, "__esModule", { value: true });
1908    exports.createMessageConnection = exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
1909    var ral_1 = require_ral();
1910    var Is2 = require_is();
1911    var messages_1 = require_messages();
1912    var linkedMap_1 = require_linkedMap();
1913    var events_1 = require_events2();
1914    var cancellation_1 = require_cancellation();
1915    var CancelNotification;
1916    (function(CancelNotification2) {
1917      CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
1918    })(CancelNotification || (CancelNotification = {}));
1919    var ProgressToken;
1920    (function(ProgressToken2) {
1921      function is(value) {
1922        return typeof value === "string" || typeof value === "number";
1923      }
1924      ProgressToken2.is = is;
1925    })(ProgressToken || (exports.ProgressToken = ProgressToken = {}));
1926    var ProgressNotification;
1927    (function(ProgressNotification2) {
1928      ProgressNotification2.type = new messages_1.NotificationType("$/progress");
1929    })(ProgressNotification || (ProgressNotification = {}));
1930    var ProgressType = class {
1931      constructor() {
1932      }
1933    };
1934    exports.ProgressType = ProgressType;
1935    var StarRequestHandler;
1936    (function(StarRequestHandler2) {
1937      function is(value) {
1938        return Is2.func(value);
1939      }
1940      StarRequestHandler2.is = is;
1941    })(StarRequestHandler || (StarRequestHandler = {}));
1942    exports.NullLogger = Object.freeze({
1943      error: () => {
1944      },
1945      warn: () => {
1946      },
1947      info: () => {
1948      },
1949      log: () => {
1950      }
1951    });
1952    var Trace;
1953    (function(Trace2) {
1954      Trace2[Trace2["Off"] = 0] = "Off";
1955      Trace2[Trace2["Messages"] = 1] = "Messages";
1956      Trace2[Trace2["Compact"] = 2] = "Compact";
1957      Trace2[Trace2["Verbose"] = 3] = "Verbose";
1958    })(Trace || (exports.Trace = Trace = {}));
1959    var TraceValues;
1960    (function(TraceValues2) {
1961      TraceValues2.Off = "off";
1962      TraceValues2.Messages = "messages";
1963      TraceValues2.Compact = "compact";
1964      TraceValues2.Verbose = "verbose";
1965    })(TraceValues || (exports.TraceValues = TraceValues = {}));
1966    (function(Trace2) {
1967      function fromString(value) {
1968        if (!Is2.string(value)) {
1969          return Trace2.Off;
1970        }
1971        value = value.toLowerCase();
1972        switch (value) {
1973          case "off":
1974            return Trace2.Off;
1975          case "messages":
1976            return Trace2.Messages;
1977          case "compact":
1978            return Trace2.Compact;
1979          case "verbose":
1980            return Trace2.Verbose;
1981          default:
1982            return Trace2.Off;
1983        }
1984      }
1985      Trace2.fromString = fromString;
1986      function toString(value) {
1987        switch (value) {
1988          case Trace2.Off:
1989            return "off";
1990          case Trace2.Messages:
1991            return "messages";
1992          case Trace2.Compact:
1993            return "compact";
1994          case Trace2.Verbose:
1995            return "verbose";
1996          default:
1997            return "off";
1998        }
1999      }
2000      Trace2.toString = toString;
2001    })(Trace || (exports.Trace = Trace = {}));
2002    var TraceFormat;
2003    (function(TraceFormat2) {
2004      TraceFormat2["Text"] = "text";
2005      TraceFormat2["JSON"] = "json";
2006    })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
2007    (function(TraceFormat2) {
2008      function fromString(value) {
2009        if (!Is2.string(value)) {
2010          return TraceFormat2.Text;
2011        }
2012        value = value.toLowerCase();
2013        if (value === "json") {
2014          return TraceFormat2.JSON;
2015        } else {
2016          return TraceFormat2.Text;
2017        }
2018      }
2019      TraceFormat2.fromString = fromString;
2020    })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
2021    var SetTraceNotification;
2022    (function(SetTraceNotification2) {
2023      SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
2024    })(SetTraceNotification || (exports.SetTraceNotification = SetTraceNotification = {}));
2025    var LogTraceNotification;
2026    (function(LogTraceNotification2) {
2027      LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
2028    })(LogTraceNotification || (exports.LogTraceNotification = LogTraceNotification = {}));
2029    var ConnectionErrors;
2030    (function(ConnectionErrors2) {
2031      ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
2032      ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
2033      ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
2034    })(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
2035    var ConnectionError = class _ConnectionError extends Error {
2036      constructor(code, message) {
2037        super(message);
2038        this.code = code;
2039        Object.setPrototypeOf(this, _ConnectionError.prototype);
2040      }
2041    };
2042    exports.ConnectionError = ConnectionError;
2043    var ConnectionStrategy;
2044    (function(ConnectionStrategy2) {
2045      function is(value) {
2046        const candidate = value;
2047        return candidate && Is2.func(candidate.cancelUndispatched);
2048      }
2049      ConnectionStrategy2.is = is;
2050    })(ConnectionStrategy || (exports.ConnectionStrategy = ConnectionStrategy = {}));
2051    var IdCancellationReceiverStrategy;
2052    (function(IdCancellationReceiverStrategy2) {
2053      function is(value) {
2054        const candidate = value;
2055        return candidate && (candidate.kind === void 0 || candidate.kind === "id") && Is2.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is2.func(candidate.dispose));
2056      }
2057      IdCancellationReceiverStrategy2.is = is;
2058    })(IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
2059    var RequestCancellationReceiverStrategy;
2060    (function(RequestCancellationReceiverStrategy2) {
2061      function is(value) {
2062        const candidate = value;
2063        return candidate && candidate.kind === "request" && Is2.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is2.func(candidate.dispose));
2064      }
2065      RequestCancellationReceiverStrategy2.is = is;
2066    })(RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
2067    var CancellationReceiverStrategy;
2068    (function(CancellationReceiverStrategy2) {
2069      CancellationReceiverStrategy2.Message = Object.freeze({
2070        createCancellationTokenSource(_2) {
2071          return new cancellation_1.CancellationTokenSource();
2072        }
2073      });
2074      function is(value) {
2075        return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
2076      }
2077      CancellationReceiverStrategy2.is = is;
2078    })(CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
2079    var CancellationSenderStrategy;
2080    (function(CancellationSenderStrategy2) {
2081      CancellationSenderStrategy2.Message = Object.freeze({
2082        sendCancellation(conn, id2) {
2083          return conn.sendNotification(CancelNotification.type, { id: id2 });
2084        },
2085        cleanup(_2) {
2086        }
2087      });
2088      function is(value) {
2089        const candidate = value;
2090        return candidate && Is2.func(candidate.sendCancellation) && Is2.func(candidate.cleanup);
2091      }
2092      CancellationSenderStrategy2.is = is;
2093    })(CancellationSenderStrategy || (exports.CancellationSenderStrategy = CancellationSenderStrategy = {}));
2094    var CancellationStrategy;
2095    (function(CancellationStrategy2) {
2096      CancellationStrategy2.Message = Object.freeze({
2097        receiver: CancellationReceiverStrategy.Message,
2098        sender: CancellationSenderStrategy.Message
2099      });
2100      function is(value) {
2101        const candidate = value;
2102        return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
2103      }
2104      CancellationStrategy2.is = is;
2105    })(CancellationStrategy || (exports.CancellationStrategy = CancellationStrategy = {}));
2106    var MessageStrategy;
2107    (function(MessageStrategy2) {
2108      function is(value) {
2109        const candidate = value;
2110        return candidate && Is2.func(candidate.handleMessage);
2111      }
2112      MessageStrategy2.is = is;
2113    })(MessageStrategy || (exports.MessageStrategy = MessageStrategy = {}));
2114    var ConnectionOptions;
2115    (function(ConnectionOptions2) {
2116      function is(value) {
2117        const candidate = value;
2118        return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
2119      }
2120      ConnectionOptions2.is = is;
2121    })(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
2122    var ConnectionState;
2123    (function(ConnectionState2) {
2124      ConnectionState2[ConnectionState2["New"] = 1] = "New";
2125      ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
2126      ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
2127      ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
2128    })(ConnectionState || (ConnectionState = {}));
2129    function createMessageConnection3(messageReader, messageWriter, _logger, options2) {
2130      const logger = _logger !== void 0 ? _logger : exports.NullLogger;
2131      let sequenceNumber = 0;
2132      let notificationSequenceNumber = 0;
2133      let unknownResponseSequenceNumber = 0;
2134      const version = "2.0";
2135      let starRequestHandler = void 0;
2136      const requestHandlers = /* @__PURE__ */ new Map();
2137      let starNotificationHandler = void 0;
2138      const notificationHandlers = /* @__PURE__ */ new Map();
2139      const progressHandlers = /* @__PURE__ */ new Map();
2140      let timer;
2141      let messageQueue = new linkedMap_1.LinkedMap();
2142      let responsePromises = /* @__PURE__ */ new Map();
2143      let knownCanceledRequests = /* @__PURE__ */ new Set();
2144      let requestTokens = /* @__PURE__ */ new Map();
2145      let trace = Trace.Off;
2146      let traceFormat = TraceFormat.Text;
2147      let tracer;
2148      let state = ConnectionState.New;
2149      const errorEmitter = new events_1.Emitter();
2150      const closeEmitter = new events_1.Emitter();
2151      const unhandledNotificationEmitter = new events_1.Emitter();
2152      const unhandledProgressEmitter = new events_1.Emitter();
2153      const disposeEmitter = new events_1.Emitter();
2154      const cancellationStrategy = options2 && options2.cancellationStrategy ? options2.cancellationStrategy : CancellationStrategy.Message;
2155      function createRequestQueueKey(id2) {
2156        if (id2 === null) {
2157          throw new Error(`Can't send requests with id null since the response can't be correlated.`);
2158        }
2159        return "req-" + id2.toString();
2160      }
2161      function createResponseQueueKey(id2) {
2162        if (id2 === null) {
2163          return "res-unknown-" + (++unknownResponseSequenceNumber).toString();
2164        } else {
2165          return "res-" + id2.toString();
2166        }
2167      }
2168      function createNotificationQueueKey() {
2169        return "not-" + (++notificationSequenceNumber).toString();
2170      }
2171      function addMessageToQueue(queue, message) {
2172        if (messages_1.Message.isRequest(message)) {
2173          queue.set(createRequestQueueKey(message.id), message);
2174        } else if (messages_1.Message.isResponse(message)) {
2175          queue.set(createResponseQueueKey(message.id), message);
2176        } else {
2177          queue.set(createNotificationQueueKey(), message);
2178        }
2179      }
2180      function cancelUndispatched(_message) {
2181        return void 0;
2182      }
2183      function isListening() {
2184        return state === ConnectionState.Listening;
2185      }
2186      function isClosed() {
2187        return state === ConnectionState.Closed;
2188      }
2189      function isDisposed() {
2190        return state === ConnectionState.Disposed;
2191      }
2192      function closeHandler() {
2193        if (state === ConnectionState.New || state === ConnectionState.Listening) {
2194          state = ConnectionState.Closed;
2195          closeEmitter.fire(void 0);
2196        }
2197      }
2198      function readErrorHandler(error) {
2199        errorEmitter.fire([error, void 0, void 0]);
2200      }
2201      function writeErrorHandler(data) {
2202        errorEmitter.fire(data);
2203      }
2204      messageReader.onClose(closeHandler);
2205      messageReader.onError(readErrorHandler);
2206      messageWriter.onClose(closeHandler);
2207      messageWriter.onError(writeErrorHandler);
2208      function triggerMessageQueue() {
2209        if (timer || messageQueue.size === 0) {
2210          return;
2211        }
2212        timer = (0, ral_1.default)().timer.setImmediate(() => {
2213          timer = void 0;
2214          processMessageQueue();
2215        });
2216      }
2217      function handleMessage(message) {
2218        if (messages_1.Message.isRequest(message)) {
2219          handleRequest(message);
2220        } else if (messages_1.Message.isNotification(message)) {
2221          handleNotification(message);
2222        } else if (messages_1.Message.isResponse(message)) {
2223          handleResponse(message);
2224        } else {
2225          handleInvalidMessage(message);
2226        }
2227      }
2228      function processMessageQueue() {
2229        if (messageQueue.size === 0) {
2230          return;
2231        }
2232        const message = messageQueue.shift();
2233        try {
2234          const messageStrategy = options2?.messageStrategy;
2235          if (MessageStrategy.is(messageStrategy)) {
2236            messageStrategy.handleMessage(message, handleMessage);
2237          } else {
2238            handleMessage(message);
2239          }
2240        } finally {
2241          triggerMessageQueue();
2242        }
2243      }
2244      const callback = (message) => {
2245        try {
2246          if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
2247            const cancelId = message.params.id;
2248            const key = createRequestQueueKey(cancelId);
2249            const toCancel = messageQueue.get(key);
2250            if (messages_1.Message.isRequest(toCancel)) {
2251              const strategy = options2?.connectionStrategy;
2252              const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
2253              if (response && (response.error !== void 0 || response.result !== void 0)) {
2254                messageQueue.delete(key);
2255                requestTokens.delete(cancelId);
2256                response.id = toCancel.id;
2257                traceSendingResponse(response, message.method, Date.now());
2258                messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
2259                return;
2260              }
2261            }
2262            const cancellationToken = requestTokens.get(cancelId);
2263            if (cancellationToken !== void 0) {
2264              cancellationToken.cancel();
2265              traceReceivedNotification(message);
2266              return;
2267            } else {
2268              knownCanceledRequests.add(cancelId);
2269            }
2270          }
2271          addMessageToQueue(messageQueue, message);
2272        } finally {
2273          triggerMessageQueue();
2274        }
2275      };
2276      function handleRequest(requestMessage) {
2277        if (isDisposed()) {
2278          return;
2279        }
2280        function reply(resultOrError, method, startTime2) {
2281          const message = {
2282            jsonrpc: version,
2283            id: requestMessage.id
2284          };
2285          if (resultOrError instanceof messages_1.ResponseError) {
2286            message.error = resultOrError.toJson();
2287          } else {
2288            message.result = resultOrError === void 0 ? null : resultOrError;
2289          }
2290          traceSendingResponse(message, method, startTime2);
2291          messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
2292        }
2293        function replyError(error, method, startTime2) {
2294          const message = {
2295            jsonrpc: version,
2296            id: requestMessage.id,
2297            error: error.toJson()
2298          };
2299          traceSendingResponse(message, method, startTime2);
2300          messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
2301        }
2302        function replySuccess(result, method, startTime2) {
2303          if (result === void 0) {
2304            result = null;
2305          }
2306          const message = {
2307            jsonrpc: version,
2308            id: requestMessage.id,
2309            result
2310          };
2311          traceSendingResponse(message, method, startTime2);
2312          messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
2313        }
2314        traceReceivedRequest(requestMessage);
2315        const element = requestHandlers.get(requestMessage.method);
2316        let type;
2317        let requestHandler;
2318        if (element) {
2319          type = element.type;
2320          requestHandler = element.handler;
2321        }
2322        const startTime = Date.now();
2323        if (requestHandler || starRequestHandler) {
2324          const tokenKey = requestMessage.id ?? String(Date.now());
2325          const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver) ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey) : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
2326          if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
2327            cancellationSource.cancel();
2328          }
2329          if (requestMessage.id !== null) {
2330            requestTokens.set(tokenKey, cancellationSource);
2331          }
2332          try {
2333            let handlerResult;
2334            if (requestHandler) {
2335              if (requestMessage.params === void 0) {
2336                if (type !== void 0 && type.numberOfParams !== 0) {
2337                  replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
2338                  return;
2339                }
2340                handlerResult = requestHandler(cancellationSource.token);
2341              } else if (Array.isArray(requestMessage.params)) {
2342                if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
2343                  replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
2344                  return;
2345                }
2346                handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
2347              } else {
2348                if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
2349                  replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
2350                  return;
2351                }
2352                handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
2353              }
2354            } else if (starRequestHandler) {
2355              handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
2356            }
2357            const promise = handlerResult;
2358            if (!handlerResult) {
2359              requestTokens.delete(tokenKey);
2360              replySuccess(handlerResult, requestMessage.method, startTime);
2361            } else if (promise.then) {
2362              promise.then((resultOrError) => {
2363                requestTokens.delete(tokenKey);
2364                reply(resultOrError, requestMessage.method, startTime);
2365              }, (error) => {
2366                requestTokens.delete(tokenKey);
2367                if (error instanceof messages_1.ResponseError) {
2368                  replyError(error, requestMessage.method, startTime);
2369                } else if (error && Is2.string(error.message)) {
2370                  replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
2371                } else {
2372                  replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
2373                }
2374              });
2375            } else {
2376              requestTokens.delete(tokenKey);
2377              reply(handlerResult, requestMessage.method, startTime);
2378            }
2379          } catch (error) {
2380            requestTokens.delete(tokenKey);
2381            if (error instanceof messages_1.ResponseError) {
2382              reply(error, requestMessage.method, startTime);
2383            } else if (error && Is2.string(error.message)) {
2384              replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
2385            } else {
2386              replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
2387            }
2388          }
2389        } else {
2390          replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
2391        }
2392      }
2393      function handleResponse(responseMessage) {
2394        if (isDisposed()) {
2395          return;
2396        }
2397        if (responseMessage.id === null) {
2398          if (responseMessage.error) {
2399            logger.error(`Received response message without id: Error is: 
2400${JSON.stringify(responseMessage.error, void 0, 4)}`);
2401          } else {
2402            logger.error(`Received response message without id. No further error information provided.`);
2403          }
2404        } else {
2405          const key = responseMessage.id;
2406          const responsePromise = responsePromises.get(key);
2407          traceReceivedResponse(responseMessage, responsePromise);
2408          if (responsePromise !== void 0) {
2409            responsePromises.delete(key);
2410            try {
2411              if (responseMessage.error) {
2412                const error = responseMessage.error;
2413                responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
2414              } else if (responseMessage.result !== void 0) {
2415                responsePromise.resolve(responseMessage.result);
2416              } else {
2417                throw new Error("Should never happen.");
2418              }
2419            } catch (error) {
2420              if (error.message) {
2421                logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
2422              } else {
2423                logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
2424              }
2425            }
2426          }
2427        }
2428      }
2429      function handleNotification(message) {
2430        if (isDisposed()) {
2431          return;
2432        }
2433        let type = void 0;
2434        let notificationHandler;
2435        if (message.method === CancelNotification.type.method) {
2436          const cancelId = message.params.id;
2437          knownCanceledRequests.delete(cancelId);
2438          traceReceivedNotification(message);
2439          return;
2440        } else {
2441          const element = notificationHandlers.get(message.method);
2442          if (element) {
2443            notificationHandler = element.handler;
2444            type = element.type;
2445          }
2446        }
2447        if (notificationHandler || starNotificationHandler) {
2448          try {
2449            traceReceivedNotification(message);
2450            if (notificationHandler) {
2451              if (message.params === void 0) {
2452                if (type !== void 0) {
2453                  if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
2454                    logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
2455                  }
2456                }
2457                notificationHandler();
2458              } else if (Array.isArray(message.params)) {
2459                const params = message.params;
2460                if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
2461                  notificationHandler({ token: params[0], value: params[1] });
2462                } else {
2463                  if (type !== void 0) {
2464                    if (type.parameterStructures === messages_1.ParameterStructures.byName) {
2465                      logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
2466                    }
2467                    if (type.numberOfParams !== message.params.length) {
2468                      logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
2469                    }
2470                  }
2471                  notificationHandler(...params);
2472                }
2473              } else {
2474                if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
2475                  logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
2476                }
2477                notificationHandler(message.params);
2478              }
2479            } else if (starNotificationHandler) {
2480              starNotificationHandler(message.method, message.params);
2481            }
2482          } catch (error) {
2483            if (error.message) {
2484              logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
2485            } else {
2486              logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
2487            }
2488          }
2489        } else {
2490          unhandledNotificationEmitter.fire(message);
2491        }
2492      }
2493      function handleInvalidMessage(message) {
2494        if (!message) {
2495          logger.error("Received empty message.");
2496          return;
2497        }
2498        logger.error(`Received message which is neither a response nor a notification message:
2499${JSON.stringify(message, null, 4)}`);
2500        const responseMessage = message;
2501        if (Is2.string(responseMessage.id) || Is2.number(responseMessage.id)) {
2502          const key = responseMessage.id;
2503          const responseHandler = responsePromises.get(key);
2504          if (responseHandler) {
2505            responseHandler.reject(new Error("The received response has neither a result nor an error property."));
2506          }
2507        }
2508      }
2509      function stringifyTrace(params) {
2510        if (params === void 0 || params === null) {
2511          return void 0;
2512        }
2513        switch (trace) {
2514          case Trace.Verbose:
2515            return JSON.stringify(params, null, 4);
2516          case Trace.Compact:
2517            return JSON.stringify(params);
2518          default:
2519            return void 0;
2520        }
2521      }
2522      function traceSendingRequest(message) {
2523        if (trace === Trace.Off || !tracer) {
2524          return;
2525        }
2526        if (traceFormat === TraceFormat.Text) {
2527          let data = void 0;
2528          if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
2529            data = `Params: ${stringifyTrace(message.params)}
2530
2531`;
2532          }
2533          tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
2534        } else {
2535          logLSPMessage("send-request", message);
2536        }
2537      }
2538      function traceSendingNotification(message) {
2539        if (trace === Trace.Off || !tracer) {
2540          return;
2541        }
2542        if (traceFormat === TraceFormat.Text) {
2543          let data = void 0;
2544          if (trace === Trace.Verbose || trace === Trace.Compact) {
2545            if (message.params) {
2546              data = `Params: ${stringifyTrace(message.params)}
2547
2548`;
2549            } else {
2550              data = "No parameters provided.\n\n";
2551            }
2552          }
2553          tracer.log(`Sending notification '${message.method}'.`, data);
2554        } else {
2555          logLSPMessage("send-notification", message);
2556        }
2557      }
2558      function traceSendingResponse(message, method, startTime) {
2559        if (trace === Trace.Off || !tracer) {
2560          return;
2561        }
2562        if (traceFormat === TraceFormat.Text) {
2563          let data = void 0;
2564          if (trace === Trace.Verbose || trace === Trace.Compact) {
2565            if (message.error && message.error.data) {
2566              data = `Error data: ${stringifyTrace(message.error.data)}
2567
2568`;
2569            } else {
2570              if (message.result) {
2571                data = `Result: ${stringifyTrace(message.result)}
2572
2573`;
2574              } else if (message.error === void 0) {
2575                data = "No result returned.\n\n";
2576              }
2577            }
2578          }
2579          tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
2580        } else {
2581          logLSPMessage("send-response", message);
2582        }
2583      }
2584      function traceReceivedRequest(message) {
2585        if (trace === Trace.Off || !tracer) {
2586          return;
2587        }
2588        if (traceFormat === TraceFormat.Text) {
2589          let data = void 0;
2590          if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
2591            data = `Params: ${stringifyTrace(message.params)}
2592
2593`;
2594          }
2595          tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
2596        } else {
2597          logLSPMessage("receive-request", message);
2598        }
2599      }
2600      function traceReceivedNotification(message) {
2601        if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
2602          return;
2603        }
2604        if (traceFormat === TraceFormat.Text) {
2605          let data = void 0;
2606          if (trace === Trace.Verbose || trace === Trace.Compact) {
2607            if (message.params) {
2608              data = `Params: ${stringifyTrace(message.params)}
2609
2610`;
2611            } else {
2612              data = "No parameters provided.\n\n";
2613            }
2614          }
2615          tracer.log(`Received notification '${message.method}'.`, data);
2616        } else {
2617          logLSPMessage("receive-notification", message);
2618        }
2619      }
2620      function traceReceivedResponse(message, responsePromise) {
2621        if (trace === Trace.Off || !tracer) {
2622          return;
2623        }
2624        if (traceFormat === TraceFormat.Text) {
2625          let data = void 0;
2626          if (trace === Trace.Verbose || trace === Trace.Compact) {
2627            if (message.error && message.error.data) {
2628              data = `Error data: ${stringifyTrace(message.error.data)}
2629
2630`;
2631            } else {
2632              if (message.result) {
2633                data = `Result: ${stringifyTrace(message.result)}
2634
2635`;
2636              } else if (message.error === void 0) {
2637                data = "No result returned.\n\n";
2638              }
2639            }
2640          }
2641          if (responsePromise) {
2642            const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
2643            tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
2644          } else {
2645            tracer.log(`Received response ${message.id} without active response promise.`, data);
2646          }
2647        } else {
2648          logLSPMessage("receive-response", message);
2649        }
2650      }
2651      function logLSPMessage(type, message) {
2652        if (!tracer || trace === Trace.Off) {
2653          return;
2654        }
2655        const lspMessage = {
2656          isLSPMessage: true,
2657          type,
2658          message,
2659          timestamp: Date.now()
2660        };
2661        tracer.log(lspMessage);
2662      }
2663      function throwIfClosedOrDisposed() {
2664        if (isClosed()) {
2665          throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
2666        }
2667        if (isDisposed()) {
2668          throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
2669        }
2670      }
2671      function throwIfListening() {
2672        if (isListening()) {
2673          throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
2674        }
2675      }
2676      function throwIfNotListening() {
2677        if (!isListening()) {
2678          throw new Error("Call listen() first.");
2679        }
2680      }
2681      function undefinedToNull(param) {
2682        if (param === void 0) {
2683          return null;
2684        } else {
2685          return param;
2686        }
2687      }
2688      function nullToUndefined(param) {
2689        if (param === null) {
2690          return void 0;
2691        } else {
2692          return param;
2693        }
2694      }
2695      function isNamedParam(param) {
2696        return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
2697      }
2698      function computeSingleParam(parameterStructures, param) {
2699        switch (parameterStructures) {
2700          case messages_1.ParameterStructures.auto:
2701            if (isNamedParam(param)) {
2702              return nullToUndefined(param);
2703            } else {
2704              return [undefinedToNull(param)];
2705            }
2706          case messages_1.ParameterStructures.byName:
2707            if (!isNamedParam(param)) {
2708              throw new Error(`Received parameters by name but param is not an object literal.`);
2709            }
2710            return nullToUndefined(param);
2711          case messages_1.ParameterStructures.byPosition:
2712            return [undefinedToNull(param)];
2713          default:
2714            throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
2715        }
2716      }
2717      function computeMessageParams(type, params) {
2718        let result;
2719        const numberOfParams = type.numberOfParams;
2720        switch (numberOfParams) {
2721          case 0:
2722            result = void 0;
2723            break;
2724          case 1:
2725            result = computeSingleParam(type.parameterStructures, params[0]);
2726            break;
2727          default:
2728            result = [];
2729            for (let i2 = 0; i2 < params.length && i2 < numberOfParams; i2++) {
2730              result.push(undefinedToNull(params[i2]));
2731            }
2732            if (params.length < numberOfParams) {
2733              for (let i2 = params.length; i2 < numberOfParams; i2++) {
2734                result.push(null);
2735              }
2736            }
2737            break;
2738        }
2739        return result;
2740      }
2741      const connection = {
2742        sendNotification: (type, ...args) => {
2743          throwIfClosedOrDisposed();
2744          let method;
2745          let messageParams;
2746          if (Is2.string(type)) {
2747            method = type;
2748            const first = args[0];
2749            let paramStart = 0;
2750            let parameterStructures = messages_1.ParameterStructures.auto;
2751            if (messages_1.ParameterStructures.is(first)) {
2752              paramStart = 1;
2753              parameterStructures = first;
2754            }
2755            let paramEnd = args.length;
2756            const numberOfParams = paramEnd - paramStart;
2757            switch (numberOfParams) {
2758              case 0:
2759                messageParams = void 0;
2760                break;
2761              case 1:
2762                messageParams = computeSingleParam(parameterStructures, args[paramStart]);
2763                break;
2764              default:
2765                if (parameterStructures === messages_1.ParameterStructures.byName) {
2766                  throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
2767                }
2768                messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
2769                break;
2770            }
2771          } else {
2772            const params = args;
2773            method = type.method;
2774            messageParams = computeMessageParams(type, params);
2775          }
2776          const notificationMessage = {
2777            jsonrpc: version,
2778            method,
2779            params: messageParams
2780          };
2781          traceSendingNotification(notificationMessage);
2782          return messageWriter.write(notificationMessage).catch((error) => {
2783            logger.error(`Sending notification failed.`);
2784            throw error;
2785          });
2786        },
2787        onNotification: (type, handler) => {
2788          throwIfClosedOrDisposed();
2789          let method;
2790          if (Is2.func(type)) {
2791            starNotificationHandler = type;
2792          } else if (handler) {
2793            if (Is2.string(type)) {
2794              method = type;
2795              notificationHandlers.set(type, { type: void 0, handler });
2796            } else {
2797              method = type.method;
2798              notificationHandlers.set(type.method, { type, handler });
2799            }
2800          }
2801          return {
2802            dispose: () => {
2803              if (method !== void 0) {
2804                notificationHandlers.delete(method);
2805              } else {
2806                starNotificationHandler = void 0;
2807              }
2808            }
2809          };
2810        },
2811        onProgress: (_type, token, handler) => {
2812          if (progressHandlers.has(token)) {
2813            throw new Error(`Progress handler for token ${token} already registered`);
2814          }
2815          progressHandlers.set(token, handler);
2816          return {
2817            dispose: () => {
2818              progressHandlers.delete(token);
2819            }
2820          };
2821        },
2822        sendProgress: (_type, token, value) => {
2823          return connection.sendNotification(ProgressNotification.type, { token, value });
2824        },
2825        onUnhandledProgress: unhandledProgressEmitter.event,
2826        sendRequest: (type, ...args) => {
2827          throwIfClosedOrDisposed();
2828          throwIfNotListening();
2829          let method;
2830          let messageParams;
2831          let token = void 0;
2832          if (Is2.string(type)) {
2833            method = type;
2834            const first = args[0];
2835            const last = args[args.length - 1];
2836            let paramStart = 0;
2837            let parameterStructures = messages_1.ParameterStructures.auto;
2838            if (messages_1.ParameterStructures.is(first)) {
2839              paramStart = 1;
2840              parameterStructures = first;
2841            }
2842            let paramEnd = args.length;
2843            if (cancellation_1.CancellationToken.is(last)) {
2844              paramEnd = paramEnd - 1;
2845              token = last;
2846            }
2847            const numberOfParams = paramEnd - paramStart;
2848            switch (numberOfParams) {
2849              case 0:
2850                messageParams = void 0;
2851                break;
2852              case 1:
2853                messageParams = computeSingleParam(parameterStructures, args[paramStart]);
2854                break;
2855              default:
2856                if (parameterStructures === messages_1.ParameterStructures.byName) {
2857                  throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
2858                }
2859                messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
2860                break;
2861            }
2862          } else {
2863            const params = args;
2864            method = type.method;
2865            messageParams = computeMessageParams(type, params);
2866            const numberOfParams = type.numberOfParams;
2867            token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : void 0;
2868          }
2869          const id2 = sequenceNumber++;
2870          let disposable;
2871          if (token) {
2872            disposable = token.onCancellationRequested(() => {
2873              const p2 = cancellationStrategy.sender.sendCancellation(connection, id2);
2874              if (p2 === void 0) {
2875                logger.log(`Received no promise from cancellation strategy when cancelling id ${id2}`);
2876                return Promise.resolve();
2877              } else {
2878                return p2.catch(() => {
2879                  logger.log(`Sending cancellation messages for id ${id2} failed`);
2880                });
2881              }
2882            });
2883          }
2884          const requestMessage = {
2885            jsonrpc: version,
2886            id: id2,
2887            method,
2888            params: messageParams
2889          };
2890          traceSendingRequest(requestMessage);
2891          if (typeof cancellationStrategy.sender.enableCancellation === "function") {
2892            cancellationStrategy.sender.enableCancellation(requestMessage);
2893          }
2894          return new Promise(async (resolve, reject) => {
2895            const resolveWithCleanup = (r2) => {
2896              resolve(r2);
2897              cancellationStrategy.sender.cleanup(id2);
2898              disposable?.dispose();
2899            };
2900            const rejectWithCleanup = (r2) => {
2901              reject(r2);
2902              cancellationStrategy.sender.cleanup(id2);
2903              disposable?.dispose();
2904            };
2905            const responsePromise = { method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
2906            try {
2907              await messageWriter.write(requestMessage);
2908              responsePromises.set(id2, responsePromise);
2909            } catch (error) {
2910              logger.error(`Sending request failed.`);
2911              responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : "Unknown reason"));
2912              throw error;
2913            }
2914          });
2915        },
2916        onRequest: (type, handler) => {
2917          throwIfClosedOrDisposed();
2918          let method = null;
2919          if (StarRequestHandler.is(type)) {
2920            method = void 0;
2921            starRequestHandler = type;
2922          } else if (Is2.string(type)) {
2923            method = null;
2924            if (handler !== void 0) {
2925              method = type;
2926              requestHandlers.set(type, { handler, type: void 0 });
2927            }
2928          } else {
2929            if (handler !== void 0) {
2930              method = type.method;
2931              requestHandlers.set(type.method, { type, handler });
2932            }
2933          }
2934          return {
2935            dispose: () => {
2936              if (method === null) {
2937                return;
2938              }
2939              if (method !== void 0) {
2940                requestHandlers.delete(method);
2941              } else {
2942                starRequestHandler = void 0;
2943              }
2944            }
2945          };
2946        },
2947        hasPendingResponse: () => {
2948          return responsePromises.size > 0;
2949        },
2950        trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
2951          let _sendNotification = false;
2952          let _traceFormat = TraceFormat.Text;
2953          if (sendNotificationOrTraceOptions !== void 0) {
2954            if (Is2.boolean(sendNotificationOrTraceOptions)) {
2955              _sendNotification = sendNotificationOrTraceOptions;
2956            } else {
2957              _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
2958              _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
2959            }
2960          }
2961          trace = _value;
2962          traceFormat = _traceFormat;
2963          if (trace === Trace.Off) {
2964            tracer = void 0;
2965          } else {
2966            tracer = _tracer;
2967          }
2968          if (_sendNotification && !isClosed() && !isDisposed()) {
2969            await connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
2970          }
2971        },
2972        onError: errorEmitter.event,
2973        onClose: closeEmitter.event,
2974        onUnhandledNotification: unhandledNotificationEmitter.event,
2975        onDispose: disposeEmitter.event,
2976        end: () => {
2977          messageWriter.end();
2978        },
2979        dispose: () => {
2980          if (isDisposed()) {
2981            return;
2982          }
2983          state = ConnectionState.Disposed;
2984          disposeEmitter.fire(void 0);
2985          const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
2986          for (const promise of responsePromises.values()) {
2987            promise.reject(error);
2988          }
2989          responsePromises = /* @__PURE__ */ new Map();
2990          requestTokens = /* @__PURE__ */ new Map();
2991          knownCanceledRequests = /* @__PURE__ */ new Set();
2992          messageQueue = new linkedMap_1.LinkedMap();
2993          if (Is2.func(messageWriter.dispose)) {
2994            messageWriter.dispose();
2995          }
2996          if (Is2.func(messageReader.dispose)) {
2997            messageReader.dispose();
2998          }
2999        },
3000        listen: () => {
3001          throwIfClosedOrDisposed();
3002          throwIfListening();
3003          state = ConnectionState.Listening;
3004          messageReader.listen(callback);
3005        },
3006        inspect: () => {
3007          (0, ral_1.default)().console.log("inspect");
3008        }
3009      };
3010      connection.onNotification(LogTraceNotification.type, (params) => {
3011        if (trace === Trace.Off || !tracer) {
3012          return;
3013        }
3014        const verbose2 = trace === Trace.Verbose || trace === Trace.Compact;
3015        tracer.log(params.message, verbose2 ? params.verbose : void 0);
3016      });
3017      connection.onNotification(ProgressNotification.type, (params) => {
3018        const handler = progressHandlers.get(params.token);
3019        if (handler) {
3020          handler(params.value);
3021        } else {
3022          unhandledProgressEmitter.fire(params);
3023        }
3024      });
3025      return connection;
3026    }
3027    exports.createMessageConnection = createMessageConnection3;
3028  }
3029});
3030