@willh/subtitle-correction-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,4783 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/vscode-jsonrpc/lib/common/is.js
+var require_is = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = undefined;
+  function boolean(value) {
+    return value === true || value === false;
+  }
+  exports.boolean = boolean;
+  function string(value) {
+    return typeof value === "string" || value instanceof String;
+  }
+  exports.string = string;
+  function number(value) {
+    return typeof value === "number" || value instanceof Number;
+  }
+  exports.number = number;
+  function error(value) {
+    return value instanceof Error;
+  }
+  exports.error = error;
+  function func(value) {
+    return typeof value === "function";
+  }
+  exports.func = func;
+  function array(value) {
+    return Array.isArray(value);
+  }
+  exports.array = array;
+  function stringArray(value) {
+    return array(value) && value.every((elem) => string(elem));
+  }
+  exports.stringArray = stringArray;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messages.js
+var require_messages = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  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 = undefined;
+  var is = require_is();
+  var ErrorCodes;
+  (function(ErrorCodes2) {
+    ErrorCodes2.ParseError = -32700;
+    ErrorCodes2.InvalidRequest = -32600;
+    ErrorCodes2.MethodNotFound = -32601;
+    ErrorCodes2.InvalidParams = -32602;
+    ErrorCodes2.InternalError = -32603;
+    ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
+    ErrorCodes2.serverErrorStart = -32099;
+    ErrorCodes2.MessageWriteError = -32099;
+    ErrorCodes2.MessageReadError = -32098;
+    ErrorCodes2.PendingResponseRejected = -32097;
+    ErrorCodes2.ConnectionInactive = -32096;
+    ErrorCodes2.ServerNotInitialized = -32002;
+    ErrorCodes2.UnknownErrorCode = -32001;
+    ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32000;
+    ErrorCodes2.serverErrorEnd = -32000;
+  })(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
+
+  class ResponseError extends Error {
+    constructor(code, message, data) {
+      super(message);
+      this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
+      this.data = data;
+      Object.setPrototypeOf(this, ResponseError.prototype);
+    }
+    toJson() {
+      const result = {
+        code: this.code,
+        message: this.message
+      };
+      if (this.data !== undefined) {
+        result.data = this.data;
+      }
+      return result;
+    }
+  }
+  exports.ResponseError = ResponseError;
+
+  class ParameterStructures {
+    constructor(kind) {
+      this.kind = kind;
+    }
+    static is(value) {
+      return value === ParameterStructures.auto || value === ParameterStructures.byName || value === ParameterStructures.byPosition;
+    }
+    toString() {
+      return this.kind;
+    }
+  }
+  exports.ParameterStructures = ParameterStructures;
+  ParameterStructures.auto = new ParameterStructures("auto");
+  ParameterStructures.byPosition = new ParameterStructures("byPosition");
+  ParameterStructures.byName = new ParameterStructures("byName");
+
+  class AbstractMessageSignature {
+    constructor(method, numberOfParams) {
+      this.method = method;
+      this.numberOfParams = numberOfParams;
+    }
+    get parameterStructures() {
+      return ParameterStructures.auto;
+    }
+  }
+  exports.AbstractMessageSignature = AbstractMessageSignature;
+
+  class RequestType0 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 0);
+    }
+  }
+  exports.RequestType0 = RequestType0;
+
+  class RequestType extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+      super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
+    }
+  }
+  exports.RequestType = RequestType;
+
+  class RequestType1 extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+      super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
+    }
+  }
+  exports.RequestType1 = RequestType1;
+
+  class RequestType2 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 2);
+    }
+  }
+  exports.RequestType2 = RequestType2;
+
+  class RequestType3 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 3);
+    }
+  }
+  exports.RequestType3 = RequestType3;
+
+  class RequestType4 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 4);
+    }
+  }
+  exports.RequestType4 = RequestType4;
+
+  class RequestType5 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 5);
+    }
+  }
+  exports.RequestType5 = RequestType5;
+
+  class RequestType6 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 6);
+    }
+  }
+  exports.RequestType6 = RequestType6;
+
+  class RequestType7 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 7);
+    }
+  }
+  exports.RequestType7 = RequestType7;
+
+  class RequestType8 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 8);
+    }
+  }
+  exports.RequestType8 = RequestType8;
+
+  class RequestType9 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 9);
+    }
+  }
+  exports.RequestType9 = RequestType9;
+
+  class NotificationType extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+      super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
+    }
+  }
+  exports.NotificationType = NotificationType;
+
+  class NotificationType0 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 0);
+    }
+  }
+  exports.NotificationType0 = NotificationType0;
+
+  class NotificationType1 extends AbstractMessageSignature {
+    constructor(method, _parameterStructures = ParameterStructures.auto) {
+      super(method, 1);
+      this._parameterStructures = _parameterStructures;
+    }
+    get parameterStructures() {
+      return this._parameterStructures;
+    }
+  }
+  exports.NotificationType1 = NotificationType1;
+
+  class NotificationType2 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 2);
+    }
+  }
+  exports.NotificationType2 = NotificationType2;
+
+  class NotificationType3 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 3);
+    }
+  }
+  exports.NotificationType3 = NotificationType3;
+
+  class NotificationType4 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 4);
+    }
+  }
+  exports.NotificationType4 = NotificationType4;
+
+  class NotificationType5 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 5);
+    }
+  }
+  exports.NotificationType5 = NotificationType5;
+
+  class NotificationType6 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 6);
+    }
+  }
+  exports.NotificationType6 = NotificationType6;
+
+  class NotificationType7 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 7);
+    }
+  }
+  exports.NotificationType7 = NotificationType7;
+
+  class NotificationType8 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 8);
+    }
+  }
+  exports.NotificationType8 = NotificationType8;
+
+  class NotificationType9 extends AbstractMessageSignature {
+    constructor(method) {
+      super(method, 9);
+    }
+  }
+  exports.NotificationType9 = NotificationType9;
+  var Message;
+  (function(Message2) {
+    function isRequest(message) {
+      const candidate = message;
+      return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
+    }
+    Message2.isRequest = isRequest;
+    function isNotification(message) {
+      const candidate = message;
+      return candidate && is.string(candidate.method) && message.id === undefined;
+    }
+    Message2.isNotification = isNotification;
+    function isResponse(message) {
+      const candidate = message;
+      return candidate && (candidate.result !== undefined || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
+    }
+    Message2.isResponse = isResponse;
+  })(Message || (exports.Message = Message = {}));
+});
+
+// node_modules/vscode-jsonrpc/lib/common/linkedMap.js
+var require_linkedMap = __commonJS((exports) => {
+  var _a;
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LRUCache = exports.LinkedMap = exports.Touch = undefined;
+  var Touch;
+  (function(Touch2) {
+    Touch2.None = 0;
+    Touch2.First = 1;
+    Touch2.AsOld = Touch2.First;
+    Touch2.Last = 2;
+    Touch2.AsNew = Touch2.Last;
+  })(Touch || (exports.Touch = Touch = {}));
+
+  class LinkedMap {
+    constructor() {
+      this[_a] = "LinkedMap";
+      this._map = new Map;
+      this._head = undefined;
+      this._tail = undefined;
+      this._size = 0;
+      this._state = 0;
+    }
+    clear() {
+      this._map.clear();
+      this._head = undefined;
+      this._tail = undefined;
+      this._size = 0;
+      this._state++;
+    }
+    isEmpty() {
+      return !this._head && !this._tail;
+    }
+    get size() {
+      return this._size;
+    }
+    get first() {
+      return this._head?.value;
+    }
+    get last() {
+      return this._tail?.value;
+    }
+    has(key) {
+      return this._map.has(key);
+    }
+    get(key, touch = Touch.None) {
+      const item = this._map.get(key);
+      if (!item) {
+        return;
+      }
+      if (touch !== Touch.None) {
+        this.touch(item, touch);
+      }
+      return item.value;
+    }
+    set(key, value, touch = Touch.None) {
+      let item = this._map.get(key);
+      if (item) {
+        item.value = value;
+        if (touch !== Touch.None) {
+          this.touch(item, touch);
+        }
+      } else {
+        item = { key, value, next: undefined, previous: undefined };
+        switch (touch) {
+          case Touch.None:
+            this.addItemLast(item);
+            break;
+          case Touch.First:
+            this.addItemFirst(item);
+            break;
+          case Touch.Last:
+            this.addItemLast(item);
+            break;
+          default:
+            this.addItemLast(item);
+            break;
+        }
+        this._map.set(key, item);
+        this._size++;
+      }
+      return this;
+    }
+    delete(key) {
+      return !!this.remove(key);
+    }
+    remove(key) {
+      const item = this._map.get(key);
+      if (!item) {
+        return;
+      }
+      this._map.delete(key);
+      this.removeItem(item);
+      this._size--;
+      return item.value;
+    }
+    shift() {
+      if (!this._head && !this._tail) {
+        return;
+      }
+      if (!this._head || !this._tail) {
+        throw new Error("Invalid list");
+      }
+      const item = this._head;
+      this._map.delete(item.key);
+      this.removeItem(item);
+      this._size--;
+      return item.value;
+    }
+    forEach(callbackfn, thisArg) {
+      const state = this._state;
+      let current = this._head;
+      while (current) {
+        if (thisArg) {
+          callbackfn.bind(thisArg)(current.value, current.key, this);
+        } else {
+          callbackfn(current.value, current.key, this);
+        }
+        if (this._state !== state) {
+          throw new Error(`LinkedMap got modified during iteration.`);
+        }
+        current = current.next;
+      }
+    }
+    keys() {
+      const state = this._state;
+      let current = this._head;
+      const iterator = {
+        [Symbol.iterator]: () => {
+          return iterator;
+        },
+        next: () => {
+          if (this._state !== state) {
+            throw new Error(`LinkedMap got modified during iteration.`);
+          }
+          if (current) {
+            const result = { value: current.key, done: false };
+            current = current.next;
+            return result;
+          } else {
+            return { value: undefined, done: true };
+          }
+        }
+      };
+      return iterator;
+    }
+    values() {
+      const state = this._state;
+      let current = this._head;
+      const iterator = {
+        [Symbol.iterator]: () => {
+          return iterator;
+        },
+        next: () => {
+          if (this._state !== state) {
+            throw new Error(`LinkedMap got modified during iteration.`);
+          }
+          if (current) {
+            const result = { value: current.value, done: false };
+            current = current.next;
+            return result;
+          } else {
+            return { value: undefined, done: true };
+          }
+        }
+      };
+      return iterator;
+    }
+    entries() {
+      const state = this._state;
+      let current = this._head;
+      const iterator = {
+        [Symbol.iterator]: () => {
+          return iterator;
+        },
+        next: () => {
+          if (this._state !== state) {
+            throw new Error(`LinkedMap got modified during iteration.`);
+          }
+          if (current) {
+            const result = { value: [current.key, current.value], done: false };
+            current = current.next;
+            return result;
+          } else {
+            return { value: undefined, done: true };
+          }
+        }
+      };
+      return iterator;
+    }
+    [(_a = Symbol.toStringTag, Symbol.iterator)]() {
+      return this.entries();
+    }
+    trimOld(newSize) {
+      if (newSize >= this.size) {
+        return;
+      }
+      if (newSize === 0) {
+        this.clear();
+        return;
+      }
+      let current = this._head;
+      let currentSize = this.size;
+      while (current && currentSize > newSize) {
+        this._map.delete(current.key);
+        current = current.next;
+        currentSize--;
+      }
+      this._head = current;
+      this._size = currentSize;
+      if (current) {
+        current.previous = undefined;
+      }
+      this._state++;
+    }
+    addItemFirst(item) {
+      if (!this._head && !this._tail) {
+        this._tail = item;
+      } else if (!this._head) {
+        throw new Error("Invalid list");
+      } else {
+        item.next = this._head;
+        this._head.previous = item;
+      }
+      this._head = item;
+      this._state++;
+    }
+    addItemLast(item) {
+      if (!this._head && !this._tail) {
+        this._head = item;
+      } else if (!this._tail) {
+        throw new Error("Invalid list");
+      } else {
+        item.previous = this._tail;
+        this._tail.next = item;
+      }
+      this._tail = item;
+      this._state++;
+    }
+    removeItem(item) {
+      if (item === this._head && item === this._tail) {
+        this._head = undefined;
+        this._tail = undefined;
+      } else if (item === this._head) {
+        if (!item.next) {
+          throw new Error("Invalid list");
+        }
+        item.next.previous = undefined;
+        this._head = item.next;
+      } else if (item === this._tail) {
+        if (!item.previous) {
+          throw new Error("Invalid list");
+        }
+        item.previous.next = undefined;
+        this._tail = item.previous;
+      } else {
+        const next = item.next;
+        const previous = item.previous;
+        if (!next || !previous) {
+          throw new Error("Invalid list");
+        }
+        next.previous = previous;
+        previous.next = next;
+      }
+      item.next = undefined;
+      item.previous = undefined;
+      this._state++;
+    }
+    touch(item, touch) {
+      if (!this._head || !this._tail) {
+        throw new Error("Invalid list");
+      }
+      if (touch !== Touch.First && touch !== Touch.Last) {
+        return;
+      }
+      if (touch === Touch.First) {
+        if (item === this._head) {
+          return;
+        }
+        const next = item.next;
+        const previous = item.previous;
+        if (item === this._tail) {
+          previous.next = undefined;
+          this._tail = previous;
+        } else {
+          next.previous = previous;
+          previous.next = next;
+        }
+        item.previous = undefined;
+        item.next = this._head;
+        this._head.previous = item;
+        this._head = item;
+        this._state++;
+      } else if (touch === Touch.Last) {
+        if (item === this._tail) {
+          return;
+        }
+        const next = item.next;
+        const previous = item.previous;
+        if (item === this._head) {
+          next.previous = undefined;
+          this._head = next;
+        } else {
+          next.previous = previous;
+          previous.next = next;
+        }
+        item.next = undefined;
+        item.previous = this._tail;
+        this._tail.next = item;
+        this._tail = item;
+        this._state++;
+      }
+    }
+    toJSON() {
+      const data = [];
+      this.forEach((value, key) => {
+        data.push([key, value]);
+      });
+      return data;
+    }
+    fromJSON(data) {
+      this.clear();
+      for (const [key, value] of data) {
+        this.set(key, value);
+      }
+    }
+  }
+  exports.LinkedMap = LinkedMap;
+
+  class LRUCache extends LinkedMap {
+    constructor(limit, ratio = 1) {
+      super();
+      this._limit = limit;
+      this._ratio = Math.min(Math.max(0, ratio), 1);
+    }
+    get limit() {
+      return this._limit;
+    }
+    set limit(limit) {
+      this._limit = limit;
+      this.checkTrim();
+    }
+    get ratio() {
+      return this._ratio;
+    }
+    set ratio(ratio) {
+      this._ratio = Math.min(Math.max(0, ratio), 1);
+      this.checkTrim();
+    }
+    get(key, touch = Touch.AsNew) {
+      return super.get(key, touch);
+    }
+    peek(key) {
+      return super.get(key, Touch.None);
+    }
+    set(key, value) {
+      super.set(key, value, Touch.Last);
+      this.checkTrim();
+      return this;
+    }
+    checkTrim() {
+      if (this.size > this._limit) {
+        this.trimOld(Math.round(this._limit * this._ratio));
+      }
+    }
+  }
+  exports.LRUCache = LRUCache;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/disposable.js
+var require_disposable = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Disposable = undefined;
+  var Disposable;
+  (function(Disposable2) {
+    function create(func) {
+      return {
+        dispose: func
+      };
+    }
+    Disposable2.create = create;
+  })(Disposable || (exports.Disposable = Disposable = {}));
+});
+
+// node_modules/vscode-jsonrpc/lib/common/ral.js
+var require_ral = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var _ral;
+  function RAL() {
+    if (_ral === undefined) {
+      throw new Error(`No runtime abstraction layer installed`);
+    }
+    return _ral;
+  }
+  (function(RAL2) {
+    function install(ral) {
+      if (ral === undefined) {
+        throw new Error(`No runtime abstraction layer provided`);
+      }
+      _ral = ral;
+    }
+    RAL2.install = install;
+  })(RAL || (RAL = {}));
+  exports.default = RAL;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/events.js
+var require_events = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Emitter = exports.Event = undefined;
+  var ral_1 = require_ral();
+  var Event;
+  (function(Event2) {
+    const _disposable = { dispose() {} };
+    Event2.None = function() {
+      return _disposable;
+    };
+  })(Event || (exports.Event = Event = {}));
+
+  class CallbackList {
+    add(callback, context = null, bucket) {
+      if (!this._callbacks) {
+        this._callbacks = [];
+        this._contexts = [];
+      }
+      this._callbacks.push(callback);
+      this._contexts.push(context);
+      if (Array.isArray(bucket)) {
+        bucket.push({ dispose: () => this.remove(callback, context) });
+      }
+    }
+    remove(callback, context = null) {
+      if (!this._callbacks) {
+        return;
+      }
+      let foundCallbackWithDifferentContext = false;
+      for (let i = 0, len = this._callbacks.length;i < len; i++) {
+        if (this._callbacks[i] === callback) {
+          if (this._contexts[i] === context) {
+            this._callbacks.splice(i, 1);
+            this._contexts.splice(i, 1);
+            return;
+          } else {
+            foundCallbackWithDifferentContext = true;
+          }
+        }
+      }
+      if (foundCallbackWithDifferentContext) {
+        throw new Error("When adding a listener with a context, you should remove it with the same context");
+      }
+    }
+    invoke(...args) {
+      if (!this._callbacks) {
+        return [];
+      }
+      const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+      for (let i = 0, len = callbacks.length;i < len; i++) {
+        try {
+          ret.push(callbacks[i].apply(contexts[i], args));
+        } catch (e) {
+          (0, ral_1.default)().console.error(e);
+        }
+      }
+      return ret;
+    }
+    isEmpty() {
+      return !this._callbacks || this._callbacks.length === 0;
+    }
+    dispose() {
+      this._callbacks = undefined;
+      this._contexts = undefined;
+    }
+  }
+
+  class Emitter {
+    constructor(_options) {
+      this._options = _options;
+    }
+    get event() {
+      if (!this._event) {
+        this._event = (listener, thisArgs, disposables) => {
+          if (!this._callbacks) {
+            this._callbacks = new CallbackList;
+          }
+          if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+            this._options.onFirstListenerAdd(this);
+          }
+          this._callbacks.add(listener, thisArgs);
+          const result = {
+            dispose: () => {
+              if (!this._callbacks) {
+                return;
+              }
+              this._callbacks.remove(listener, thisArgs);
+              result.dispose = Emitter._noop;
+              if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
+                this._options.onLastListenerRemove(this);
+              }
+            }
+          };
+          if (Array.isArray(disposables)) {
+            disposables.push(result);
+          }
+          return result;
+        };
+      }
+      return this._event;
+    }
+    fire(event) {
+      if (this._callbacks) {
+        this._callbacks.invoke.call(this._callbacks, event);
+      }
+    }
+    dispose() {
+      if (this._callbacks) {
+        this._callbacks.dispose();
+        this._callbacks = undefined;
+      }
+    }
+  }
+  exports.Emitter = Emitter;
+  Emitter._noop = function() {};
+});
+
+// node_modules/vscode-jsonrpc/lib/common/cancellation.js
+var require_cancellation = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.CancellationTokenSource = exports.CancellationToken = undefined;
+  var ral_1 = require_ral();
+  var Is = require_is();
+  var events_1 = require_events();
+  var CancellationToken;
+  (function(CancellationToken2) {
+    CancellationToken2.None = Object.freeze({
+      isCancellationRequested: false,
+      onCancellationRequested: events_1.Event.None
+    });
+    CancellationToken2.Cancelled = Object.freeze({
+      isCancellationRequested: true,
+      onCancellationRequested: events_1.Event.None
+    });
+    function is(value) {
+      const candidate = value;
+      return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
+    }
+    CancellationToken2.is = is;
+  })(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
+  var shortcutEvent = Object.freeze(function(callback, context) {
+    const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
+    return { dispose() {
+      handle.dispose();
+    } };
+  });
+
+  class MutableToken {
+    constructor() {
+      this._isCancelled = false;
+    }
+    cancel() {
+      if (!this._isCancelled) {
+        this._isCancelled = true;
+        if (this._emitter) {
+          this._emitter.fire(undefined);
+          this.dispose();
+        }
+      }
+    }
+    get isCancellationRequested() {
+      return this._isCancelled;
+    }
+    get onCancellationRequested() {
+      if (this._isCancelled) {
+        return shortcutEvent;
+      }
+      if (!this._emitter) {
+        this._emitter = new events_1.Emitter;
+      }
+      return this._emitter.event;
+    }
+    dispose() {
+      if (this._emitter) {
+        this._emitter.dispose();
+        this._emitter = undefined;
+      }
+    }
+  }
+
+  class CancellationTokenSource {
+    get token() {
+      if (!this._token) {
+        this._token = new MutableToken;
+      }
+      return this._token;
+    }
+    cancel() {
+      if (!this._token) {
+        this._token = CancellationToken.Cancelled;
+      } else {
+        this._token.cancel();
+      }
+    }
+    dispose() {
+      if (!this._token) {
+        this._token = CancellationToken.None;
+      } else if (this._token instanceof MutableToken) {
+        this._token.dispose();
+      }
+    }
+  }
+  exports.CancellationTokenSource = CancellationTokenSource;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js
+var require_sharedArrayCancellation = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = undefined;
+  var cancellation_1 = require_cancellation();
+  var CancellationState;
+  (function(CancellationState2) {
+    CancellationState2.Continue = 0;
+    CancellationState2.Cancelled = 1;
+  })(CancellationState || (CancellationState = {}));
+
+  class SharedArraySenderStrategy {
+    constructor() {
+      this.buffers = new Map;
+    }
+    enableCancellation(request) {
+      if (request.id === null) {
+        return;
+      }
+      const buffer = new SharedArrayBuffer(4);
+      const data = new Int32Array(buffer, 0, 1);
+      data[0] = CancellationState.Continue;
+      this.buffers.set(request.id, buffer);
+      request.$cancellationData = buffer;
+    }
+    async sendCancellation(_conn, id) {
+      const buffer = this.buffers.get(id);
+      if (buffer === undefined) {
+        return;
+      }
+      const data = new Int32Array(buffer, 0, 1);
+      Atomics.store(data, 0, CancellationState.Cancelled);
+    }
+    cleanup(id) {
+      this.buffers.delete(id);
+    }
+    dispose() {
+      this.buffers.clear();
+    }
+  }
+  exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
+
+  class SharedArrayBufferCancellationToken {
+    constructor(buffer) {
+      this.data = new Int32Array(buffer, 0, 1);
+    }
+    get isCancellationRequested() {
+      return Atomics.load(this.data, 0) === CancellationState.Cancelled;
+    }
+    get onCancellationRequested() {
+      throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
+    }
+  }
+
+  class SharedArrayBufferCancellationTokenSource {
+    constructor(buffer) {
+      this.token = new SharedArrayBufferCancellationToken(buffer);
+    }
+    cancel() {}
+    dispose() {}
+  }
+
+  class SharedArrayReceiverStrategy {
+    constructor() {
+      this.kind = "request";
+    }
+    createCancellationTokenSource(request) {
+      const buffer = request.$cancellationData;
+      if (buffer === undefined) {
+        return new cancellation_1.CancellationTokenSource;
+      }
+      return new SharedArrayBufferCancellationTokenSource(buffer);
+    }
+  }
+  exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/semaphore.js
+var require_semaphore = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Semaphore = undefined;
+  var ral_1 = require_ral();
+
+  class Semaphore {
+    constructor(capacity = 1) {
+      if (capacity <= 0) {
+        throw new Error("Capacity must be greater than 0");
+      }
+      this._capacity = capacity;
+      this._active = 0;
+      this._waiting = [];
+    }
+    lock(thunk) {
+      return new Promise((resolve, reject) => {
+        this._waiting.push({ thunk, resolve, reject });
+        this.runNext();
+      });
+    }
+    get active() {
+      return this._active;
+    }
+    runNext() {
+      if (this._waiting.length === 0 || this._active === this._capacity) {
+        return;
+      }
+      (0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
+    }
+    doRunNext() {
+      if (this._waiting.length === 0 || this._active === this._capacity) {
+        return;
+      }
+      const next = this._waiting.shift();
+      this._active++;
+      if (this._active > this._capacity) {
+        throw new Error(`To many thunks active`);
+      }
+      try {
+        const result = next.thunk();
+        if (result instanceof Promise) {
+          result.then((value) => {
+            this._active--;
+            next.resolve(value);
+            this.runNext();
+          }, (err) => {
+            this._active--;
+            next.reject(err);
+            this.runNext();
+          });
+        } else {
+          this._active--;
+          next.resolve(result);
+          this.runNext();
+        }
+      } catch (err) {
+        this._active--;
+        next.reject(err);
+        this.runNext();
+      }
+    }
+  }
+  exports.Semaphore = Semaphore;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageReader.js
+var require_messageReader = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = undefined;
+  var ral_1 = require_ral();
+  var Is = require_is();
+  var events_1 = require_events();
+  var semaphore_1 = require_semaphore();
+  var MessageReader;
+  (function(MessageReader2) {
+    function is(value) {
+      let candidate = value;
+      return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) && Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
+    }
+    MessageReader2.is = is;
+  })(MessageReader || (exports.MessageReader = MessageReader = {}));
+
+  class AbstractMessageReader {
+    constructor() {
+      this.errorEmitter = new events_1.Emitter;
+      this.closeEmitter = new events_1.Emitter;
+      this.partialMessageEmitter = new events_1.Emitter;
+    }
+    dispose() {
+      this.errorEmitter.dispose();
+      this.closeEmitter.dispose();
+    }
+    get onError() {
+      return this.errorEmitter.event;
+    }
+    fireError(error) {
+      this.errorEmitter.fire(this.asError(error));
+    }
+    get onClose() {
+      return this.closeEmitter.event;
+    }
+    fireClose() {
+      this.closeEmitter.fire(undefined);
+    }
+    get onPartialMessage() {
+      return this.partialMessageEmitter.event;
+    }
+    firePartialMessage(info) {
+      this.partialMessageEmitter.fire(info);
+    }
+    asError(error) {
+      if (error instanceof Error) {
+        return error;
+      } else {
+        return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
+      }
+    }
+  }
+  exports.AbstractMessageReader = AbstractMessageReader;
+  var ResolvedMessageReaderOptions;
+  (function(ResolvedMessageReaderOptions2) {
+    function fromOptions(options) {
+      let charset;
+      let result;
+      let contentDecoder;
+      const contentDecoders = new Map;
+      let contentTypeDecoder;
+      const contentTypeDecoders = new Map;
+      if (options === undefined || typeof options === "string") {
+        charset = options ?? "utf-8";
+      } else {
+        charset = options.charset ?? "utf-8";
+        if (options.contentDecoder !== undefined) {
+          contentDecoder = options.contentDecoder;
+          contentDecoders.set(contentDecoder.name, contentDecoder);
+        }
+        if (options.contentDecoders !== undefined) {
+          for (const decoder of options.contentDecoders) {
+            contentDecoders.set(decoder.name, decoder);
+          }
+        }
+        if (options.contentTypeDecoder !== undefined) {
+          contentTypeDecoder = options.contentTypeDecoder;
+          contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+        }
+        if (options.contentTypeDecoders !== undefined) {
+          for (const decoder of options.contentTypeDecoders) {
+            contentTypeDecoders.set(decoder.name, decoder);
+          }
+        }
+      }
+      if (contentTypeDecoder === undefined) {
+        contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
+        contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+      }
+      return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
+    }
+    ResolvedMessageReaderOptions2.fromOptions = fromOptions;
+  })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
+
+  class ReadableStreamMessageReader extends AbstractMessageReader {
+    constructor(readable, options) {
+      super();
+      this.readable = readable;
+      this.options = ResolvedMessageReaderOptions.fromOptions(options);
+      this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
+      this._partialMessageTimeout = 1e4;
+      this.nextMessageLength = -1;
+      this.messageToken = 0;
+      this.readSemaphore = new semaphore_1.Semaphore(1);
+    }
+    set partialMessageTimeout(timeout) {
+      this._partialMessageTimeout = timeout;
+    }
+    get partialMessageTimeout() {
+      return this._partialMessageTimeout;
+    }
+    listen(callback) {
+      this.nextMessageLength = -1;
+      this.messageToken = 0;
+      this.partialMessageTimer = undefined;
+      this.callback = callback;
+      const result = this.readable.onData((data) => {
+        this.onData(data);
+      });
+      this.readable.onError((error) => this.fireError(error));
+      this.readable.onClose(() => this.fireClose());
+      return result;
+    }
+    onData(data) {
+      try {
+        this.buffer.append(data);
+        while (true) {
+          if (this.nextMessageLength === -1) {
+            const headers = this.buffer.tryReadHeaders(true);
+            if (!headers) {
+              return;
+            }
+            const contentLength = headers.get("content-length");
+            if (!contentLength) {
+              this.fireError(new Error(`Header must provide a Content-Length property.
+${JSON.stringify(Object.fromEntries(headers))}`));
+              return;
+            }
+            const length = parseInt(contentLength);
+            if (isNaN(length)) {
+              this.fireError(new Error(`Content-Length value must be a number. Got ${contentLength}`));
+              return;
+            }
+            this.nextMessageLength = length;
+          }
+          const body = this.buffer.tryReadBody(this.nextMessageLength);
+          if (body === undefined) {
+            this.setPartialMessageTimer();
+            return;
+          }
+          this.clearPartialMessageTimer();
+          this.nextMessageLength = -1;
+          this.readSemaphore.lock(async () => {
+            const bytes = this.options.contentDecoder !== undefined ? await this.options.contentDecoder.decode(body) : body;
+            const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
+            this.callback(message);
+          }).catch((error) => {
+            this.fireError(error);
+          });
+        }
+      } catch (error) {
+        this.fireError(error);
+      }
+    }
+    clearPartialMessageTimer() {
+      if (this.partialMessageTimer) {
+        this.partialMessageTimer.dispose();
+        this.partialMessageTimer = undefined;
+      }
+    }
+    setPartialMessageTimer() {
+      this.clearPartialMessageTimer();
+      if (this._partialMessageTimeout <= 0) {
+        return;
+      }
+      this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
+        this.partialMessageTimer = undefined;
+        if (token === this.messageToken) {
+          this.firePartialMessage({ messageToken: token, waitingTime: timeout });
+          this.setPartialMessageTimer();
+        }
+      }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
+    }
+  }
+  exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageWriter.js
+var require_messageWriter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = undefined;
+  var ral_1 = require_ral();
+  var Is = require_is();
+  var semaphore_1 = require_semaphore();
+  var events_1 = require_events();
+  var ContentLength = "Content-Length: ";
+  var CRLF = `\r
+`;
+  var MessageWriter;
+  (function(MessageWriter2) {
+    function is(value) {
+      let candidate = value;
+      return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) && Is.func(candidate.onError) && Is.func(candidate.write);
+    }
+    MessageWriter2.is = is;
+  })(MessageWriter || (exports.MessageWriter = MessageWriter = {}));
+
+  class AbstractMessageWriter {
+    constructor() {
+      this.errorEmitter = new events_1.Emitter;
+      this.closeEmitter = new events_1.Emitter;
+    }
+    dispose() {
+      this.errorEmitter.dispose();
+      this.closeEmitter.dispose();
+    }
+    get onError() {
+      return this.errorEmitter.event;
+    }
+    fireError(error, message, count) {
+      this.errorEmitter.fire([this.asError(error), message, count]);
+    }
+    get onClose() {
+      return this.closeEmitter.event;
+    }
+    fireClose() {
+      this.closeEmitter.fire(undefined);
+    }
+    asError(error) {
+      if (error instanceof Error) {
+        return error;
+      } else {
+        return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
+      }
+    }
+  }
+  exports.AbstractMessageWriter = AbstractMessageWriter;
+  var ResolvedMessageWriterOptions;
+  (function(ResolvedMessageWriterOptions2) {
+    function fromOptions(options) {
+      if (options === undefined || typeof options === "string") {
+        return { charset: options ?? "utf-8", contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
+      } else {
+        return { charset: options.charset ?? "utf-8", contentEncoder: options.contentEncoder, contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
+      }
+    }
+    ResolvedMessageWriterOptions2.fromOptions = fromOptions;
+  })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
+
+  class WriteableStreamMessageWriter extends AbstractMessageWriter {
+    constructor(writable, options) {
+      super();
+      this.writable = writable;
+      this.options = ResolvedMessageWriterOptions.fromOptions(options);
+      this.errorCount = 0;
+      this.writeSemaphore = new semaphore_1.Semaphore(1);
+      this.writable.onError((error) => this.fireError(error));
+      this.writable.onClose(() => this.fireClose());
+    }
+    async write(msg) {
+      return this.writeSemaphore.lock(async () => {
+        const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
+          if (this.options.contentEncoder !== undefined) {
+            return this.options.contentEncoder.encode(buffer);
+          } else {
+            return buffer;
+          }
+        });
+        return payload.then((buffer) => {
+          const headers = [];
+          headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
+          headers.push(CRLF);
+          return this.doWrite(msg, headers, buffer);
+        }, (error) => {
+          this.fireError(error);
+          throw error;
+        });
+      });
+    }
+    async doWrite(msg, headers, data) {
+      try {
+        await this.writable.write(headers.join(""), "ascii");
+        return this.writable.write(data);
+      } catch (error) {
+        this.handleError(error, msg);
+        return Promise.reject(error);
+      }
+    }
+    handleError(error, msg) {
+      this.errorCount++;
+      this.fireError(error, msg, this.errorCount);
+    }
+    end() {
+      this.writable.end();
+    }
+  }
+  exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
+var require_messageBuffer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AbstractMessageBuffer = undefined;
+  var CR = 13;
+  var LF = 10;
+  var CRLF = `\r
+`;
+
+  class AbstractMessageBuffer {
+    constructor(encoding = "utf-8") {
+      this._encoding = encoding;
+      this._chunks = [];
+      this._totalLength = 0;
+    }
+    get encoding() {
+      return this._encoding;
+    }
+    append(chunk) {
+      const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
+      this._chunks.push(toAppend);
+      this._totalLength += toAppend.byteLength;
+    }
+    tryReadHeaders(lowerCaseKeys = false) {
+      if (this._chunks.length === 0) {
+        return;
+      }
+      let state = 0;
+      let chunkIndex = 0;
+      let offset = 0;
+      let chunkBytesRead = 0;
+      row:
+        while (chunkIndex < this._chunks.length) {
+          const chunk = this._chunks[chunkIndex];
+          offset = 0;
+          column:
+            while (offset < chunk.length) {
+              const value = chunk[offset];
+              switch (value) {
+                case CR:
+                  switch (state) {
+                    case 0:
+                      state = 1;
+                      break;
+                    case 2:
+                      state = 3;
+                      break;
+                    default:
+                      state = 0;
+                  }
+                  break;
+                case LF:
+                  switch (state) {
+                    case 1:
+                      state = 2;
+                      break;
+                    case 3:
+                      state = 4;
+                      offset++;
+                      break row;
+                    default:
+                      state = 0;
+                  }
+                  break;
+                default:
+                  state = 0;
+              }
+              offset++;
+            }
+          chunkBytesRead += chunk.byteLength;
+          chunkIndex++;
+        }
+      if (state !== 4) {
+        return;
+      }
+      const buffer = this._read(chunkBytesRead + offset);
+      const result = new Map;
+      const headers = this.toString(buffer, "ascii").split(CRLF);
+      if (headers.length < 2) {
+        return result;
+      }
+      for (let i = 0;i < headers.length - 2; i++) {
+        const header = headers[i];
+        const index = header.indexOf(":");
+        if (index === -1) {
+          throw new Error(`Message header must separate key and value using ':'
+${header}`);
+        }
+        const key = header.substr(0, index);
+        const value = header.substr(index + 1).trim();
+        result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
+      }
+      return result;
+    }
+    tryReadBody(length) {
+      if (this._totalLength < length) {
+        return;
+      }
+      return this._read(length);
+    }
+    get numberOfBytes() {
+      return this._totalLength;
+    }
+    _read(byteCount) {
+      if (byteCount === 0) {
+        return this.emptyBuffer();
+      }
+      if (byteCount > this._totalLength) {
+        throw new Error(`Cannot read so many bytes!`);
+      }
+      if (this._chunks[0].byteLength === byteCount) {
+        const chunk = this._chunks[0];
+        this._chunks.shift();
+        this._totalLength -= byteCount;
+        return this.asNative(chunk);
+      }
+      if (this._chunks[0].byteLength > byteCount) {
+        const chunk = this._chunks[0];
+        const result2 = this.asNative(chunk, byteCount);
+        this._chunks[0] = chunk.slice(byteCount);
+        this._totalLength -= byteCount;
+        return result2;
+      }
+      const result = this.allocNative(byteCount);
+      let resultOffset = 0;
+      let chunkIndex = 0;
+      while (byteCount > 0) {
+        const chunk = this._chunks[chunkIndex];
+        if (chunk.byteLength > byteCount) {
+          const chunkPart = chunk.slice(0, byteCount);
+          result.set(chunkPart, resultOffset);
+          resultOffset += byteCount;
+          this._chunks[chunkIndex] = chunk.slice(byteCount);
+          this._totalLength -= byteCount;
+          byteCount -= byteCount;
+        } else {
+          result.set(chunk, resultOffset);
+          resultOffset += chunk.byteLength;
+          this._chunks.shift();
+          this._totalLength -= chunk.byteLength;
+          byteCount -= chunk.byteLength;
+        }
+      }
+      return result;
+    }
+  }
+  exports.AbstractMessageBuffer = AbstractMessageBuffer;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/connection.js
+var require_connection = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  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 = undefined;
+  var ral_1 = require_ral();
+  var Is = require_is();
+  var messages_1 = require_messages();
+  var linkedMap_1 = require_linkedMap();
+  var events_1 = require_events();
+  var cancellation_1 = require_cancellation();
+  var CancelNotification;
+  (function(CancelNotification2) {
+    CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
+  })(CancelNotification || (CancelNotification = {}));
+  var ProgressToken;
+  (function(ProgressToken2) {
+    function is(value) {
+      return typeof value === "string" || typeof value === "number";
+    }
+    ProgressToken2.is = is;
+  })(ProgressToken || (exports.ProgressToken = ProgressToken = {}));
+  var ProgressNotification;
+  (function(ProgressNotification2) {
+    ProgressNotification2.type = new messages_1.NotificationType("$/progress");
+  })(ProgressNotification || (ProgressNotification = {}));
+
+  class ProgressType {
+    constructor() {}
+  }
+  exports.ProgressType = ProgressType;
+  var StarRequestHandler;
+  (function(StarRequestHandler2) {
+    function is(value) {
+      return Is.func(value);
+    }
+    StarRequestHandler2.is = is;
+  })(StarRequestHandler || (StarRequestHandler = {}));
+  exports.NullLogger = Object.freeze({
+    error: () => {},
+    warn: () => {},
+    info: () => {},
+    log: () => {}
+  });
+  var Trace;
+  (function(Trace2) {
+    Trace2[Trace2["Off"] = 0] = "Off";
+    Trace2[Trace2["Messages"] = 1] = "Messages";
+    Trace2[Trace2["Compact"] = 2] = "Compact";
+    Trace2[Trace2["Verbose"] = 3] = "Verbose";
+  })(Trace || (exports.Trace = Trace = {}));
+  var TraceValues;
+  (function(TraceValues2) {
+    TraceValues2.Off = "off";
+    TraceValues2.Messages = "messages";
+    TraceValues2.Compact = "compact";
+    TraceValues2.Verbose = "verbose";
+  })(TraceValues || (exports.TraceValues = TraceValues = {}));
+  (function(Trace2) {
+    function fromString(value) {
+      if (!Is.string(value)) {
+        return Trace2.Off;
+      }
+      value = value.toLowerCase();
+      switch (value) {
+        case "off":
+          return Trace2.Off;
+        case "messages":
+          return Trace2.Messages;
+        case "compact":
+          return Trace2.Compact;
+        case "verbose":
+          return Trace2.Verbose;
+        default:
+          return Trace2.Off;
+      }
+    }
+    Trace2.fromString = fromString;
+    function toString(value) {
+      switch (value) {
+        case Trace2.Off:
+          return "off";
+        case Trace2.Messages:
+          return "messages";
+        case Trace2.Compact:
+          return "compact";
+        case Trace2.Verbose:
+          return "verbose";
+        default:
+          return "off";
+      }
+    }
+    Trace2.toString = toString;
+  })(Trace || (exports.Trace = Trace = {}));
+  var TraceFormat;
+  (function(TraceFormat2) {
+    TraceFormat2["Text"] = "text";
+    TraceFormat2["JSON"] = "json";
+  })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
+  (function(TraceFormat2) {
+    function fromString(value) {
+      if (!Is.string(value)) {
+        return TraceFormat2.Text;
+      }
+      value = value.toLowerCase();
+      if (value === "json") {
+        return TraceFormat2.JSON;
+      } else {
+        return TraceFormat2.Text;
+      }
+    }
+    TraceFormat2.fromString = fromString;
+  })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
+  var SetTraceNotification;
+  (function(SetTraceNotification2) {
+    SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
+  })(SetTraceNotification || (exports.SetTraceNotification = SetTraceNotification = {}));
+  var LogTraceNotification;
+  (function(LogTraceNotification2) {
+    LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
+  })(LogTraceNotification || (exports.LogTraceNotification = LogTraceNotification = {}));
+  var ConnectionErrors;
+  (function(ConnectionErrors2) {
+    ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
+    ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
+    ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
+  })(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
+
+  class ConnectionError extends Error {
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+  }
+  exports.ConnectionError = ConnectionError;
+  var ConnectionStrategy;
+  (function(ConnectionStrategy2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && Is.func(candidate.cancelUndispatched);
+    }
+    ConnectionStrategy2.is = is;
+  })(ConnectionStrategy || (exports.ConnectionStrategy = ConnectionStrategy = {}));
+  var IdCancellationReceiverStrategy;
+  (function(IdCancellationReceiverStrategy2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && (candidate.kind === undefined || candidate.kind === "id") && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === undefined || Is.func(candidate.dispose));
+    }
+    IdCancellationReceiverStrategy2.is = is;
+  })(IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
+  var RequestCancellationReceiverStrategy;
+  (function(RequestCancellationReceiverStrategy2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && candidate.kind === "request" && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === undefined || Is.func(candidate.dispose));
+    }
+    RequestCancellationReceiverStrategy2.is = is;
+  })(RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
+  var CancellationReceiverStrategy;
+  (function(CancellationReceiverStrategy2) {
+    CancellationReceiverStrategy2.Message = Object.freeze({
+      createCancellationTokenSource(_) {
+        return new cancellation_1.CancellationTokenSource;
+      }
+    });
+    function is(value) {
+      return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
+    }
+    CancellationReceiverStrategy2.is = is;
+  })(CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
+  var CancellationSenderStrategy;
+  (function(CancellationSenderStrategy2) {
+    CancellationSenderStrategy2.Message = Object.freeze({
+      sendCancellation(conn, id) {
+        return conn.sendNotification(CancelNotification.type, { id });
+      },
+      cleanup(_) {}
+    });
+    function is(value) {
+      const candidate = value;
+      return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
+    }
+    CancellationSenderStrategy2.is = is;
+  })(CancellationSenderStrategy || (exports.CancellationSenderStrategy = CancellationSenderStrategy = {}));
+  var CancellationStrategy;
+  (function(CancellationStrategy2) {
+    CancellationStrategy2.Message = Object.freeze({
+      receiver: CancellationReceiverStrategy.Message,
+      sender: CancellationSenderStrategy.Message
+    });
+    function is(value) {
+      const candidate = value;
+      return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
+    }
+    CancellationStrategy2.is = is;
+  })(CancellationStrategy || (exports.CancellationStrategy = CancellationStrategy = {}));
+  var MessageStrategy;
+  (function(MessageStrategy2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && Is.func(candidate.handleMessage);
+    }
+    MessageStrategy2.is = is;
+  })(MessageStrategy || (exports.MessageStrategy = MessageStrategy = {}));
+  var ConnectionOptions;
+  (function(ConnectionOptions2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
+    }
+    ConnectionOptions2.is = is;
+  })(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
+  var ConnectionState;
+  (function(ConnectionState2) {
+    ConnectionState2[ConnectionState2["New"] = 1] = "New";
+    ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
+    ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
+    ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
+  })(ConnectionState || (ConnectionState = {}));
+  function createMessageConnection(messageReader, messageWriter, _logger, options) {
+    const logger = _logger !== undefined ? _logger : exports.NullLogger;
+    let sequenceNumber = 0;
+    let notificationSequenceNumber = 0;
+    let unknownResponseSequenceNumber = 0;
+    const version = "2.0";
+    let starRequestHandler = undefined;
+    const requestHandlers = new Map;
+    let starNotificationHandler = undefined;
+    const notificationHandlers = new Map;
+    const progressHandlers = new Map;
+    let timer;
+    let messageQueue = new linkedMap_1.LinkedMap;
+    let responsePromises = new Map;
+    let knownCanceledRequests = new Set;
+    let requestTokens = new Map;
+    let trace = Trace.Off;
+    let traceFormat = TraceFormat.Text;
+    let tracer;
+    let state = ConnectionState.New;
+    const errorEmitter = new events_1.Emitter;
+    const closeEmitter = new events_1.Emitter;
+    const unhandledNotificationEmitter = new events_1.Emitter;
+    const unhandledProgressEmitter = new events_1.Emitter;
+    const disposeEmitter = new events_1.Emitter;
+    const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
+    function createRequestQueueKey(id) {
+      if (id === null) {
+        throw new Error(`Can't send requests with id null since the response can't be correlated.`);
+      }
+      return "req-" + id.toString();
+    }
+    function createResponseQueueKey(id) {
+      if (id === null) {
+        return "res-unknown-" + (++unknownResponseSequenceNumber).toString();
+      } else {
+        return "res-" + id.toString();
+      }
+    }
+    function createNotificationQueueKey() {
+      return "not-" + (++notificationSequenceNumber).toString();
+    }
+    function addMessageToQueue(queue, message) {
+      if (messages_1.Message.isRequest(message)) {
+        queue.set(createRequestQueueKey(message.id), message);
+      } else if (messages_1.Message.isResponse(message)) {
+        queue.set(createResponseQueueKey(message.id), message);
+      } else {
+        queue.set(createNotificationQueueKey(), message);
+      }
+    }
+    function cancelUndispatched(_message) {
+      return;
+    }
+    function isListening() {
+      return state === ConnectionState.Listening;
+    }
+    function isClosed() {
+      return state === ConnectionState.Closed;
+    }
+    function isDisposed() {
+      return state === ConnectionState.Disposed;
+    }
+    function closeHandler() {
+      if (state === ConnectionState.New || state === ConnectionState.Listening) {
+        state = ConnectionState.Closed;
+        closeEmitter.fire(undefined);
+      }
+    }
+    function readErrorHandler(error) {
+      errorEmitter.fire([error, undefined, undefined]);
+    }
+    function writeErrorHandler(data) {
+      errorEmitter.fire(data);
+    }
+    messageReader.onClose(closeHandler);
+    messageReader.onError(readErrorHandler);
+    messageWriter.onClose(closeHandler);
+    messageWriter.onError(writeErrorHandler);
+    function triggerMessageQueue() {
+      if (timer || messageQueue.size === 0) {
+        return;
+      }
+      timer = (0, ral_1.default)().timer.setImmediate(() => {
+        timer = undefined;
+        processMessageQueue();
+      });
+    }
+    function handleMessage(message) {
+      if (messages_1.Message.isRequest(message)) {
+        handleRequest(message);
+      } else if (messages_1.Message.isNotification(message)) {
+        handleNotification(message);
+      } else if (messages_1.Message.isResponse(message)) {
+        handleResponse(message);
+      } else {
+        handleInvalidMessage(message);
+      }
+    }
+    function processMessageQueue() {
+      if (messageQueue.size === 0) {
+        return;
+      }
+      const message = messageQueue.shift();
+      try {
+        const messageStrategy = options?.messageStrategy;
+        if (MessageStrategy.is(messageStrategy)) {
+          messageStrategy.handleMessage(message, handleMessage);
+        } else {
+          handleMessage(message);
+        }
+      } finally {
+        triggerMessageQueue();
+      }
+    }
+    const callback = (message) => {
+      try {
+        if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
+          const cancelId = message.params.id;
+          const key = createRequestQueueKey(cancelId);
+          const toCancel = messageQueue.get(key);
+          if (messages_1.Message.isRequest(toCancel)) {
+            const strategy = options?.connectionStrategy;
+            const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+            if (response && (response.error !== undefined || response.result !== undefined)) {
+              messageQueue.delete(key);
+              requestTokens.delete(cancelId);
+              response.id = toCancel.id;
+              traceSendingResponse(response, message.method, Date.now());
+              messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
+              return;
+            }
+          }
+          const cancellationToken = requestTokens.get(cancelId);
+          if (cancellationToken !== undefined) {
+            cancellationToken.cancel();
+            traceReceivedNotification(message);
+            return;
+          } else {
+            knownCanceledRequests.add(cancelId);
+          }
+        }
+        addMessageToQueue(messageQueue, message);
+      } finally {
+        triggerMessageQueue();
+      }
+    };
+    function handleRequest(requestMessage) {
+      if (isDisposed()) {
+        return;
+      }
+      function reply(resultOrError, method, startTime2) {
+        const message = {
+          jsonrpc: version,
+          id: requestMessage.id
+        };
+        if (resultOrError instanceof messages_1.ResponseError) {
+          message.error = resultOrError.toJson();
+        } else {
+          message.result = resultOrError === undefined ? null : resultOrError;
+        }
+        traceSendingResponse(message, method, startTime2);
+        messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+      }
+      function replyError(error, method, startTime2) {
+        const message = {
+          jsonrpc: version,
+          id: requestMessage.id,
+          error: error.toJson()
+        };
+        traceSendingResponse(message, method, startTime2);
+        messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+      }
+      function replySuccess(result, method, startTime2) {
+        if (result === undefined) {
+          result = null;
+        }
+        const message = {
+          jsonrpc: version,
+          id: requestMessage.id,
+          result
+        };
+        traceSendingResponse(message, method, startTime2);
+        messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+      }
+      traceReceivedRequest(requestMessage);
+      const element = requestHandlers.get(requestMessage.method);
+      let type;
+      let requestHandler;
+      if (element) {
+        type = element.type;
+        requestHandler = element.handler;
+      }
+      const startTime = Date.now();
+      if (requestHandler || starRequestHandler) {
+        const tokenKey = requestMessage.id ?? String(Date.now());
+        const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver) ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey) : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
+        if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
+          cancellationSource.cancel();
+        }
+        if (requestMessage.id !== null) {
+          requestTokens.set(tokenKey, cancellationSource);
+        }
+        try {
+          let handlerResult;
+          if (requestHandler) {
+            if (requestMessage.params === undefined) {
+              if (type !== undefined && type.numberOfParams !== 0) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
+                return;
+              }
+              handlerResult = requestHandler(cancellationSource.token);
+            } else if (Array.isArray(requestMessage.params)) {
+              if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byName) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
+                return;
+              }
+              handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
+            } else {
+              if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
+                return;
+              }
+              handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
+            }
+          } else if (starRequestHandler) {
+            handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
+          }
+          const promise = handlerResult;
+          if (!handlerResult) {
+            requestTokens.delete(tokenKey);
+            replySuccess(handlerResult, requestMessage.method, startTime);
+          } else if (promise.then) {
+            promise.then((resultOrError) => {
+              requestTokens.delete(tokenKey);
+              reply(resultOrError, requestMessage.method, startTime);
+            }, (error) => {
+              requestTokens.delete(tokenKey);
+              if (error instanceof messages_1.ResponseError) {
+                replyError(error, requestMessage.method, startTime);
+              } else if (error && Is.string(error.message)) {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+              } else {
+                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+              }
+            });
+          } else {
+            requestTokens.delete(tokenKey);
+            reply(handlerResult, requestMessage.method, startTime);
+          }
+        } catch (error) {
+          requestTokens.delete(tokenKey);
+          if (error instanceof messages_1.ResponseError) {
+            reply(error, requestMessage.method, startTime);
+          } else if (error && Is.string(error.message)) {
+            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+          } else {
+            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+          }
+        }
+      } else {
+        replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
+      }
+    }
+    function handleResponse(responseMessage) {
+      if (isDisposed()) {
+        return;
+      }
+      if (responseMessage.id === null) {
+        if (responseMessage.error) {
+          logger.error(`Received response message without id: Error is: 
+${JSON.stringify(responseMessage.error, undefined, 4)}`);
+        } else {
+          logger.error(`Received response message without id. No further error information provided.`);
+        }
+      } else {
+        const key = responseMessage.id;
+        const responsePromise = responsePromises.get(key);
+        traceReceivedResponse(responseMessage, responsePromise);
+        if (responsePromise !== undefined) {
+          responsePromises.delete(key);
+          try {
+            if (responseMessage.error) {
+              const error = responseMessage.error;
+              responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
+            } else if (responseMessage.result !== undefined) {
+              responsePromise.resolve(responseMessage.result);
+            } else {
+              throw new Error("Should never happen.");
+            }
+          } catch (error) {
+            if (error.message) {
+              logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
+            } else {
+              logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
+            }
+          }
+        }
+      }
+    }
+    function handleNotification(message) {
+      if (isDisposed()) {
+        return;
+      }
+      let type = undefined;
+      let notificationHandler;
+      if (message.method === CancelNotification.type.method) {
+        const cancelId = message.params.id;
+        knownCanceledRequests.delete(cancelId);
+        traceReceivedNotification(message);
+        return;
+      } else {
+        const element = notificationHandlers.get(message.method);
+        if (element) {
+          notificationHandler = element.handler;
+          type = element.type;
+        }
+      }
+      if (notificationHandler || starNotificationHandler) {
+        try {
+          traceReceivedNotification(message);
+          if (notificationHandler) {
+            if (message.params === undefined) {
+              if (type !== undefined) {
+                if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
+                  logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
+                }
+              }
+              notificationHandler();
+            } else if (Array.isArray(message.params)) {
+              const params = message.params;
+              if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
+                notificationHandler({ token: params[0], value: params[1] });
+              } else {
+                if (type !== undefined) {
+                  if (type.parameterStructures === messages_1.ParameterStructures.byName) {
+                    logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
+                  }
+                  if (type.numberOfParams !== message.params.length) {
+                    logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
+                  }
+                }
+                notificationHandler(...params);
+              }
+            } else {
+              if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+                logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
+              }
+              notificationHandler(message.params);
+            }
+          } else if (starNotificationHandler) {
+            starNotificationHandler(message.method, message.params);
+          }
+        } catch (error) {
+          if (error.message) {
+            logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
+          } else {
+            logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
+          }
+        }
+      } else {
+        unhandledNotificationEmitter.fire(message);
+      }
+    }
+    function handleInvalidMessage(message) {
+      if (!message) {
+        logger.error("Received empty message.");
+        return;
+      }
+      logger.error(`Received message which is neither a response nor a notification message:
+${JSON.stringify(message, null, 4)}`);
+      const responseMessage = message;
+      if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
+        const key = responseMessage.id;
+        const responseHandler = responsePromises.get(key);
+        if (responseHandler) {
+          responseHandler.reject(new Error("The received response has neither a result nor an error property."));
+        }
+      }
+    }
+    function stringifyTrace(params) {
+      if (params === undefined || params === null) {
+        return;
+      }
+      switch (trace) {
+        case Trace.Verbose:
+          return JSON.stringify(params, null, 4);
+        case Trace.Compact:
+          return JSON.stringify(params);
+        default:
+          return;
+      }
+    }
+    function traceSendingRequest(message) {
+      if (trace === Trace.Off || !tracer) {
+        return;
+      }
+      if (traceFormat === TraceFormat.Text) {
+        let data = undefined;
+        if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
+          data = `Params: ${stringifyTrace(message.params)}
+
+`;
+        }
+        tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
+      } else {
+        logLSPMessage("send-request", message);
+      }
+    }
+    function traceSendingNotification(message) {
+      if (trace === Trace.Off || !tracer) {
+        return;
+      }
+      if (traceFormat === TraceFormat.Text) {
+        let data = undefined;
+        if (trace === Trace.Verbose || trace === Trace.Compact) {
+          if (message.params) {
+            data = `Params: ${stringifyTrace(message.params)}
+
+`;
+          } else {
+            data = `No parameters provided.
+
+`;
+          }
+        }
+        tracer.log(`Sending notification '${message.method}'.`, data);
+      } else {
+        logLSPMessage("send-notification", message);
+      }
+    }
+    function traceSendingResponse(message, method, startTime) {
+      if (trace === Trace.Off || !tracer) {
+        return;
+      }
+      if (traceFormat === TraceFormat.Text) {
+        let data = undefined;
+        if (trace === Trace.Verbose || trace === Trace.Compact) {
+          if (message.error && message.error.data) {
+            data = `Error data: ${stringifyTrace(message.error.data)}
+
+`;
+          } else {
+            if (message.result) {
+              data = `Result: ${stringifyTrace(message.result)}
+
+`;
+            } else if (message.error === undefined) {
+              data = `No result returned.
+
+`;
+            }
+          }
+        }
+        tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
+      } else {
+        logLSPMessage("send-response", message);
+      }
+    }
+    function traceReceivedRequest(message) {
+      if (trace === Trace.Off || !tracer) {
+        return;
+      }
+      if (traceFormat === TraceFormat.Text) {
+        let data = undefined;
+        if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
+          data = `Params: ${stringifyTrace(message.params)}
+
+`;
+        }
+        tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
+      } else {
+        logLSPMessage("receive-request", message);
+      }
+    }
+    function traceReceivedNotification(message) {
+      if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
+        return;
+      }
+      if (traceFormat === TraceFormat.Text) {
+        let data = undefined;
+        if (trace === Trace.Verbose || trace === Trace.Compact) {
+          if (message.params) {
+            data = `Params: ${stringifyTrace(message.params)}
+
+`;
+          } else {
+            data = `No parameters provided.
+
+`;
+          }
+        }
+        tracer.log(`Received notification '${message.method}'.`, data);
+      } else {
+        logLSPMessage("receive-notification", message);
+      }
+    }
+    function traceReceivedResponse(message, responsePromise) {
+      if (trace === Trace.Off || !tracer) {
+        return;
+      }
+      if (traceFormat === TraceFormat.Text) {
+        let data = undefined;
+        if (trace === Trace.Verbose || trace === Trace.Compact) {
+          if (message.error && message.error.data) {
+            data = `Error data: ${stringifyTrace(message.error.data)}
+
+`;
+          } else {
+            if (message.result) {
+              data = `Result: ${stringifyTrace(message.result)}
+
+`;
+            } else if (message.error === undefined) {
+              data = `No result returned.
+
+`;
+            }
+          }
+        }
+        if (responsePromise) {
+          const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
+          tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
+        } else {
+          tracer.log(`Received response ${message.id} without active response promise.`, data);
+        }
+      } else {
+        logLSPMessage("receive-response", message);
+      }
+    }
+    function logLSPMessage(type, message) {
+      if (!tracer || trace === Trace.Off) {
+        return;
+      }
+      const lspMessage = {
+        isLSPMessage: true,
+        type,
+        message,
+        timestamp: Date.now()
+      };
+      tracer.log(lspMessage);
+    }
+    function throwIfClosedOrDisposed() {
+      if (isClosed()) {
+        throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
+      }
+      if (isDisposed()) {
+        throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
+      }
+    }
+    function throwIfListening() {
+      if (isListening()) {
+        throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
+      }
+    }
+    function throwIfNotListening() {
+      if (!isListening()) {
+        throw new Error("Call listen() first.");
+      }
+    }
+    function undefinedToNull(param) {
+      if (param === undefined) {
+        return null;
+      } else {
+        return param;
+      }
+    }
+    function nullToUndefined(param) {
+      if (param === null) {
+        return;
+      } else {
+        return param;
+      }
+    }
+    function isNamedParam(param) {
+      return param !== undefined && param !== null && !Array.isArray(param) && typeof param === "object";
+    }
+    function computeSingleParam(parameterStructures, param) {
+      switch (parameterStructures) {
+        case messages_1.ParameterStructures.auto:
+          if (isNamedParam(param)) {
+            return nullToUndefined(param);
+          } else {
+            return [undefinedToNull(param)];
+          }
+        case messages_1.ParameterStructures.byName:
+          if (!isNamedParam(param)) {
+            throw new Error(`Received parameters by name but param is not an object literal.`);
+          }
+          return nullToUndefined(param);
+        case messages_1.ParameterStructures.byPosition:
+          return [undefinedToNull(param)];
+        default:
+          throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
+      }
+    }
+    function computeMessageParams(type, params) {
+      let result;
+      const numberOfParams = type.numberOfParams;
+      switch (numberOfParams) {
+        case 0:
+          result = undefined;
+          break;
+        case 1:
+          result = computeSingleParam(type.parameterStructures, params[0]);
+          break;
+        default:
+          result = [];
+          for (let i = 0;i < params.length && i < numberOfParams; i++) {
+            result.push(undefinedToNull(params[i]));
+          }
+          if (params.length < numberOfParams) {
+            for (let i = params.length;i < numberOfParams; i++) {
+              result.push(null);
+            }
+          }
+          break;
+      }
+      return result;
+    }
+    const connection = {
+      sendNotification: (type, ...args) => {
+        throwIfClosedOrDisposed();
+        let method;
+        let messageParams;
+        if (Is.string(type)) {
+          method = type;
+          const first = args[0];
+          let paramStart = 0;
+          let parameterStructures = messages_1.ParameterStructures.auto;
+          if (messages_1.ParameterStructures.is(first)) {
+            paramStart = 1;
+            parameterStructures = first;
+          }
+          let paramEnd = args.length;
+          const numberOfParams = paramEnd - paramStart;
+          switch (numberOfParams) {
+            case 0:
+              messageParams = undefined;
+              break;
+            case 1:
+              messageParams = computeSingleParam(parameterStructures, args[paramStart]);
+              break;
+            default:
+              if (parameterStructures === messages_1.ParameterStructures.byName) {
+                throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
+              }
+              messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
+              break;
+          }
+        } else {
+          const params = args;
+          method = type.method;
+          messageParams = computeMessageParams(type, params);
+        }
+        const notificationMessage = {
+          jsonrpc: version,
+          method,
+          params: messageParams
+        };
+        traceSendingNotification(notificationMessage);
+        return messageWriter.write(notificationMessage).catch((error) => {
+          logger.error(`Sending notification failed.`);
+          throw error;
+        });
+      },
+      onNotification: (type, handler) => {
+        throwIfClosedOrDisposed();
+        let method;
+        if (Is.func(type)) {
+          starNotificationHandler = type;
+        } else if (handler) {
+          if (Is.string(type)) {
+            method = type;
+            notificationHandlers.set(type, { type: undefined, handler });
+          } else {
+            method = type.method;
+            notificationHandlers.set(type.method, { type, handler });
+          }
+        }
+        return {
+          dispose: () => {
+            if (method !== undefined) {
+              notificationHandlers.delete(method);
+            } else {
+              starNotificationHandler = undefined;
+            }
+          }
+        };
+      },
+      onProgress: (_type, token, handler) => {
+        if (progressHandlers.has(token)) {
+          throw new Error(`Progress handler for token ${token} already registered`);
+        }
+        progressHandlers.set(token, handler);
+        return {
+          dispose: () => {
+            progressHandlers.delete(token);
+          }
+        };
+      },
+      sendProgress: (_type, token, value) => {
+        return connection.sendNotification(ProgressNotification.type, { token, value });
+      },
+      onUnhandledProgress: unhandledProgressEmitter.event,
+      sendRequest: (type, ...args) => {
+        throwIfClosedOrDisposed();
+        throwIfNotListening();
+        let method;
+        let messageParams;
+        let token = undefined;
+        if (Is.string(type)) {
+          method = type;
+          const first = args[0];
+          const last = args[args.length - 1];
+          let paramStart = 0;
+          let parameterStructures = messages_1.ParameterStructures.auto;
+          if (messages_1.ParameterStructures.is(first)) {
+            paramStart = 1;
+            parameterStructures = first;
+          }
+          let paramEnd = args.length;
+          if (cancellation_1.CancellationToken.is(last)) {
+            paramEnd = paramEnd - 1;
+            token = last;
+          }
+          const numberOfParams = paramEnd - paramStart;
+          switch (numberOfParams) {
+            case 0:
+              messageParams = undefined;
+              break;
+            case 1:
+              messageParams = computeSingleParam(parameterStructures, args[paramStart]);
+              break;
+            default:
+              if (parameterStructures === messages_1.ParameterStructures.byName) {
+                throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
+              }
+              messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
+              break;
+          }
+        } else {
+          const params = args;
+          method = type.method;
+          messageParams = computeMessageParams(type, params);
+          const numberOfParams = type.numberOfParams;
+          token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;
+        }
+        const id = sequenceNumber++;
+        let disposable;
+        if (token) {
+          disposable = token.onCancellationRequested(() => {
+            const p = cancellationStrategy.sender.sendCancellation(connection, id);
+            if (p === undefined) {
+              logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
+              return Promise.resolve();
+            } else {
+              return p.catch(() => {
+                logger.log(`Sending cancellation messages for id ${id} failed`);
+              });
+            }
+          });
+        }
+        const requestMessage = {
+          jsonrpc: version,
+          id,
+          method,
+          params: messageParams
+        };
+        traceSendingRequest(requestMessage);
+        if (typeof cancellationStrategy.sender.enableCancellation === "function") {
+          cancellationStrategy.sender.enableCancellation(requestMessage);
+        }
+        return new Promise(async (resolve, reject) => {
+          const resolveWithCleanup = (r) => {
+            resolve(r);
+            cancellationStrategy.sender.cleanup(id);
+            disposable?.dispose();
+          };
+          const rejectWithCleanup = (r) => {
+            reject(r);
+            cancellationStrategy.sender.cleanup(id);
+            disposable?.dispose();
+          };
+          const responsePromise = { method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
+          try {
+            responsePromises.set(id, responsePromise);
+            await messageWriter.write(requestMessage);
+          } catch (error) {
+            responsePromises.delete(id);
+            responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : "Unknown reason"));
+            logger.error(`Sending request failed.`);
+            throw error;
+          }
+        });
+      },
+      onRequest: (type, handler) => {
+        throwIfClosedOrDisposed();
+        let method = null;
+        if (StarRequestHandler.is(type)) {
+          method = undefined;
+          starRequestHandler = type;
+        } else if (Is.string(type)) {
+          method = null;
+          if (handler !== undefined) {
+            method = type;
+            requestHandlers.set(type, { handler, type: undefined });
+          }
+        } else {
+          if (handler !== undefined) {
+            method = type.method;
+            requestHandlers.set(type.method, { type, handler });
+          }
+        }
+        return {
+          dispose: () => {
+            if (method === null) {
+              return;
+            }
+            if (method !== undefined) {
+              requestHandlers.delete(method);
+            } else {
+              starRequestHandler = undefined;
+            }
+          }
+        };
+      },
+      hasPendingResponse: () => {
+        return responsePromises.size > 0;
+      },
+      trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
+        let _sendNotification = false;
+        let _traceFormat = TraceFormat.Text;
+        if (sendNotificationOrTraceOptions !== undefined) {
+          if (Is.boolean(sendNotificationOrTraceOptions)) {
+            _sendNotification = sendNotificationOrTraceOptions;
+          } else {
+            _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
+            _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
+          }
+        }
+        trace = _value;
+        traceFormat = _traceFormat;
+        if (trace === Trace.Off) {
+          tracer = undefined;
+        } else {
+          tracer = _tracer;
+        }
+        if (_sendNotification && !isClosed() && !isDisposed()) {
+          await connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
+        }
+      },
+      onError: errorEmitter.event,
+      onClose: closeEmitter.event,
+      onUnhandledNotification: unhandledNotificationEmitter.event,
+      onDispose: disposeEmitter.event,
+      end: () => {
+        messageWriter.end();
+      },
+      dispose: () => {
+        if (isDisposed()) {
+          return;
+        }
+        state = ConnectionState.Disposed;
+        disposeEmitter.fire(undefined);
+        const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
+        for (const promise of responsePromises.values()) {
+          promise.reject(error);
+        }
+        responsePromises = new Map;
+        requestTokens = new Map;
+        knownCanceledRequests = new Set;
+        messageQueue = new linkedMap_1.LinkedMap;
+        if (Is.func(messageWriter.dispose)) {
+          messageWriter.dispose();
+        }
+        if (Is.func(messageReader.dispose)) {
+          messageReader.dispose();
+        }
+      },
+      listen: () => {
+        throwIfClosedOrDisposed();
+        throwIfListening();
+        state = ConnectionState.Listening;
+        messageReader.listen(callback);
+      },
+      inspect: () => {
+        (0, ral_1.default)().console.log("inspect");
+      }
+    };
+    connection.onNotification(LogTraceNotification.type, (params) => {
+      if (trace === Trace.Off || !tracer) {
+        return;
+      }
+      const verbose = trace === Trace.Verbose || trace === Trace.Compact;
+      tracer.log(params.message, verbose ? params.verbose : undefined);
+    });
+    connection.onNotification(ProgressNotification.type, (params) => {
+      const handler = progressHandlers.get(params.token);
+      if (handler) {
+        handler(params.value);
+      } else {
+        unhandledProgressEmitter.fire(params);
+      }
+    });
+    return connection;
+  }
+  exports.createMessageConnection = createMessageConnection;
+});
+
+// node_modules/vscode-jsonrpc/lib/common/api.js
+var require_api = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = undefined;
+  exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = undefined;
+  var messages_1 = require_messages();
+  Object.defineProperty(exports, "Message", { enumerable: true, get: function() {
+    return messages_1.Message;
+  } });
+  Object.defineProperty(exports, "RequestType", { enumerable: true, get: function() {
+    return messages_1.RequestType;
+  } });
+  Object.defineProperty(exports, "RequestType0", { enumerable: true, get: function() {
+    return messages_1.RequestType0;
+  } });
+  Object.defineProperty(exports, "RequestType1", { enumerable: true, get: function() {
+    return messages_1.RequestType1;
+  } });
+  Object.defineProperty(exports, "RequestType2", { enumerable: true, get: function() {
+    return messages_1.RequestType2;
+  } });
+  Object.defineProperty(exports, "RequestType3", { enumerable: true, get: function() {
+    return messages_1.RequestType3;
+  } });
+  Object.defineProperty(exports, "RequestType4", { enumerable: true, get: function() {
+    return messages_1.RequestType4;
+  } });
+  Object.defineProperty(exports, "RequestType5", { enumerable: true, get: function() {
+    return messages_1.RequestType5;
+  } });
+  Object.defineProperty(exports, "RequestType6", { enumerable: true, get: function() {
+    return messages_1.RequestType6;
+  } });
+  Object.defineProperty(exports, "RequestType7", { enumerable: true, get: function() {
+    return messages_1.RequestType7;
+  } });
+  Object.defineProperty(exports, "RequestType8", { enumerable: true, get: function() {
+    return messages_1.RequestType8;
+  } });
+  Object.defineProperty(exports, "RequestType9", { enumerable: true, get: function() {
+    return messages_1.RequestType9;
+  } });
+  Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function() {
+    return messages_1.ResponseError;
+  } });
+  Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function() {
+    return messages_1.ErrorCodes;
+  } });
+  Object.defineProperty(exports, "NotificationType", { enumerable: true, get: function() {
+    return messages_1.NotificationType;
+  } });
+  Object.defineProperty(exports, "NotificationType0", { enumerable: true, get: function() {
+    return messages_1.NotificationType0;
+  } });
+  Object.defineProperty(exports, "NotificationType1", { enumerable: true, get: function() {
+    return messages_1.NotificationType1;
+  } });
+  Object.defineProperty(exports, "NotificationType2", { enumerable: true, get: function() {
+    return messages_1.NotificationType2;
+  } });
+  Object.defineProperty(exports, "NotificationType3", { enumerable: true, get: function() {
+    return messages_1.NotificationType3;
+  } });
+  Object.defineProperty(exports, "NotificationType4", { enumerable: true, get: function() {
+    return messages_1.NotificationType4;
+  } });
+  Object.defineProperty(exports, "NotificationType5", { enumerable: true, get: function() {
+    return messages_1.NotificationType5;
+  } });
+  Object.defineProperty(exports, "NotificationType6", { enumerable: true, get: function() {
+    return messages_1.NotificationType6;
+  } });
+  Object.defineProperty(exports, "NotificationType7", { enumerable: true, get: function() {
+    return messages_1.NotificationType7;
+  } });
+  Object.defineProperty(exports, "NotificationType8", { enumerable: true, get: function() {
+    return messages_1.NotificationType8;
+  } });
+  Object.defineProperty(exports, "NotificationType9", { enumerable: true, get: function() {
+    return messages_1.NotificationType9;
+  } });
+  Object.defineProperty(exports, "ParameterStructures", { enumerable: true, get: function() {
+    return messages_1.ParameterStructures;
+  } });
+  var linkedMap_1 = require_linkedMap();
+  Object.defineProperty(exports, "LinkedMap", { enumerable: true, get: function() {
+    return linkedMap_1.LinkedMap;
+  } });
+  Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function() {
+    return linkedMap_1.LRUCache;
+  } });
+  Object.defineProperty(exports, "Touch", { enumerable: true, get: function() {
+    return linkedMap_1.Touch;
+  } });
+  var disposable_1 = require_disposable();
+  Object.defineProperty(exports, "Disposable", { enumerable: true, get: function() {
+    return disposable_1.Disposable;
+  } });
+  var events_1 = require_events();
+  Object.defineProperty(exports, "Event", { enumerable: true, get: function() {
+    return events_1.Event;
+  } });
+  Object.defineProperty(exports, "Emitter", { enumerable: true, get: function() {
+    return events_1.Emitter;
+  } });
+  var cancellation_1 = require_cancellation();
+  Object.defineProperty(exports, "CancellationTokenSource", { enumerable: true, get: function() {
+    return cancellation_1.CancellationTokenSource;
+  } });
+  Object.defineProperty(exports, "CancellationToken", { enumerable: true, get: function() {
+    return cancellation_1.CancellationToken;
+  } });
+  var sharedArrayCancellation_1 = require_sharedArrayCancellation();
+  Object.defineProperty(exports, "SharedArraySenderStrategy", { enumerable: true, get: function() {
+    return sharedArrayCancellation_1.SharedArraySenderStrategy;
+  } });
+  Object.defineProperty(exports, "SharedArrayReceiverStrategy", { enumerable: true, get: function() {
+    return sharedArrayCancellation_1.SharedArrayReceiverStrategy;
+  } });
+  var messageReader_1 = require_messageReader();
+  Object.defineProperty(exports, "MessageReader", { enumerable: true, get: function() {
+    return messageReader_1.MessageReader;
+  } });
+  Object.defineProperty(exports, "AbstractMessageReader", { enumerable: true, get: function() {
+    return messageReader_1.AbstractMessageReader;
+  } });
+  Object.defineProperty(exports, "ReadableStreamMessageReader", { enumerable: true, get: function() {
+    return messageReader_1.ReadableStreamMessageReader;
+  } });
+  var messageWriter_1 = require_messageWriter();
+  Object.defineProperty(exports, "MessageWriter", { enumerable: true, get: function() {
+    return messageWriter_1.MessageWriter;
+  } });
+  Object.defineProperty(exports, "AbstractMessageWriter", { enumerable: true, get: function() {
+    return messageWriter_1.AbstractMessageWriter;
+  } });
+  Object.defineProperty(exports, "WriteableStreamMessageWriter", { enumerable: true, get: function() {
+    return messageWriter_1.WriteableStreamMessageWriter;
+  } });
+  var messageBuffer_1 = require_messageBuffer();
+  Object.defineProperty(exports, "AbstractMessageBuffer", { enumerable: true, get: function() {
+    return messageBuffer_1.AbstractMessageBuffer;
+  } });
+  var connection_1 = require_connection();
+  Object.defineProperty(exports, "ConnectionStrategy", { enumerable: true, get: function() {
+    return connection_1.ConnectionStrategy;
+  } });
+  Object.defineProperty(exports, "ConnectionOptions", { enumerable: true, get: function() {
+    return connection_1.ConnectionOptions;
+  } });
+  Object.defineProperty(exports, "NullLogger", { enumerable: true, get: function() {
+    return connection_1.NullLogger;
+  } });
+  Object.defineProperty(exports, "createMessageConnection", { enumerable: true, get: function() {
+    return connection_1.createMessageConnection;
+  } });
+  Object.defineProperty(exports, "ProgressToken", { enumerable: true, get: function() {
+    return connection_1.ProgressToken;
+  } });
+  Object.defineProperty(exports, "ProgressType", { enumerable: true, get: function() {
+    return connection_1.ProgressType;
+  } });
+  Object.defineProperty(exports, "Trace", { enumerable: true, get: function() {
+    return connection_1.Trace;
+  } });
+  Object.defineProperty(exports, "TraceValues", { enumerable: true, get: function() {
+    return connection_1.TraceValues;
+  } });
+  Object.defineProperty(exports, "TraceFormat", { enumerable: true, get: function() {
+    return connection_1.TraceFormat;
+  } });
+  Object.defineProperty(exports, "SetTraceNotification", { enumerable: true, get: function() {
+    return connection_1.SetTraceNotification;
+  } });
+  Object.defineProperty(exports, "LogTraceNotification", { enumerable: true, get: function() {
+    return connection_1.LogTraceNotification;
+  } });
+  Object.defineProperty(exports, "ConnectionErrors", { enumerable: true, get: function() {
+    return connection_1.ConnectionErrors;
+  } });
+  Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function() {
+    return connection_1.ConnectionError;
+  } });
+  Object.defineProperty(exports, "CancellationReceiverStrategy", { enumerable: true, get: function() {
+    return connection_1.CancellationReceiverStrategy;
+  } });
+  Object.defineProperty(exports, "CancellationSenderStrategy", { enumerable: true, get: function() {
+    return connection_1.CancellationSenderStrategy;
+  } });
+  Object.defineProperty(exports, "CancellationStrategy", { enumerable: true, get: function() {
+    return connection_1.CancellationStrategy;
+  } });
+  Object.defineProperty(exports, "MessageStrategy", { enumerable: true, get: function() {
+    return connection_1.MessageStrategy;
+  } });
+  var ral_1 = require_ral();
+  exports.RAL = ral_1.default;
+});
+
+// node_modules/vscode-jsonrpc/lib/node/ril.js
+var require_ril = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var util_1 = __require("util");
+  var api_1 = require_api();
+
+  class MessageBuffer extends api_1.AbstractMessageBuffer {
+    constructor(encoding = "utf-8") {
+      super(encoding);
+    }
+    emptyBuffer() {
+      return MessageBuffer.emptyBuffer;
+    }
+    fromString(value, encoding) {
+      return Buffer.from(value, encoding);
+    }
+    toString(value, encoding) {
+      if (value instanceof Buffer) {
+        return value.toString(encoding);
+      } else {
+        return new util_1.TextDecoder(encoding).decode(value);
+      }
+    }
+    asNative(buffer, length) {
+      if (length === undefined) {
+        return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
+      } else {
+        return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
+      }
+    }
+    allocNative(length) {
+      return Buffer.allocUnsafe(length);
+    }
+  }
+  MessageBuffer.emptyBuffer = Buffer.allocUnsafe(0);
+
+  class ReadableStreamWrapper {
+    constructor(stream) {
+      this.stream = stream;
+    }
+    onClose(listener) {
+      this.stream.on("close", listener);
+      return api_1.Disposable.create(() => this.stream.off("close", listener));
+    }
+    onError(listener) {
+      this.stream.on("error", listener);
+      return api_1.Disposable.create(() => this.stream.off("error", listener));
+    }
+    onEnd(listener) {
+      this.stream.on("end", listener);
+      return api_1.Disposable.create(() => this.stream.off("end", listener));
+    }
+    onData(listener) {
+      this.stream.on("data", listener);
+      return api_1.Disposable.create(() => this.stream.off("data", listener));
+    }
+  }
+
+  class WritableStreamWrapper {
+    constructor(stream) {
+      this.stream = stream;
+    }
+    onClose(listener) {
+      this.stream.on("close", listener);
+      return api_1.Disposable.create(() => this.stream.off("close", listener));
+    }
+    onError(listener) {
+      this.stream.on("error", listener);
+      return api_1.Disposable.create(() => this.stream.off("error", listener));
+    }
+    onEnd(listener) {
+      this.stream.on("end", listener);
+      return api_1.Disposable.create(() => this.stream.off("end", listener));
+    }
+    write(data, encoding) {
+      return new Promise((resolve, reject) => {
+        const callback = (error) => {
+          if (error === undefined || error === null) {
+            resolve();
+          } else {
+            reject(error);
+          }
+        };
+        if (typeof data === "string") {
+          this.stream.write(data, encoding, callback);
+        } else {
+          this.stream.write(data, callback);
+        }
+      });
+    }
+    end() {
+      this.stream.end();
+    }
+  }
+  var _ril = Object.freeze({
+    messageBuffer: Object.freeze({
+      create: (encoding) => new MessageBuffer(encoding)
+    }),
+    applicationJson: Object.freeze({
+      encoder: Object.freeze({
+        name: "application/json",
+        encode: (msg, options) => {
+          try {
+            return Promise.resolve(Buffer.from(JSON.stringify(msg, undefined, 0), options.charset));
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        }
+      }),
+      decoder: Object.freeze({
+        name: "application/json",
+        decode: (buffer, options) => {
+          try {
+            if (buffer instanceof Buffer) {
+              return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
+            } else {
+              return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
+            }
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        }
+      })
+    }),
+    stream: Object.freeze({
+      asReadableStream: (stream) => new ReadableStreamWrapper(stream),
+      asWritableStream: (stream) => new WritableStreamWrapper(stream)
+    }),
+    console,
+    timer: Object.freeze({
+      setTimeout(callback, ms, ...args) {
+        const handle = setTimeout(callback, ms, ...args);
+        return { dispose: () => clearTimeout(handle) };
+      },
+      setImmediate(callback, ...args) {
+        const handle = setImmediate(callback, ...args);
+        return { dispose: () => clearImmediate(handle) };
+      },
+      setInterval(callback, ms, ...args) {
+        const handle = setInterval(callback, ms, ...args);
+        return { dispose: () => clearInterval(handle) };
+      }
+    })
+  });
+  function RIL() {
+    return _ril;
+  }
+  (function(RIL2) {
+    function install() {
+      api_1.RAL.install(_ril);
+    }
+    RIL2.install = install;
+  })(RIL || (RIL = {}));
+  exports.default = RIL;
+});
+
+// node_modules/vscode-jsonrpc/lib/node/main.js
+var require_main = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createMessageConnection = exports.createServerSocketTransport = exports.createClientSocketTransport = exports.createServerPipeTransport = exports.createClientPipeTransport = exports.generateRandomPipeName = exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.PortMessageWriter = exports.PortMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = undefined;
+  var ril_1 = require_ril();
+  ril_1.default.install();
+  var path = __require("path");
+  var os = __require("os");
+  var crypto_1 = __require("crypto");
+  var net_1 = __require("net");
+  var api_1 = require_api();
+  __exportStar(require_api(), exports);
+
+  class IPCMessageReader extends api_1.AbstractMessageReader {
+    constructor(process2) {
+      super();
+      this.process = process2;
+      let eventEmitter = this.process;
+      eventEmitter.on("error", (error) => this.fireError(error));
+      eventEmitter.on("close", () => this.fireClose());
+    }
+    listen(callback) {
+      this.process.on("message", callback);
+      return api_1.Disposable.create(() => this.process.off("message", callback));
+    }
+  }
+  exports.IPCMessageReader = IPCMessageReader;
+
+  class IPCMessageWriter extends api_1.AbstractMessageWriter {
+    constructor(process2) {
+      super();
+      this.process = process2;
+      this.errorCount = 0;
+      const eventEmitter = this.process;
+      eventEmitter.on("error", (error) => this.fireError(error));
+      eventEmitter.on("close", () => this.fireClose);
+    }
+    write(msg) {
+      try {
+        if (typeof this.process.send === "function") {
+          this.process.send(msg, undefined, undefined, (error) => {
+            if (error) {
+              this.errorCount++;
+              this.handleError(error, msg);
+            } else {
+              this.errorCount = 0;
+            }
+          });
+        }
+        return Promise.resolve();
+      } catch (error) {
+        this.handleError(error, msg);
+        return Promise.reject(error);
+      }
+    }
+    handleError(error, msg) {
+      this.errorCount++;
+      this.fireError(error, msg, this.errorCount);
+    }
+    end() {}
+  }
+  exports.IPCMessageWriter = IPCMessageWriter;
+
+  class PortMessageReader extends api_1.AbstractMessageReader {
+    constructor(port) {
+      super();
+      this.onData = new api_1.Emitter;
+      port.on("close", () => this.fireClose);
+      port.on("error", (error) => this.fireError(error));
+      port.on("message", (message) => {
+        this.onData.fire(message);
+      });
+    }
+    listen(callback) {
+      return this.onData.event(callback);
+    }
+  }
+  exports.PortMessageReader = PortMessageReader;
+
+  class PortMessageWriter extends api_1.AbstractMessageWriter {
+    constructor(port) {
+      super();
+      this.port = port;
+      this.errorCount = 0;
+      port.on("close", () => this.fireClose());
+      port.on("error", (error) => this.fireError(error));
+    }
+    write(msg) {
+      try {
+        this.port.postMessage(msg);
+        return Promise.resolve();
+      } catch (error) {
+        this.handleError(error, msg);
+        return Promise.reject(error);
+      }
+    }
+    handleError(error, msg) {
+      this.errorCount++;
+      this.fireError(error, msg, this.errorCount);
+    }
+    end() {}
+  }
+  exports.PortMessageWriter = PortMessageWriter;
+
+  class SocketMessageReader extends api_1.ReadableStreamMessageReader {
+    constructor(socket, encoding = "utf-8") {
+      super((0, ril_1.default)().stream.asReadableStream(socket), encoding);
+    }
+  }
+  exports.SocketMessageReader = SocketMessageReader;
+
+  class SocketMessageWriter extends api_1.WriteableStreamMessageWriter {
+    constructor(socket, options) {
+      super((0, ril_1.default)().stream.asWritableStream(socket), options);
+      this.socket = socket;
+    }
+    dispose() {
+      super.dispose();
+      this.socket.destroy();
+    }
+  }
+  exports.SocketMessageWriter = SocketMessageWriter;
+
+  class StreamMessageReader extends api_1.ReadableStreamMessageReader {
+    constructor(readable, encoding) {
+      super((0, ril_1.default)().stream.asReadableStream(readable), encoding);
+    }
+  }
+  exports.StreamMessageReader = StreamMessageReader;
+
+  class StreamMessageWriter extends api_1.WriteableStreamMessageWriter {
+    constructor(writable, options) {
+      super((0, ril_1.default)().stream.asWritableStream(writable), options);
+    }
+  }
+  exports.StreamMessageWriter = StreamMessageWriter;
+  var XDG_RUNTIME_DIR = process.env["XDG_RUNTIME_DIR"];
+  var safeIpcPathLengths = new Map([
+    ["linux", 107],
+    ["darwin", 103]
+  ]);
+  function generateRandomPipeName() {
+    const randomSuffix = (0, crypto_1.randomBytes)(21).toString("hex");
+    if (process.platform === "win32") {
+      return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
+    }
+    let result;
+    if (XDG_RUNTIME_DIR) {
+      result = path.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
+    } else {
+      result = path.join(os.tmpdir(), `vscode-${randomSuffix}.sock`);
+    }
+    const limit = safeIpcPathLengths.get(process.platform);
+    if (limit !== undefined && result.length > limit) {
+      (0, ril_1.default)().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
+    }
+    return result;
+  }
+  exports.generateRandomPipeName = generateRandomPipeName;
+  function createClientPipeTransport(pipeName, encoding = "utf-8") {
+    let connectResolve;
+    const connected = new Promise((resolve, _reject) => {
+      connectResolve = resolve;
+    });
+    return new Promise((resolve, reject) => {
+      let server = (0, net_1.createServer)((socket) => {
+        server.close();
+        connectResolve([
+          new SocketMessageReader(socket, encoding),
+          new SocketMessageWriter(socket, encoding)
+        ]);
+      });
+      server.on("error", reject);
+      server.listen(pipeName, () => {
+        server.removeListener("error", reject);
+        resolve({
+          onConnected: () => {
+            return connected;
+          }
+        });
+      });
+    });
+  }
+  exports.createClientPipeTransport = createClientPipeTransport;
+  function createServerPipeTransport(pipeName, encoding = "utf-8") {
+    const socket = (0, net_1.createConnection)(pipeName);
+    return [
+      new SocketMessageReader(socket, encoding),
+      new SocketMessageWriter(socket, encoding)
+    ];
+  }
+  exports.createServerPipeTransport = createServerPipeTransport;
+  function createClientSocketTransport(port, encoding = "utf-8") {
+    let connectResolve;
+    const connected = new Promise((resolve, _reject) => {
+      connectResolve = resolve;
+    });
+    return new Promise((resolve, reject) => {
+      const server = (0, net_1.createServer)((socket) => {
+        server.close();
+        connectResolve([
+          new SocketMessageReader(socket, encoding),
+          new SocketMessageWriter(socket, encoding)
+        ]);
+      });
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        server.removeListener("error", reject);
+        resolve({
+          onConnected: () => {
+            return connected;
+          }
+        });
+      });
+    });
+  }
+  exports.createClientSocketTransport = createClientSocketTransport;
+  function createServerSocketTransport(port, encoding = "utf-8") {
+    const socket = (0, net_1.createConnection)(port, "127.0.0.1");
+    return [
+      new SocketMessageReader(socket, encoding),
+      new SocketMessageWriter(socket, encoding)
+    ];
+  }
+  exports.createServerSocketTransport = createServerSocketTransport;
+  function isReadableStream(value) {
+    const candidate = value;
+    return candidate.read !== undefined && candidate.addListener !== undefined;
+  }
+  function isWritableStream(value) {
+    const candidate = value;
+    return candidate.write !== undefined && candidate.addListener !== undefined;
+  }
+  function createMessageConnection(input, output, logger, options) {
+    if (!logger) {
+      logger = api_1.NullLogger;
+    }
+    const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
+    const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
+    if (api_1.ConnectionStrategy.is(options)) {
+      options = { connectionStrategy: options };
+    }
+    return (0, api_1.createMessageConnection)(reader, writer, logger, options);
+  }
+  exports.createMessageConnection = createMessageConnection;
+});
+
+// src/index.ts
+import * as path5 from "path";
+import * as fs5 from "fs";
+import { fileURLToPath } from "url";
+
+// node_modules/@github/copilot-sdk/dist/client.js
+var import_node = __toESM(require_main(), 1);
+import { spawn } from "node:child_process";
+import { Socket } from "node:net";
+
+// node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
+var SDK_PROTOCOL_VERSION = 2;
+function getSdkProtocolVersion() {
+  return SDK_PROTOCOL_VERSION;
+}
+
+// node_modules/@github/copilot-sdk/dist/session.js
+class CopilotSession {
+  constructor(sessionId, connection, _workspacePath) {
+    this.sessionId = sessionId;
+    this.connection = connection;
+    this._workspacePath = _workspacePath;
+  }
+  eventHandlers = /* @__PURE__ */ new Set;
+  toolHandlers = /* @__PURE__ */ new Map;
+  permissionHandler;
+  get workspacePath() {
+    return this._workspacePath;
+  }
+  async send(options) {
+    const response = await this.connection.sendRequest("session.send", {
+      sessionId: this.sessionId,
+      prompt: options.prompt,
+      attachments: options.attachments,
+      mode: options.mode
+    });
+    return response.messageId;
+  }
+  async sendAndWait(options, timeout) {
+    const effectiveTimeout = timeout ?? 60000;
+    let resolveIdle;
+    let rejectWithError;
+    const idlePromise = new Promise((resolve, reject) => {
+      resolveIdle = resolve;
+      rejectWithError = reject;
+    });
+    let lastAssistantMessage;
+    const unsubscribe = this.on((event) => {
+      if (event.type === "assistant.message") {
+        lastAssistantMessage = event;
+      } else if (event.type === "session.idle") {
+        resolveIdle();
+      } else if (event.type === "session.error") {
+        const error = new Error(event.data.message);
+        error.stack = event.data.stack;
+        rejectWithError(error);
+      }
+    });
+    try {
+      await this.send(options);
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`Timeout after ${effectiveTimeout}ms waiting for session.idle`)), effectiveTimeout);
+      });
+      await Promise.race([idlePromise, timeoutPromise]);
+      return lastAssistantMessage;
+    } finally {
+      unsubscribe();
+    }
+  }
+  on(handler) {
+    this.eventHandlers.add(handler);
+    return () => {
+      this.eventHandlers.delete(handler);
+    };
+  }
+  _dispatchEvent(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch (_error) {}
+    }
+  }
+  registerTools(tools) {
+    this.toolHandlers.clear();
+    if (!tools) {
+      return;
+    }
+    for (const tool of tools) {
+      this.toolHandlers.set(tool.name, tool.handler);
+    }
+  }
+  getToolHandler(name) {
+    return this.toolHandlers.get(name);
+  }
+  registerPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  async _handlePermissionRequest(request) {
+    if (!this.permissionHandler) {
+      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
+    }
+    try {
+      const result = await this.permissionHandler(request, {
+        sessionId: this.sessionId
+      });
+      return result;
+    } catch (_error) {
+      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
+    }
+  }
+  async getMessages() {
+    const response = await this.connection.sendRequest("session.getMessages", {
+      sessionId: this.sessionId
+    });
+    return response.events;
+  }
+  async destroy() {
+    await this.connection.sendRequest("session.destroy", {
+      sessionId: this.sessionId
+    });
+    this.eventHandlers.clear();
+    this.toolHandlers.clear();
+    this.permissionHandler = undefined;
+  }
+  async abort() {
+    await this.connection.sendRequest("session.abort", {
+      sessionId: this.sessionId
+    });
+  }
+}
+
+// node_modules/@github/copilot-sdk/dist/client.js
+function isZodSchema(value) {
+  return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
+}
+function toJsonSchema(parameters) {
+  if (!parameters)
+    return;
+  if (isZodSchema(parameters)) {
+    return parameters.toJSONSchema();
+  }
+  return parameters;
+}
+
+class CopilotClient {
+  cliProcess = null;
+  connection = null;
+  socket = null;
+  actualPort = null;
+  actualHost = "localhost";
+  state = "disconnected";
+  sessions = /* @__PURE__ */ new Map;
+  options;
+  isExternalServer = false;
+  forceStopping = false;
+  constructor(options = {}) {
+    if (options.cliUrl && (options.useStdio === true || options.cliPath)) {
+      throw new Error("cliUrl is mutually exclusive with useStdio and cliPath");
+    }
+    if (options.cliUrl) {
+      const { host, port } = this.parseCliUrl(options.cliUrl);
+      this.actualHost = host;
+      this.actualPort = port;
+      this.isExternalServer = true;
+    }
+    this.options = {
+      cliPath: options.cliPath || "copilot",
+      cliArgs: options.cliArgs ?? [],
+      cwd: options.cwd ?? process.cwd(),
+      port: options.port || 0,
+      useStdio: options.cliUrl ? false : options.useStdio ?? true,
+      cliUrl: options.cliUrl,
+      logLevel: options.logLevel || "debug",
+      autoStart: options.autoStart ?? true,
+      autoRestart: options.autoRestart ?? true,
+      env: options.env ?? process.env
+    };
+  }
+  parseCliUrl(url) {
+    let cleanUrl = url.replace(/^https?:\/\//, "");
+    if (/^\d+$/.test(cleanUrl)) {
+      return { host: "localhost", port: parseInt(cleanUrl, 10) };
+    }
+    const parts = cleanUrl.split(":");
+    if (parts.length !== 2) {
+      throw new Error(`Invalid cliUrl format: ${url}. Expected "host:port", "http://host:port", or "port"`);
+    }
+    const host = parts[0] || "localhost";
+    const port = parseInt(parts[1], 10);
+    if (isNaN(port) || port <= 0 || port > 65535) {
+      throw new Error(`Invalid port in cliUrl: ${url}`);
+    }
+    return { host, port };
+  }
+  async start() {
+    if (this.state === "connected") {
+      return;
+    }
+    this.state = "connecting";
+    try {
+      if (!this.isExternalServer) {
+        await this.startCLIServer();
+      }
+      await this.connectToServer();
+      await this.verifyProtocolVersion();
+      this.state = "connected";
+    } catch (error) {
+      this.state = "error";
+      throw error;
+    }
+  }
+  async stop() {
+    const errors = [];
+    for (const session of this.sessions.values()) {
+      const sessionId = session.sessionId;
+      let lastError = null;
+      for (let attempt = 1;attempt <= 3; attempt++) {
+        try {
+          await session.destroy();
+          lastError = null;
+          break;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (attempt < 3) {
+            const delay = 100 * Math.pow(2, attempt - 1);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+      }
+      if (lastError) {
+        errors.push(new Error(`Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`));
+      }
+    }
+    this.sessions.clear();
+    if (this.connection) {
+      try {
+        this.connection.dispose();
+      } catch (error) {
+        errors.push(new Error(`Failed to dispose connection: ${error instanceof Error ? error.message : String(error)}`));
+      }
+      this.connection = null;
+    }
+    if (this.socket) {
+      try {
+        this.socket.end();
+      } catch (error) {
+        errors.push(new Error(`Failed to close socket: ${error instanceof Error ? error.message : String(error)}`));
+      }
+      this.socket = null;
+    }
+    if (this.cliProcess && !this.isExternalServer) {
+      try {
+        this.cliProcess.kill();
+      } catch (error) {
+        errors.push(new Error(`Failed to kill CLI process: ${error instanceof Error ? error.message : String(error)}`));
+      }
+      this.cliProcess = null;
+    }
+    this.state = "disconnected";
+    this.actualPort = null;
+    return errors;
+  }
+  async forceStop() {
+    this.forceStopping = true;
+    this.sessions.clear();
+    if (this.connection) {
+      try {
+        this.connection.dispose();
+      } catch {}
+      this.connection = null;
+    }
+    if (this.socket) {
+      try {
+        this.socket.destroy();
+      } catch {}
+      this.socket = null;
+    }
+    if (this.cliProcess && !this.isExternalServer) {
+      try {
+        this.cliProcess.kill("SIGKILL");
+      } catch {}
+      this.cliProcess = null;
+    }
+    this.state = "disconnected";
+    this.actualPort = null;
+  }
+  async createSession(config = {}) {
+    if (!this.connection) {
+      if (this.options.autoStart) {
+        await this.start();
+      } else {
+        throw new Error("Client not connected. Call start() first.");
+      }
+    }
+    const response = await this.connection.sendRequest("session.create", {
+      model: config.model,
+      sessionId: config.sessionId,
+      tools: config.tools?.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: toJsonSchema(tool.parameters)
+      })),
+      systemMessage: config.systemMessage,
+      availableTools: config.availableTools,
+      excludedTools: config.excludedTools,
+      provider: config.provider,
+      requestPermission: !!config.onPermissionRequest,
+      streaming: config.streaming,
+      mcpServers: config.mcpServers,
+      customAgents: config.customAgents,
+      configDir: config.configDir,
+      skillDirectories: config.skillDirectories,
+      disabledSkills: config.disabledSkills,
+      infiniteSessions: config.infiniteSessions
+    });
+    const { sessionId, workspacePath } = response;
+    const session = new CopilotSession(sessionId, this.connection, workspacePath);
+    session.registerTools(config.tools);
+    if (config.onPermissionRequest) {
+      session.registerPermissionHandler(config.onPermissionRequest);
+    }
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+  async resumeSession(sessionId, config = {}) {
+    if (!this.connection) {
+      if (this.options.autoStart) {
+        await this.start();
+      } else {
+        throw new Error("Client not connected. Call start() first.");
+      }
+    }
+    const response = await this.connection.sendRequest("session.resume", {
+      sessionId,
+      tools: config.tools?.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: toJsonSchema(tool.parameters)
+      })),
+      provider: config.provider,
+      requestPermission: !!config.onPermissionRequest,
+      streaming: config.streaming,
+      mcpServers: config.mcpServers,
+      customAgents: config.customAgents,
+      skillDirectories: config.skillDirectories,
+      disabledSkills: config.disabledSkills
+    });
+    const { sessionId: resumedSessionId, workspacePath } = response;
+    const session = new CopilotSession(resumedSessionId, this.connection, workspacePath);
+    session.registerTools(config.tools);
+    if (config.onPermissionRequest) {
+      session.registerPermissionHandler(config.onPermissionRequest);
+    }
+    this.sessions.set(resumedSessionId, session);
+    return session;
+  }
+  getState() {
+    return this.state;
+  }
+  async ping(message) {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const result = await this.connection.sendRequest("ping", { message });
+    return result;
+  }
+  async getStatus() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const result = await this.connection.sendRequest("status.get", {});
+    return result;
+  }
+  async getAuthStatus() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const result = await this.connection.sendRequest("auth.getStatus", {});
+    return result;
+  }
+  async listModels() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const result = await this.connection.sendRequest("models.list", {});
+    const response = result;
+    return response.models;
+  }
+  async verifyProtocolVersion() {
+    const expectedVersion = getSdkProtocolVersion();
+    const pingResult = await this.ping();
+    const serverVersion = pingResult.protocolVersion;
+    if (serverVersion === undefined) {
+      throw new Error(`SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`);
+    }
+    if (serverVersion !== expectedVersion) {
+      throw new Error(`SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`);
+    }
+  }
+  async getLastSessionId() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const response = await this.connection.sendRequest("session.getLastId", {});
+    return response.sessionId;
+  }
+  async deleteSession(sessionId) {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const response = await this.connection.sendRequest("session.delete", {
+      sessionId
+    });
+    const { success, error } = response;
+    if (!success) {
+      throw new Error(`Failed to delete session ${sessionId}: ${error || "Unknown error"}`);
+    }
+    this.sessions.delete(sessionId);
+  }
+  async listSessions() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const response = await this.connection.sendRequest("session.list", {});
+    const { sessions } = response;
+    return sessions.map((s) => ({
+      sessionId: s.sessionId,
+      startTime: new Date(s.startTime),
+      modifiedTime: new Date(s.modifiedTime),
+      summary: s.summary,
+      isRemote: s.isRemote
+    }));
+  }
+  async startCLIServer() {
+    return new Promise((resolve, reject) => {
+      const args = [
+        ...this.options.cliArgs,
+        "--server",
+        "--log-level",
+        this.options.logLevel
+      ];
+      if (this.options.useStdio) {
+        args.push("--stdio");
+      } else if (this.options.port > 0) {
+        args.push("--port", this.options.port.toString());
+      }
+      const envWithoutNodeDebug = { ...this.options.env };
+      delete envWithoutNodeDebug.NODE_DEBUG;
+      const isJsFile = this.options.cliPath.endsWith(".js");
+      const isAbsolutePath = this.options.cliPath.startsWith("/") || /^[a-zA-Z]:/.test(this.options.cliPath);
+      let command;
+      let spawnArgs;
+      if (isJsFile) {
+        command = "node";
+        spawnArgs = [this.options.cliPath, ...args];
+      } else if (process.platform === "win32" && !isAbsolutePath) {
+        command = "cmd";
+        spawnArgs = ["/c", `${this.options.cliPath}`, ...args];
+      } else {
+        command = this.options.cliPath;
+        spawnArgs = args;
+      }
+      this.cliProcess = spawn(command, spawnArgs, {
+        stdio: this.options.useStdio ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
+        cwd: this.options.cwd,
+        env: envWithoutNodeDebug
+      });
+      let stdout = "";
+      let resolved = false;
+      if (this.options.useStdio) {
+        resolved = true;
+        resolve();
+      } else {
+        this.cliProcess.stdout?.on("data", (data) => {
+          stdout += data.toString();
+          const match = stdout.match(/listening on port (\d+)/i);
+          if (match && !resolved) {
+            this.actualPort = parseInt(match[1], 10);
+            resolved = true;
+            resolve();
+          }
+        });
+      }
+      this.cliProcess.stderr?.on("data", (data) => {
+        const lines = data.toString().split(`
+`);
+        for (const line of lines) {
+          if (line.trim()) {
+            process.stderr.write(`[CLI subprocess] ${line}
+`);
+          }
+        }
+      });
+      this.cliProcess.on("error", (error) => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(`Failed to start CLI server: ${error.message}`));
+        }
+      });
+      this.cliProcess.on("exit", (code) => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(`CLI server exited with code ${code}`));
+        } else if (this.options.autoRestart && this.state === "connected") {
+          this.reconnect();
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error("Timeout waiting for CLI server to start"));
+        }
+      }, 1e4);
+    });
+  }
+  async connectToServer() {
+    if (this.options.useStdio) {
+      return this.connectViaStdio();
+    } else {
+      return this.connectViaTcp();
+    }
+  }
+  async connectViaStdio() {
+    if (!this.cliProcess) {
+      throw new Error("CLI process not started");
+    }
+    this.cliProcess.stdin?.on("error", (err) => {
+      if (!this.forceStopping) {
+        throw err;
+      }
+    });
+    this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.cliProcess.stdout), new import_node.StreamMessageWriter(this.cliProcess.stdin));
+    this.attachConnectionHandlers();
+    this.connection.listen();
+  }
+  async connectViaTcp() {
+    if (!this.actualPort) {
+      throw new Error("Server port not available");
+    }
+    return new Promise((resolve, reject) => {
+      this.socket = new Socket;
+      this.socket.connect(this.actualPort, this.actualHost, () => {
+        this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.socket), new import_node.StreamMessageWriter(this.socket));
+        this.attachConnectionHandlers();
+        this.connection.listen();
+        resolve();
+      });
+      this.socket.on("error", (error) => {
+        reject(new Error(`Failed to connect to CLI server: ${error.message}`));
+      });
+    });
+  }
+  attachConnectionHandlers() {
+    if (!this.connection) {
+      return;
+    }
+    this.connection.onNotification("session.event", (notification) => {
+      this.handleSessionEventNotification(notification);
+    });
+    this.connection.onRequest("tool.call", async (params) => await this.handleToolCallRequest(params));
+    this.connection.onRequest("permission.request", async (params) => await this.handlePermissionRequest(params));
+    this.connection.onClose(() => {
+      if (this.state === "connected" && this.options.autoRestart) {
+        this.reconnect();
+      }
+    });
+    this.connection.onError((_error) => {});
+  }
+  handleSessionEventNotification(notification) {
+    if (typeof notification !== "object" || !notification || !("sessionId" in notification) || typeof notification.sessionId !== "string" || !("event" in notification)) {
+      return;
+    }
+    const session = this.sessions.get(notification.sessionId);
+    if (session) {
+      session._dispatchEvent(notification.event);
+    }
+  }
+  async handleToolCallRequest(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.toolCallId !== "string" || typeof params.toolName !== "string") {
+      throw new Error("Invalid tool call payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Unknown session ${params.sessionId}`);
+    }
+    const handler = session.getToolHandler(params.toolName);
+    if (!handler) {
+      return { result: this.buildUnsupportedToolResult(params.toolName) };
+    }
+    return await this.executeToolCall(handler, params);
+  }
+  async executeToolCall(handler, request) {
+    try {
+      const invocation = {
+        sessionId: request.sessionId,
+        toolCallId: request.toolCallId,
+        toolName: request.toolName,
+        arguments: request.arguments
+      };
+      const result = await handler(request.arguments, invocation);
+      return { result: this.normalizeToolResult(result) };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        result: {
+          textResultForLlm: "Invoking this tool produced an error. Detailed information is not available.",
+          resultType: "failure",
+          error: message,
+          toolTelemetry: {}
+        }
+      };
+    }
+  }
+  async handlePermissionRequest(params) {
+    if (!params || typeof params.sessionId !== "string" || !params.permissionRequest) {
+      throw new Error("Invalid permission request payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    try {
+      const result = await session._handlePermissionRequest(params.permissionRequest);
+      return { result };
+    } catch (_error) {
+      return {
+        result: {
+          kind: "denied-no-approval-rule-and-could-not-request-from-user"
+        }
+      };
+    }
+  }
+  normalizeToolResult(result) {
+    if (result === undefined || result === null) {
+      return {
+        textResultForLlm: "Tool returned no result",
+        resultType: "failure",
+        error: "tool returned no result",
+        toolTelemetry: {}
+      };
+    }
+    if (this.isToolResultObject(result)) {
+      return result;
+    }
+    const textResult = typeof result === "string" ? result : JSON.stringify(result);
+    return {
+      textResultForLlm: textResult,
+      resultType: "success",
+      toolTelemetry: {}
+    };
+  }
+  isToolResultObject(value) {
+    return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
+  }
+  buildUnsupportedToolResult(toolName) {
+    return {
+      textResultForLlm: `Tool '${toolName}' is not supported by this client instance.`,
+      resultType: "failure",
+      error: `tool '${toolName}' not supported`,
+      toolTelemetry: {}
+    };
+  }
+  async reconnect() {
+    this.state = "disconnected";
+    try {
+      await this.stop();
+      await this.start();
+    } catch (_error) {}
+  }
+}
+
+// src/agent.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/tools/read-vtt.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/utils/vtt-parser.ts
+function parseTimeToSeconds(timeStr) {
+  const parts = timeStr.trim().split(":");
+  if (parts.length === 3) {
+    const [hours, minutes, seconds] = parts;
+    return parseInt(hours, 10) * 3600 + parseInt(minutes, 10) * 60 + parseFloat(seconds);
+  } else if (parts.length === 2) {
+    const [minutes, seconds] = parts;
+    return parseInt(minutes, 10) * 60 + parseFloat(seconds);
+  }
+  return parseFloat(timeStr);
+}
+function parseVtt(content, filePath) {
+  const lines = content.replace(/\r\n/g, `
+`).split(`
+`);
+  const cues = [];
+  let index = 0;
+  let i = 0;
+  while (i < lines.length && !lines[i].includes("-->")) {
+    i++;
+  }
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.includes("-->")) {
+      const timeParts = line.split("-->");
+      if (timeParts.length >= 2) {
+        const startTime = timeParts[0].trim().split(" ")[0];
+        const endTime = timeParts[1].trim().split(" ")[0];
+        const textLines = [];
+        i++;
+        while (i < lines.length && lines[i].trim() !== "" && !lines[i].includes("-->")) {
+          textLines.push(lines[i].trim());
+          i++;
+        }
+        if (textLines.length > 0) {
+          cues.push({
+            index: index++,
+            startTime,
+            endTime,
+            startSeconds: parseTimeToSeconds(startTime),
+            endSeconds: parseTimeToSeconds(endTime),
+            text: textLines.join(`
+`)
+          });
+        }
+      } else {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  return {
+    filePath,
+    cues,
+    rawContent: content
+  };
+}
+function formatVtt(vttFile) {
+  const lines = ["WEBVTT", ""];
+  for (const cue of vttFile.cues) {
+    lines.push(`${cue.startTime} --> ${cue.endTime}`);
+    lines.push(cue.text);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatCuesForDisplay(vttFile) {
+  return vttFile.cues.map((cue) => `[${cue.index}] ${cue.startTime} --> ${cue.endTime}
+${cue.text}`).join(`
+
+`);
+}
+
+// src/tools/read-vtt.ts
+var cachedVttFile = null;
+function getCachedVttFile() {
+  return cachedVttFile;
+}
+var readVttTool = {
+  name: "read_vtt_file",
+  description: "讀取並解析 VTT 字幕檔案，回傳所有字幕的時間戳和內容。",
+  parameters: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "VTT 檔案的完整路徑" }
+    },
+    required: ["filePath"]
+  },
+  handler: async ({ filePath }) => {
+    try {
+      console.log(`[DEBUG] readVttTool: Starting to read ${filePath}`);
+      const absolutePath = path.resolve(filePath);
+      if (!fs.existsSync(absolutePath)) {
+        console.log(`[DEBUG] readVttTool: File not found ${absolutePath}`);
+        return { success: false, error: `檔案不存在: ${absolutePath}` };
+      }
+      const content = fs.readFileSync(absolutePath, "utf-8");
+      console.log(`[DEBUG] readVttTool: File read, size ${content.length} bytes`);
+      const vttFile = parseVtt(content, absolutePath);
+      cachedVttFile = vttFile;
+      const displayCues = formatCuesForDisplay(vttFile);
+      console.log(`[DEBUG] readVttTool: Parsed ${vttFile.cues.length} cues, formatted length ${displayCues.length}`);
+      return {
+        success: true,
+        filePath: absolutePath,
+        totalCues: vttFile.cues.length,
+        cues: displayCues
+      };
+    } catch (error) {
+      console.error(`[DEBUG] readVttTool Error:`, error);
+      return { success: false, error: String(error) };
+    }
+  }
+};
+var getVttCuesTool = {
+  name: "get_vtt_cues",
+  description: "取得已載入 VTT 檔案的特定範圍字幕 (用於分批處理大檔案)",
+  parameters: {
+    type: "object",
+    properties: {
+      startIndex: { type: "number", description: "起始 Cue 索引 (從 0 開始)" },
+      endIndex: { type: "number", description: "結束 Cue 索引 (不含)" }
+    },
+    required: ["startIndex", "endIndex"]
+  },
+  handler: async ({ startIndex, endIndex }) => {
+    if (!cachedVttFile) {
+      return { success: false, error: "請先使用 read_vtt_file 載入 VTT 檔案" };
+    }
+    const cues = cachedVttFile.cues.slice(startIndex, endIndex);
+    return {
+      success: true,
+      totalCues: cachedVttFile.cues.length,
+      requestedRange: `${startIndex}-${endIndex}`,
+      returnedCues: cues.length,
+      cues: cues.map((cue) => ({
+        index: cue.index,
+        time: `${cue.startTime} --> ${cue.endTime}`,
+        text: cue.text
+      }))
+    };
+  }
+};
+// src/tools/write-file.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var writeFileTool = {
+  name: "write_file",
+  description: "將內容寫入到指定的檔案中。用於產生修正清單、章節資訊、總結等輸出檔案。",
+  parameters: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "要寫入的檔案路徑" },
+      content: { type: "string", description: "要寫入的內容" },
+      encoding: { type: "string", description: "檔案編碼，預設為 utf-8" }
+    },
+    required: ["filePath", "content"]
+  },
+  handler: async ({ filePath, content, encoding = "utf-8" }) => {
+    try {
+      const absolutePath = path2.resolve(filePath);
+      const dir = path2.dirname(absolutePath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+      fs2.writeFileSync(absolutePath, content, { encoding });
+      return {
+        success: true,
+        filePath: absolutePath,
+        bytesWritten: Buffer.byteLength(content, encoding)
+      };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+};
+var appendFileTool = {
+  name: "append_file",
+  description: "將內容附加到指定的檔案末尾。",
+  parameters: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "要附加內容的檔案路徑" },
+      content: { type: "string", description: "要附加的內容" }
+    },
+    required: ["filePath", "content"]
+  },
+  handler: async ({ filePath, content }) => {
+    try {
+      const absolutePath = path2.resolve(filePath);
+      fs2.appendFileSync(absolutePath, content, "utf-8");
+      return {
+        success: true,
+        filePath: absolutePath,
+        bytesAppended: Buffer.byteLength(content, "utf-8")
+      };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+};
+// src/tools/update-vtt.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var updateCueTool = {
+  name: "update_cue",
+  description: "更新指定索引的字幕內容。用於校正字幕中的錯字。",
+  parameters: {
+    type: "object",
+    properties: {
+      cueIndex: { type: "number", description: "要更新的 Cue 索引 (從 0 開始)" },
+      newText: { type: "string", description: "校正後的字幕文字" }
+    },
+    required: ["cueIndex", "newText"]
+  },
+  handler: async ({ cueIndex, newText }) => {
+    const vttFile = getCachedVttFile();
+    if (!vttFile) {
+      return { success: false, error: "請先使用 read_vtt_file 載入 VTT 檔案" };
+    }
+    if (cueIndex < 0 || cueIndex >= vttFile.cues.length) {
+      return { success: false, error: `無效的 Cue 索引: ${cueIndex}，有效範圍: 0-${vttFile.cues.length - 1}` };
+    }
+    const oldText = vttFile.cues[cueIndex].text;
+    vttFile.cues[cueIndex].text = newText;
+    return {
+      success: true,
+      cueIndex,
+      oldText,
+      newText,
+      time: `${vttFile.cues[cueIndex].startTime} --> ${vttFile.cues[cueIndex].endTime}`
+    };
+  }
+};
+var batchUpdateCuesTool = {
+  name: "batch_update_cues",
+  description: "批次更新多個字幕內容。用於一次校正多個字幕中的錯字。",
+  parameters: {
+    type: "object",
+    properties: {
+      updates: {
+        type: "array",
+        description: "要更新的字幕清單",
+        items: {
+          type: "object",
+          properties: {
+            cueIndex: { type: "number", description: "要更新的 Cue 索引" },
+            newText: { type: "string", description: "校正後的字幕文字" }
+          },
+          required: ["cueIndex", "newText"]
+        }
+      }
+    },
+    required: ["updates"]
+  },
+  handler: async ({ updates }) => {
+    const vttFile = getCachedVttFile();
+    if (!vttFile) {
+      return { success: false, error: "請先使用 read_vtt_file 載入 VTT 檔案" };
+    }
+    const results = [];
+    for (const update of updates) {
+      if (update.cueIndex >= 0 && update.cueIndex < vttFile.cues.length) {
+        const oldText = vttFile.cues[update.cueIndex].text;
+        vttFile.cues[update.cueIndex].text = update.newText;
+        results.push({
+          cueIndex: update.cueIndex,
+          oldText,
+          newText: update.newText,
+          time: `${vttFile.cues[update.cueIndex].startTime} --> ${vttFile.cues[update.cueIndex].endTime}`
+        });
+      }
+    }
+    return {
+      success: true,
+      updatedCount: results.length,
+      updates: results
+    };
+  }
+};
+var saveVttTool = {
+  name: "save_vtt",
+  description: "將修改後的 VTT 字幕儲存到檔案。",
+  parameters: {
+    type: "object",
+    properties: {
+      outputPath: { type: "string", description: "輸出檔案路徑，若未指定則覆蓋原檔案" }
+    },
+    required: []
+  },
+  handler: async ({ outputPath }) => {
+    const vttFile = getCachedVttFile();
+    if (!vttFile) {
+      return { success: false, error: "請先使用 read_vtt_file 載入 VTT 檔案" };
+    }
+    try {
+      const targetPath = outputPath ? path3.resolve(outputPath) : vttFile.filePath;
+      const content = formatVtt(vttFile);
+      fs3.writeFileSync(targetPath, content, "utf-8");
+      return {
+        success: true,
+        filePath: targetPath,
+        totalCues: vttFile.cues.length
+      };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+};
+// src/agent.ts
+class EventLogger {
+  filePath;
+  stream;
+  isFirst = true;
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.stream = fs4.createWriteStream(filePath, { encoding: "utf-8" });
+    this.stream.write(`[
+`);
+  }
+  append(event) {
+    const payload = JSON.stringify(event, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2);
+    const prefix = this.isFirst ? "" : `,
+`;
+    this.isFirst = false;
+    this.stream.write(`${prefix}${payload}`);
+  }
+  close() {
+    this.stream.write(`
+]
+`);
+    this.stream.end();
+  }
+}
+function isDebugEnabled() {
+  const raw = process.env.BOT_DEBUG;
+  if (!raw) {
+    return false;
+  }
+  return raw === "1" || raw.toLowerCase() === "true";
+}
+async function sendAndWait(session, prompt, eventLogger) {
+  return new Promise((resolve5, reject) => {
+    let content = "";
+    let isResolved = false;
+    let timeoutId;
+    let unsubscribe;
+    const cleanup = () => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      if (unsubscribe)
+        unsubscribe();
+    };
+    const handleEvent = (event) => {
+      eventLogger?.append(event);
+      if (isDebugEnabled()) {
+        console.log(`[DEBUG] Event received: ${event.type}`);
+      }
+      if (event.type === "assistant.message_delta") {
+        const delta = event.data.deltaContent ?? "";
+        process.stdout.write(delta);
+      }
+      if (event.type === "assistant.message") {
+        content = event.data.content ?? "";
+      }
+      if (event.type === "session.idle" && !isResolved) {
+        isResolved = true;
+        console.log(`
+`);
+        cleanup();
+        resolve5(content);
+      }
+      if (event.type === "session.error") {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          reject(new Error(event.data?.message ?? "Unknown error"));
+        }
+      }
+    };
+    unsubscribe = session.on(handleEvent);
+    timeoutId = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        reject(new Error("Timeout: 等待 Copilot 回應超過 120 秒"));
+      }
+    }, 120000);
+    session.send({ prompt }).catch((err) => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        reject(err);
+      }
+    });
+  });
+}
+async function runSubtitleCorrectionAgent(config) {
+  const { vttFilePath } = config;
+  const absolutePath = path4.resolve(vttFilePath);
+  const dir = config.outputDir || path4.dirname(absolutePath);
+  const baseName = path4.basename(absolutePath, path4.extname(absolutePath));
+  const debugEvents = isDebugEnabled();
+  const eventLogPath = debugEvents ? path4.join(dir, `${baseName}-copilot-events.json`) : undefined;
+  const eventLogger = eventLogPath ? new EventLogger(eventLogPath) : undefined;
+  const correctedVttPath = path4.join(dir, `${baseName}-corrected.vtt`);
+  const correctionsPath = path4.join(dir, `${baseName}-corrections.txt`);
+  const chaptersPath = path4.join(dir, `${baseName}-chapters.txt`);
+  const summaryPath = path4.join(dir, `${baseName}-summary.txt`);
+  console.log("=".repeat(60));
+  console.log("字幕校正代理人 - 啟動");
+  console.log("=".repeat(60));
+  console.log(`輸入檔案: ${absolutePath}`);
+  console.log(`輸出目錄: ${dir}`);
+  console.log("=".repeat(60));
+  if (eventLogPath) {
+    console.log(`偵錯: Copilot events 記錄到 ${eventLogPath}`);
+  }
+  const client = new CopilotClient;
+  try {
+    await client.start();
+    const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+    const azureApiKey = process.env.AZURE_OPENAI_API_KEY;
+    const azureDeployment = process.env.AZURE_OPENAI_DEPLOYMENT;
+    const tools = [
+      readVttTool,
+      getVttCuesTool,
+      writeFileTool,
+      appendFileTool,
+      updateCueTool,
+      batchUpdateCuesTool,
+      saveVttTool
+    ];
+    let session;
+    if (azureEndpoint && azureApiKey && azureDeployment) {
+      console.log("使用 Azure OpenAI 作為模型提供者");
+      session = await client.createSession({
+        model: azureDeployment,
+        streaming: true,
+        provider: {
+          type: "azure",
+          baseUrl: azureEndpoint,
+          apiKey: azureApiKey,
+          azure: {
+            apiVersion: process.env.AZURE_OPENAI_API_VERSION || "2024-10-21"
+          }
+        },
+        tools
+      });
+    } else {
+      console.log("未找到完整的 Azure 配置，將使用預設的 GitHub Copilot 認證");
+      session = await client.createSession({
+        tools
+      });
+    }
+    console.log(`
+【步驟 1/7】讀取 VTT 檔案並分析主題方向...
+`);
+    await sendAndWait(session, `請使用 read_vtt_file 工具讀取 VTT 檔案: "${absolutePath}"
+
+讀取完成後，請仔細閱讀整個字幕內容，分析並整理出：
+1. 這部影片的主要談論內容是什麼？
+2. 影片的大致主題方向是什麼？
+3. 這是什麼類型的影片？（教學、訪談、講座、會議等）
+
+請給出簡潔但完整的分析。`, eventLogger);
+    console.log(`
+【步驟 2/7】整理主題相關的關鍵字與專有名詞...
+`);
+    await sendAndWait(session, `根據你剛才分析出的影片主題方向，請整理出這個主題領域中常見的：
+1. 專業術語與關鍵字
+2. 專有名詞（人名、產品名、技術名稱等）
+3. 常見的縮寫與其全稱
+
+【重要】請不要參考字幕的實際內容來整理這些詞彙（因為字幕可能有轉錄錯誤）。
+請根據你對這個主題領域的知識，列出這些詞彙的「正確寫法」，這將用於後續的字幕校正。`, eventLogger);
+    console.log(`
+【步驟 3-4/7】分析字幕正確性並進行校正...
+`);
+    await sendAndWait(session, `現在請逐一分析已載入的 VTT 字幕檔案中每一段 Cue 的正確性。
+
+對於每個 Cue：
+1. 檢查是否有潛在的錯字、同音字錯誤、轉錄錯誤
+2. 根據上下文和你整理出的正確關鍵字/專有名詞，推理出正確的文字
+3. 如果需要校正，請使用 batch_update_cues 工具批次更新校正後的字幕
+
+請特別注意：
+- 專業術語和專有名詞的正確性
+- 同音異義字的正確使用
+- 語句的通順和邏輯性
+- 標點符號的使用
+
+處理完成後，請報告發現了多少個需要校正的問題。`, eventLogger);
+    console.log(`
+【步驟 5/7】產生修正清單...
+`);
+    await sendAndWait(session, `請整理所有剛才進行的字幕校正，使用 write_file 工具將修正清單寫入到：
+"${correctionsPath}"
+
+修正清單的格式應該包含：
+1. 標題：字幕修正清單
+2. 修正日期與時間
+3. 原始檔案路徑
+4. 修正統計（總共修正了多少處）
+5. 每一筆修正的詳細資訊：
+   - Cue 索引與時間戳
+   - 原始文字
+   - 校正後文字
+   - 修正原因說明
+
+請以清晰易讀的格式呈現。`, eventLogger);
+    console.log(`
+【儲存校正後的 VTT 檔案】
+`);
+    await sendAndWait(session, `請使用 save_vtt 工具將校正後的字幕儲存到：
+"${correctedVttPath}"`, eventLogger);
+    console.log(`
+【步驟 6/7】建立分段章節...
+`);
+    await sendAndWait(session, `你現在是一個 **Video Chapter Segmenter**，負責分析字幕內容並將影片分割成清晰、合理的章節。
+
+## 分析準則
+- **主題轉換**: 識別主題或討論重點的變化
+- **敘事變化**: 檢測故事進展、場景變化或情節發展
+- **主題轉移**: 識別語氣、情緒或概念焦點的變化
+- **說話者變化**: 注意不同說話者或觀點之間的轉換
+- **明確的轉場提示**: 考慮字幕中提到的明確轉換（例如「接下來...」、「下一個主題」）
+
+## 章節標題要求
+- **簡潔**: 每個標題最多 10 個字
+- **描述性**: 捕捉該段落內容的本質
+- **行動導向**: 盡可能使用主動語態
+- **風格一致**: 所有標題保持統一的格式和語調
+
+## 輸出格式要求
+- **嚴格格式**: \`HH:mm:ss 章節標題\`
+- **第一章節**: 必須以 \`00:00:00 開始\` 開頭
+- **時間精確度**: 使用字幕檔案中的精確時間戳
+- **每行一章**: 每個章節獨立一行
+- **無額外格式**: 不使用項目符號、編號或特殊字元
+
+## 限制條件
+- **最少章節**: 3 個章節（包含「開始」）
+- **最多章節**: 15 個章節
+- **最短時長**: 每個章節通常至少 30 秒（自然斷點例外）
+- **完整覆蓋**: 確保從頭到尾完整覆蓋影片
+
+## 輸出範例
+\`\`\`
+00:00:00 開始
+00:00:16 開發過程的混亂
+00:00:28 規格驅動開發的啟發
+00:00:38 規格驅動開發主題曲
+00:01:03 AI輔助與測試先行
+00:01:38 團隊協作的重要性
+00:02:04 從混沌到清晰的轉變
+00:02:29 終章：持續改進的承諾
+\`\`\`
+
+請根據校正後的字幕內容，深入分析並自動建立分段章節。
+使用 write_file 工具將章節資訊寫入到：
+"${chaptersPath}"
+
+請只輸出章節清單，格式如上述範例。`, eventLogger);
+    console.log(`
+【步驟 7/7】產生內容總結...
+`);
+    await sendAndWait(session, `請根據校正後的字幕內容，用一段話總結這部影片的主要內容。
+
+總結應該：
+1. 概括影片的核心主題
+2. 提及主要討論的重點
+3. 簡述影片的價值或目標受眾
+
+請使用 write_file 工具將總結寫入到：
+"${summaryPath}"
+
+總結字數建議在 200-500 字之間，力求簡潔但資訊完整。`, eventLogger);
+    await session.destroy();
+    await client.stop();
+    console.log("=".repeat(60));
+    console.log("字幕校正完成！");
+    console.log("=".repeat(60));
+    console.log(`校正後字幕: ${correctedVttPath}`);
+    console.log(`修正清單: ${correctionsPath}`);
+    console.log(`章節資訊: ${chaptersPath}`);
+    console.log(`內容總結: ${summaryPath}`);
+    console.log("=".repeat(60));
+    return {
+      success: true,
+      correctedVttPath,
+      correctionsPath,
+      chaptersPath,
+      summaryPath
+    };
+  } catch (error) {
+    await client.stop();
+    return {
+      success: false,
+      error: String(error)
+    };
+  } finally {
+    eventLogger?.close();
+  }
+}
+
+// src/index.ts
+function printUsage() {
+  console.log(`
+字幕校正代理人 - 使用說明
+========================
+
+使用方式:
+  subtitle-correction-agent <vtt-file-path> [options]
+  subtitle-correction-agent --version
+
+參數:
+  <vtt-file-path>     VTT 字幕檔案的路徑 (必須)
+
+選項:
+  --output-dir <dir>  指定輸出目錄 (預設為 VTT 檔案所在目錄)
+  --version, -v       顯示版本與環境資訊
+  --help, -h          顯示此說明
+
+範例:
+  subtitle-correction-agent ./video.vtt
+  subtitle-correction-agent ./video.vtt --output-dir ./output
+  subtitle-correction-agent --version
+  npx @willh/subtitle-correction-agent ./video.vtt
+  subtitle-correction-agent "C:\\Videos\\lecture.vtt"
+
+輸出檔案:
+  {filename}-corrected.vtt   校正後的字幕檔案
+  {filename}-corrections.txt 修正清單
+  {filename}-chapters.txt    章節資訊
+  {filename}-summary.txt     內容總結
+
+環境變數:
+  AZURE_OPENAI_ENDPOINT      Azure OpenAI 端點 URL
+  AZURE_OPENAI_API_KEY       Azure OpenAI API 金鑰
+  AZURE_OPENAI_DEPLOYMENT    Azure OpenAI 部署名稱
+  AZURE_OPENAI_API_VERSION   API 版本 (預設: 2024-10-21)
+`);
+}
+function parseArgs(args) {
+  const result = {
+    help: false,
+    version: false
+  };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      result.version = true;
+    } else if (arg === "--output-dir" && i + 1 < args.length) {
+      result.outputDir = args[++i];
+    } else if (!arg.startsWith("-") && !result.vttFilePath) {
+      result.vttFilePath = arg;
+    }
+  }
+  return result;
+}
+function resolveProjectRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  let dir = path5.dirname(currentFile);
+  while (true) {
+    const candidate = path5.join(dir, "package.json");
+    if (fs5.existsSync(candidate)) {
+      return dir;
+    }
+    const parent = path5.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    const raw = fs5.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveAppVersion(projectRoot) {
+  if (!projectRoot) {
+    return "未知";
+  }
+  const pkgJson = readJsonFile(path5.join(projectRoot, "package.json"));
+  if (pkgJson && typeof pkgJson.version === "string") {
+    return pkgJson.version;
+  }
+  return "未知";
+}
+function resolveCopilotSdkVersion(projectRoot) {
+  if (!projectRoot) {
+    return "未知";
+  }
+  const modulePath = path5.join(projectRoot, "node_modules", "@github", "copilot-sdk", "package.json");
+  const moduleJson = readJsonFile(modulePath);
+  if (moduleJson && typeof moduleJson.version === "string") {
+    return moduleJson.version;
+  }
+  const pkgJson = readJsonFile(path5.join(projectRoot, "package.json"));
+  if (!pkgJson) {
+    return "未知";
+  }
+  const dependencies = pkgJson.dependencies;
+  const devDependencies = pkgJson.devDependencies;
+  return dependencies?.["@github/copilot-sdk"] || devDependencies?.["@github/copilot-sdk"] || "未知";
+}
+function maskSecret(value) {
+  if (!value) {
+    return "未設定";
+  }
+  if (value.length <= 8) {
+    return "*".repeat(value.length);
+  }
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+function formatEnvValue(value) {
+  if (!value) {
+    return "未設定";
+  }
+  return value;
+}
+function getEndpointHost(endpoint) {
+  try {
+    return new URL(endpoint).host || endpoint;
+  } catch {
+    return endpoint;
+  }
+}
+function printVersionInfo() {
+  const projectRoot = resolveProjectRoot();
+  const appVersion = resolveAppVersion(projectRoot);
+  const sdkVersion = resolveCopilotSdkVersion(projectRoot);
+  const nodeVersion = process.version;
+  const platform = `${process.platform} ${process.arch}`;
+  const cwd = process.cwd();
+  const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
+  const deployment = process.env.AZURE_OPENAI_DEPLOYMENT;
+  const apiVersion = process.env.AZURE_OPENAI_API_VERSION || "2024-10-21";
+  const apiKey = process.env.AZURE_OPENAI_API_KEY;
+  const isAzureConfigured = endpoint && apiKey && deployment;
+  console.log(`
+字幕校正代理人 - 版本資訊
+========================
+版本: ${appVersion}
+Node.js: ${nodeVersion}
+平台: ${platform}
+工作目錄: ${cwd}
+
+環境變數
+--------
+AZURE_OPENAI_ENDPOINT: ${endpoint ? formatEnvValue(endpoint) : "未設定"}
+AZURE_OPENAI_API_KEY: ${maskSecret(apiKey)}
+AZURE_OPENAI_DEPLOYMENT: ${formatEnvValue(deployment)}
+AZURE_OPENAI_API_VERSION: ${formatEnvValue(process.env.AZURE_OPENAI_API_VERSION)}
+TELEGRAM_BOT_TOKEN: ${maskSecret(process.env.TELEGRAM_BOT_TOKEN)}
+TELEGRAM_STARTUP_CHAT_ID: ${formatEnvValue(process.env.TELEGRAM_STARTUP_CHAT_ID)}
+OWNER_CHAT_ID: ${formatEnvValue(process.env.OWNER_CHAT_ID)}
+BOT_MAX_CONCURRENT: ${formatEnvValue(process.env.BOT_MAX_CONCURRENT)}
+KEEP_TEMP_FILES: ${formatEnvValue(process.env.KEEP_TEMP_FILES)}
+BOT_LOG_LEVEL: ${formatEnvValue(process.env.BOT_LOG_LEVEL)}
+BOT_DEBUG: ${formatEnvValue(process.env.BOT_DEBUG)}
+BOT_DATA_DIR: ${formatEnvValue(process.env.BOT_DATA_DIR)}
+
+Copilot SDK
+-----------
+SDK 版本: ${sdkVersion}
+Model: ${isAzureConfigured ? formatEnvValue(deployment) : "(Default)"}
+Streaming: true
+Provider: ${isAzureConfigured ? "Azure OpenAI" : "GitHub Copilot CLI (Default)"}
+${isAzureConfigured ? `Provider.baseUrl: ${endpoint ? getEndpointHost(endpoint) : "未設定"}
+Provider.apiVersion: ${apiVersion}
+Provider.apiKey: ${maskSecret(apiKey)}` : ""}
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.version) {
+    printVersionInfo();
+    process.exit(0);
+  }
+  if (args.help || !args.vttFilePath) {
+    printUsage();
+    process.exit(args.help ? 0 : 1);
+  }
+  const vttFilePath = path5.resolve(args.vttFilePath);
+  if (!fs5.existsSync(vttFilePath)) {
+    console.error(`錯誤: 找不到檔案 "${vttFilePath}"`);
+    process.exit(1);
+  }
+  if (!vttFilePath.toLowerCase().endsWith(".vtt")) {
+    console.error(`錯誤: 檔案必須是 .vtt 格式`);
+    process.exit(1);
+  }
+  const vttDir = path5.dirname(vttFilePath);
+  process.chdir(vttDir);
+  console.log(`工作目錄: ${vttDir}`);
+  const result = await runSubtitleCorrectionAgent({
+    vttFilePath,
+    outputDir: args.outputDir
+  });
+  if (!result.success) {
+    console.error(`錯誤: ${result.error}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+var isDirectRun = (() => {
+  const metaMain = __require.main == __require.module;
+  if (typeof metaMain === "boolean") {
+    return metaMain;
+  }
+  const entryPath = fileURLToPath(import.meta.url);
+  return Boolean(process.argv[1]) && path5.resolve(process.argv[1]) === path5.resolve(entryPath);
+})();
+if (isDirectRun) {
+  main().catch((error) => {
+    console.error("未預期的錯誤:", error);
+    process.exit(1);
+  });
+}
+export {
+  parseArgs
+};