@omnicross/cli-launcher 0.1.1 → 0.1.2

package/dist/chunk-HNYCLVZP.cjs

@@ -0,0 +1,1023 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5;var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/node-pty/dist/chunk-DA5uXrvU.js
+var _module = require('module');
+var __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __esm2, __export2, __copyProps2, __toCommonJS2, __require;
+var init_chunk_DA5uXrvU = __esm({
+  "../../node_modules/node-pty/dist/chunk-DA5uXrvU.js"() {
+    "use strict";
+    __defProp2 = Object.defineProperty;
+    __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    __getOwnPropNames2 = Object.getOwnPropertyNames;
+    __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    __esm2 = (fn, res) => function() {
+      return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+    };
+    __export2 = (target, all) => {
+      for (var name in all) __defProp2(target, name, {
+        get: all[name],
+        enumerable: true
+      });
+    };
+    __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key; i < n; i++) {
+        key = keys[i];
+        if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+        });
+      }
+      return to;
+    };
+    __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    __require = /* @__PURE__ */ _module.createRequire.call(void 0, import.meta.url);
+  }
+});
+
+// ../../node_modules/node-pty/dist/conout-DQRErfxK.js
+function getWorkerPipeName(conoutPipeName) {
+  return `${conoutPipeName}-worker`;
+}
+var ConoutWorkerMessage, init_conout;
+var init_conout_DQRErfxK = __esm({
+  "../../node_modules/node-pty/dist/conout-DQRErfxK.js"() {
+    "use strict";
+    init_chunk_DA5uXrvU();
+    init_conout = __esm2({ "src/shared/conout.ts": (() => {
+      ConoutWorkerMessage = /* @__PURE__ */ (function(ConoutWorkerMessage$1) {
+        ConoutWorkerMessage$1[ConoutWorkerMessage$1["READY"] = 1] = "READY";
+        return ConoutWorkerMessage$1;
+      })({});
+    }) });
+  }
+});
+
+// ../../node_modules/node-pty/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  createTerminal: () => createTerminal,
+  fork: () => fork,
+  native: () => native,
+  open: () => open,
+  spawn: () => spawn
+});
+var _path = require('path'); var path$1 = _interopRequireWildcard(_path);
+var _url = require('url');
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _os = require('os'); var os = _interopRequireWildcard(_os);
+
+
+var _events = require('events');
+var _child_process = require('child_process');
+var _net = require('net');
+var _worker_threads = require('worker_threads');
+var _tty = require('tty'); var tty = _interopRequireWildcard(_tty);
+function prebuildName() {
+  const tags = [];
+  tags.push(process.versions.hasOwnProperty("electron") ? "electron" : "node");
+  tags.push("abi" + process.versions.modules);
+  if (os.platform() === "linux" && fs.existsSync("/etc/alpine-release")) tags.push("musl");
+  return tags.join(".") + ".node";
+}
+function argsToCommandLine(file, args) {
+  if (isCommandLine(args)) {
+    if (args.length === 0) return file;
+    return `${argsToCommandLine(file, [])} ${args}`;
+  }
+  const argv = [file];
+  Array.prototype.push.apply(argv, args);
+  let result = "";
+  for (let argIndex = 0; argIndex < argv.length; argIndex++) {
+    if (argIndex > 0) result += " ";
+    const arg = argv[argIndex];
+    const hasLopsidedEnclosingQuote = xOr(arg[0] !== '"', arg[arg.length - 1] !== '"');
+    const hasNoEnclosingQuotes = arg[0] !== '"' && arg[arg.length - 1] !== '"';
+    const quote = arg === "" || (arg.indexOf(" ") !== -1 || arg.indexOf("	") !== -1) && arg.length > 1 && (hasLopsidedEnclosingQuote || hasNoEnclosingQuotes);
+    if (quote) result += '"';
+    let bsCount = 0;
+    for (let i = 0; i < arg.length; i++) {
+      const p = arg[i];
+      if (p === "\\") bsCount++;
+      else if (p === '"') {
+        result += repeatText("\\", bsCount * 2 + 1);
+        result += '"';
+        bsCount = 0;
+      } else {
+        result += repeatText("\\", bsCount);
+        bsCount = 0;
+        result += p;
+      }
+    }
+    if (quote) {
+      result += repeatText("\\", bsCount * 2);
+      result += '"';
+    } else result += repeatText("\\", bsCount);
+  }
+  return result;
+}
+function isCommandLine(args) {
+  return typeof args === "string";
+}
+function repeatText(text, count) {
+  let result = "";
+  for (let i = 0; i < count; i++) result += text;
+  return result;
+}
+function xOr(arg1, arg2) {
+  return arg1 && !arg2 || !arg1 && arg2;
+}
+function assign(target, ...sources) {
+  sources.forEach((source) => Object.keys(source).forEach((key) => target[key] = source[key]));
+  return target;
+}
+function spawn(file, args, opt) {
+  return new terminalCtor(file, args, opt);
+}
+function fork(file, args, opt) {
+  return new terminalCtor(file, args, opt);
+}
+function createTerminal(file, args, opt) {
+  return new terminalCtor(file, args, opt);
+}
+function open(options) {
+  return terminalCtor.open(options);
+}
+var getFilename, getDirname, __dirname, init_esm_shims, pathToBuild, ptyPath, init_prebuild_file_path, EventEmitter2, init_eventEmitter2, DEFAULT_COLS, DEFAULT_ROWS, FLOW_CONTROL_PAUSE, FLOW_CONTROL_RESUME, Terminal, init_terminal, FLUSH_DATA_INTERVAL$1, ConoutConnection, init_windowsConoutConnection, conptyNative, winptyNative, FLUSH_DATA_INTERVAL, WindowsPtyAgent, init_windowsPtyAgent, init_utils, windowsTerminal_exports, DEFAULT_FILE$1, DEFAULT_NAME$1, WindowsTerminal, init_windowsTerminal, pty$1, pty, init_prebuild_loader, unixTerminal_exports, helperPath, DEFAULT_FILE, DEFAULT_NAME, DESTROY_SOCKET_TIMEOUT_MS, UnixTerminal, init_unixTerminal, terminalCtor, native;
+var init_dist = __esm({
+  "../../node_modules/node-pty/dist/index.js"() {
+    "use strict";
+    init_chunk_DA5uXrvU();
+    init_conout_DQRErfxK();
+    init_esm_shims = __esm2({ "node_modules/.pnpm/tsdown@0.14.1_typescript@5.9.2/node_modules/tsdown/esm-shims.js": (() => {
+      getFilename = () => _url.fileURLToPath.call(void 0, import.meta.url);
+      getDirname = () => path$1.default.dirname(getFilename());
+      __dirname = /* @__PURE__ */ getDirname();
+    }) });
+    init_prebuild_file_path = __esm2({ "src/prebuild-file-path.ts": (() => {
+      init_esm_shims();
+      pathToBuild = path$1.resolve(__dirname, `../prebuilds/${os.platform()}-${os.arch()}/${prebuildName()}`);
+      ptyPath = fs.existsSync(pathToBuild) ? pathToBuild : null;
+    }) });
+    init_eventEmitter2 = __esm2({ "src/eventEmitter2.ts": (() => {
+      EventEmitter2 = (_class = class {constructor() { _class.prototype.__init2.call(this); }
+        __init2() {this._listeners = []}
+        
+        get event() {
+          if (!this._event) this._event = (listener) => {
+            this._listeners.push(listener);
+            const disposable = { dispose: () => {
+              for (let i = 0; i < this._listeners.length; i++) if (this._listeners[i] === listener) {
+                this._listeners.splice(i, 1);
+                return;
+              }
+            } };
+            return disposable;
+          };
+          return this._event;
+        }
+        fire(data) {
+          const queue = [];
+          for (let i = 0; i < this._listeners.length; i++) queue.push(this._listeners[i]);
+          for (let i = 0; i < queue.length; i++) queue[i].call(void 0, data);
+        }
+      }, _class);
+    }) });
+    init_terminal = __esm2({ "src/terminal.ts": (() => {
+      init_eventEmitter2();
+      DEFAULT_COLS = 80;
+      DEFAULT_ROWS = 24;
+      FLOW_CONTROL_PAUSE = "";
+      FLOW_CONTROL_RESUME = "";
+      Terminal = (_class2 = class {
+        
+        __init3() {this._pid = 0}
+        __init4() {this._fd = 0}
+        
+        
+        
+        __init5() {this._cols = 0}
+        __init6() {this._rows = 0}
+        __init7() {this._readable = false}
+        __init8() {this._writable = false}
+        
+        
+        
+        
+        __init9() {this._onData = new EventEmitter2()}
+        get onData() {
+          return this._onData.event;
+        }
+        __init10() {this._onExit = new EventEmitter2()}
+        get onExit() {
+          return this._onExit.event;
+        }
+        get pid() {
+          return this._pid;
+        }
+        get cols() {
+          return this._cols;
+        }
+        get rows() {
+          return this._rows;
+        }
+        constructor(opt) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+          this._internalee = new (0, _events.EventEmitter)();
+          this.handleFlowControl = !!_optionalChain([opt, 'optionalAccess', _ => _.handleFlowControl]);
+          this._flowControlPause = _optionalChain([opt, 'optionalAccess', _2 => _2.flowControlPause]) || FLOW_CONTROL_PAUSE;
+          this._flowControlResume = _optionalChain([opt, 'optionalAccess', _3 => _3.flowControlResume]) || FLOW_CONTROL_RESUME;
+          if (!opt) return;
+          this._checkType("name", opt.name ? opt.name : void 0, "string");
+          this._checkType("cols", opt.cols ? opt.cols : void 0, "number");
+          this._checkType("rows", opt.rows ? opt.rows : void 0, "number");
+          this._checkType("cwd", opt.cwd ? opt.cwd : void 0, "string");
+          this._checkType("env", opt.env ? opt.env : void 0, "object");
+          this._checkType("uid", opt.uid ? opt.uid : void 0, "number");
+          this._checkType("gid", opt.gid ? opt.gid : void 0, "number");
+          this._checkType("encoding", opt.encoding ? opt.encoding : void 0, "string");
+        }
+        write(data) {
+          if (this.handleFlowControl) {
+            if (data === this._flowControlPause) {
+              this.pause();
+              return;
+            }
+            if (data === this._flowControlResume) {
+              this.resume();
+              return;
+            }
+          }
+          this._write(data);
+        }
+        _forwardEvents() {
+          this.on("data", (e) => this._onData.fire(e));
+          this.on("exit", (exitCode, signal) => this._onExit.fire({
+            exitCode,
+            signal
+          }));
+        }
+        _checkType(name, value, type, allowArray = false) {
+          if (value === void 0) return;
+          if (allowArray) {
+            if (Array.isArray(value)) {
+              value.forEach((v, i) => {
+                if (typeof v !== type) throw new Error(`${name}[${i}] must be a ${type} (not a ${typeof v[i]})`);
+              });
+              return;
+            }
+          }
+          if (typeof value !== type) throw new Error(`${name} must be a ${type} (not a ${typeof value})`);
+        }
+        /** See net.Socket.end */
+        end(data) {
+          this._socket.end(data);
+        }
+        /** See stream.Readable.pipe */
+        pipe(dest, options) {
+          return this._socket.pipe(dest, options);
+        }
+        /** See net.Socket.pause */
+        pause() {
+          return this._socket.pause();
+        }
+        /** See net.Socket.resume */
+        resume() {
+          return this._socket.resume();
+        }
+        /** See net.Socket.setEncoding */
+        setEncoding(encoding) {
+          if (this._socket._decoder) delete this._socket._decoder;
+          if (encoding) this._socket.setEncoding(encoding);
+        }
+        addListener(eventName, listener) {
+          this.on(eventName, listener);
+        }
+        on(eventName, listener) {
+          if (eventName === "close") {
+            this._internalee.on("close", listener);
+            return;
+          }
+          this._socket.on(eventName, listener);
+        }
+        emit(eventName, ...args) {
+          if (eventName === "close") return this._internalee.emit.apply(this._internalee, arguments);
+          return this._socket.emit.apply(this._socket, arguments);
+        }
+        listeners(eventName) {
+          return this._socket.listeners(eventName);
+        }
+        removeListener(eventName, listener) {
+          this._socket.removeListener(eventName, listener);
+        }
+        removeAllListeners(eventName) {
+          this._socket.removeAllListeners(eventName);
+        }
+        once(eventName, listener) {
+          this._socket.once(eventName, listener);
+        }
+        _close() {
+          this._socket.readable = false;
+          this.write = () => {
+          };
+          this.end = () => {
+          };
+          this._writable = false;
+          this._readable = false;
+        }
+        _parseEnv(env) {
+          const keys = Object.keys(env || {});
+          const pairs = [];
+          for (let i = 0; i < keys.length; i++) {
+            if (keys[i] === void 0) continue;
+            pairs.push(keys[i] + "=" + env[keys[i]]);
+          }
+          return pairs;
+        }
+      }, _class2);
+    }) });
+    init_windowsConoutConnection = __esm2({ "src/windowsConoutConnection.ts": (() => {
+      init_esm_shims();
+      init_conout();
+      init_eventEmitter2();
+      FLUSH_DATA_INTERVAL$1 = 1e3;
+      ConoutConnection = (_class3 = class {
+        
+        
+        __init11() {this._isDisposed = false}
+        __init12() {this._onReady = new EventEmitter2()}
+        get onReady() {
+          return this._onReady.event;
+        }
+        constructor(_conoutPipeName, _useConptyDll) {;_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);
+          this._conoutPipeName = _conoutPipeName;
+          this._useConptyDll = _useConptyDll;
+          const workerData$1 = { conoutPipeName: _conoutPipeName };
+          const scriptPath = __dirname.replace("node_modules.asar", "node_modules.asar.unpacked");
+          this._worker = new (0, _worker_threads.Worker)(_path.join.call(void 0, scriptPath, "worker/conoutSocketWorker.js"), { workerData: workerData$1 });
+          this._worker.on("message", (message) => {
+            switch (message) {
+              case ConoutWorkerMessage.READY:
+                this._onReady.fire();
+                return;
+              default:
+                console.warn("Unexpected ConoutWorkerMessage", message);
+            }
+          });
+        }
+        dispose() {
+          if (!this._useConptyDll && this._isDisposed) return;
+          this._isDisposed = true;
+          this._drainDataAndClose();
+        }
+        connectSocket(socket) {
+          socket.connect(getWorkerPipeName(this._conoutPipeName));
+        }
+        _drainDataAndClose() {
+          if (this._drainTimeout) clearTimeout(this._drainTimeout);
+          this._drainTimeout = setTimeout(() => this._destroySocket(), FLUSH_DATA_INTERVAL$1);
+        }
+        async _destroySocket() {
+          await this._worker.terminate();
+        }
+      }, _class3);
+    }) });
+    init_windowsPtyAgent = __esm2({ "src/windowsPtyAgent.ts": (() => {
+      init_esm_shims();
+      init_windowsConoutConnection();
+      ;
+      ;
+      FLUSH_DATA_INTERVAL = 1e3;
+      WindowsPtyAgent = (_class4 = class {
+        
+        
+        __init13() {this._pid = 0}
+        __init14() {this._innerPid = 0}
+        
+        
+        
+        
+        
+        
+        get inSocket() {
+          return this._inSocket;
+        }
+        get outSocket() {
+          return this._outSocket;
+        }
+        get fd() {
+          return this._fd;
+        }
+        get innerPid() {
+          return this._innerPid;
+        }
+        get pty() {
+          return this._pty;
+        }
+        constructor(file, args, env, cwd, cols, rows, debug, _useConpty, _useConptyDll = false, conptyInheritCursor = false) {;_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);
+          this._useConpty = _useConpty;
+          this._useConptyDll = _useConptyDll;
+          if (this._useConpty === void 0 || this._useConpty === true) this._useConpty = this._getWindowsBuildNumber() >= 18309;
+          if (this._useConpty) {
+            if (!conptyNative) try {
+              conptyNative = __require("../build/Release/conpty.node");
+            } catch (outerError) {
+              try {
+                conptyNative = __require("../build/Debug/conpty.node");
+              } catch (innerError) {
+                console.error("innerError", innerError);
+                throw outerError;
+              }
+            }
+          } else if (!winptyNative) try {
+            winptyNative = __require("../build/Release/pty.node");
+          } catch (outerError) {
+            try {
+              winptyNative = __require("../build/Debug/pty.node");
+            } catch (innerError) {
+              console.error("innerError", innerError);
+              throw outerError;
+            }
+          }
+          this._ptyNative = this._useConpty ? conptyNative : winptyNative;
+          cwd = path$1.resolve(cwd);
+          const commandLine = argsToCommandLine(file, args);
+          let term;
+          if (this._useConpty) term = this._ptyNative.startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor, this._useConptyDll);
+          else {
+            term = this._ptyNative.startProcess(file, commandLine, env, cwd, cols, rows, debug);
+            this._pid = term.pid;
+            this._innerPid = term.innerPid;
+          }
+          this._fd = term.fd;
+          this._pty = term.pty;
+          this._outSocket = new (0, _net.Socket)();
+          this._outSocket.setEncoding("utf8");
+          this._conoutSocketWorker = new ConoutConnection(term.conout, this._useConptyDll);
+          this._conoutSocketWorker.onReady(() => {
+            this._conoutSocketWorker.connectSocket(this._outSocket);
+          });
+          this._outSocket.on("connect", () => {
+            this._outSocket.emit("ready_datapipe");
+          });
+          const inSocketFD = fs.openSync(term.conin, "w");
+          this._inSocket = new (0, _net.Socket)({
+            fd: inSocketFD,
+            readable: false,
+            writable: true
+          });
+          this._inSocket.setEncoding("utf8");
+          if (this._useConpty) {
+            const connect = this._ptyNative.connect(this._pty, commandLine, cwd, env, this._useConptyDll, (c) => this._$onProcessExit(c));
+            this._innerPid = connect.pid;
+          }
+        }
+        resize(cols, rows) {
+          if (this._useConpty) {
+            if (this._exitCode !== void 0) throw new Error("Cannot resize a pty that has already exited");
+            this._ptyNative.resize(this._pty, cols, rows, this._useConptyDll);
+            return;
+          }
+          this._ptyNative.resize(this._pid, cols, rows);
+        }
+        clear() {
+          if (this._useConpty) this._ptyNative.clear(this._pty, this._useConptyDll);
+        }
+        kill() {
+          if (this._useConpty) if (!this._useConptyDll) {
+            this._inSocket.readable = false;
+            this._outSocket.readable = false;
+            this._getConsoleProcessList().then((consoleProcessList) => {
+              consoleProcessList.forEach((pid) => {
+                try {
+                  process.kill(pid);
+                } catch (e) {
+                }
+              });
+            });
+            this._ptyNative.kill(this._pty, this._useConptyDll);
+            this._conoutSocketWorker.dispose();
+          } else {
+            this._inSocket.destroy();
+            this._ptyNative.kill(this._pty, this._useConptyDll);
+            this._outSocket.on("data", () => {
+              this._conoutSocketWorker.dispose();
+            });
+          }
+          else {
+            const processList = this._ptyNative.getProcessList(this._pid);
+            this._ptyNative.kill(this._pid, this._innerPid);
+            processList.forEach((pid) => {
+              try {
+                process.kill(pid);
+              } catch (e) {
+              }
+            });
+          }
+        }
+        _getConsoleProcessList() {
+          return new Promise((resolve2) => {
+            const agent = _child_process.fork.call(void 0, path$1.join(__dirname, "conpty_console_list_agent"), [this._innerPid.toString()]);
+            agent.on("message", (message) => {
+              clearTimeout(timeout);
+              resolve2(message.consoleProcessList);
+            });
+            const timeout = setTimeout(() => {
+              agent.kill();
+              resolve2([this._innerPid]);
+            }, 5e3);
+          });
+        }
+        get exitCode() {
+          if (this._useConpty) return this._exitCode;
+          const winptyExitCode = this._ptyNative.getExitCode(this._innerPid);
+          return winptyExitCode === -1 ? void 0 : winptyExitCode;
+        }
+        _getWindowsBuildNumber() {
+          const osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os.release());
+          let buildNumber = 0;
+          if (osVersion && osVersion.length === 4) buildNumber = parseInt(osVersion[3]);
+          return buildNumber;
+        }
+        _generatePipeName() {
+          return `conpty-${Math.random() * 1e7}`;
+        }
+        /**
+        * Triggered from the native side when a contpy process exits.
+        */
+        _$onProcessExit(exitCode) {
+          this._exitCode = exitCode;
+          if (!this._useConptyDll) {
+            this._flushDataAndCleanUp();
+            this._outSocket.on("data", () => this._flushDataAndCleanUp());
+          }
+        }
+        _flushDataAndCleanUp() {
+          if (this._useConptyDll) return;
+          if (this._closeTimeout) clearTimeout(this._closeTimeout);
+          this._closeTimeout = setTimeout(() => this._cleanUpProcess(), FLUSH_DATA_INTERVAL);
+        }
+        _cleanUpProcess() {
+          if (this._useConptyDll) return;
+          this._inSocket.readable = false;
+          this._outSocket.readable = false;
+          this._outSocket.destroy();
+        }
+      }, _class4);
+    }) });
+    init_utils = __esm2({ "src/utils.ts": (() => {
+    }) });
+    windowsTerminal_exports = {};
+    __export2(windowsTerminal_exports, { WindowsTerminal: () => WindowsTerminal });
+    init_windowsTerminal = __esm2({ "src/windowsTerminal.ts": (() => {
+      init_terminal();
+      init_windowsPtyAgent();
+      init_utils();
+      DEFAULT_FILE$1 = "cmd.exe";
+      DEFAULT_NAME$1 = "Windows Shell";
+      WindowsTerminal = class extends Terminal {
+        
+        
+        
+        constructor(file, args, opt) {
+          super(opt);
+          this._checkType("args", args, "string", true);
+          args = args || [];
+          file = file || DEFAULT_FILE$1;
+          opt = opt || {};
+          opt.env = opt.env || process.env;
+          if (opt.encoding) console.warn("Setting encoding on Windows is not supported");
+          const env = assign({}, opt.env);
+          this._cols = opt.cols || DEFAULT_COLS;
+          this._rows = opt.rows || DEFAULT_ROWS;
+          const cwd = opt.cwd || process.cwd();
+          const name = opt.name || env.TERM || DEFAULT_NAME$1;
+          const parsedEnv = this._parseEnv(env);
+          this._isReady = false;
+          this._deferreds = [];
+          this._agent = new WindowsPtyAgent(file, args, parsedEnv, cwd, this._cols, this._rows, false, opt.useConpty, opt.useConptyDll, opt.conptyInheritCursor);
+          this._socket = this._agent.outSocket;
+          this._pid = this._agent.innerPid;
+          this._fd = this._agent.fd;
+          this._pty = this._agent.pty;
+          this._socket.on("ready_datapipe", () => {
+            [
+              "connect",
+              "data",
+              "end",
+              "timeout",
+              "drain"
+            ].forEach((event) => {
+              this._socket.on(event, () => {
+                if (!this._isReady && event === "data") {
+                  this._isReady = true;
+                  this._deferreds.forEach((fn) => {
+                    fn.run();
+                  });
+                  this._deferreds = [];
+                }
+              });
+            });
+            this._socket.on("error", (err) => {
+              this._close();
+              if (err.code) {
+                if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO")) return;
+              }
+              if (this.listeners("error").length < 2) throw err;
+            });
+            this._socket.on("close", () => {
+              this.emit("exit", this._agent.exitCode);
+              this._close();
+            });
+          });
+          this._file = file;
+          this._name = name;
+          this._readable = true;
+          this._writable = true;
+          this._forwardEvents();
+        }
+        _write(data) {
+          this._defer(this._doWrite, data);
+        }
+        _doWrite(data) {
+          this._agent.inSocket.write(data);
+        }
+        /**
+        * openpty
+        */
+        static open(options) {
+          throw new Error("open() not supported on windows, use Fork() instead.");
+        }
+        /**
+        * TTY
+        */
+        resize(cols, rows) {
+          if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) throw new Error("resizing must be done using positive cols and rows");
+          this._deferNoArgs(() => {
+            this._agent.resize(cols, rows);
+            this._cols = cols;
+            this._rows = rows;
+          });
+        }
+        clear() {
+          this._deferNoArgs(() => {
+            this._agent.clear();
+          });
+        }
+        destroy() {
+          this._deferNoArgs(() => {
+            this.kill();
+          });
+        }
+        kill(signal) {
+          this._deferNoArgs(() => {
+            if (signal) throw new Error("Signals not supported on windows.");
+            this._close();
+            this._agent.kill();
+          });
+        }
+        _deferNoArgs(deferredFn) {
+          if (this._isReady) {
+            deferredFn.call(this);
+            return;
+          }
+          this._deferreds.push({ run: () => deferredFn.call(this) });
+        }
+        _defer(deferredFn, arg) {
+          if (this._isReady) {
+            deferredFn.call(this, arg);
+            return;
+          }
+          this._deferreds.push({ run: () => deferredFn.call(this, arg) });
+        }
+        get process() {
+          return this._name;
+        }
+        get master() {
+          throw new Error("master is not supported on Windows");
+        }
+        get slave() {
+          throw new Error("slave is not supported on Windows");
+        }
+      };
+    }) });
+    init_prebuild_loader = __esm2({ "src/prebuild-loader.ts": (() => {
+      init_prebuild_file_path();
+      ;
+      try {
+        pty$1 = __require(ptyPath || "../build/Release/pty.node");
+      } catch (outerError) {
+        try {
+          pty$1 = ptyPath ? __require("../build/Release/pty.node") : __require("../build/Debug/pty.node");
+        } catch (innerError) {
+          console.error("innerError", innerError);
+          throw outerError;
+        }
+      }
+      pty = pty$1;
+    }) });
+    unixTerminal_exports = {};
+    __export2(unixTerminal_exports, { UnixTerminal: () => UnixTerminal });
+    init_unixTerminal = __esm2({ "src/unixTerminal.ts": (() => {
+      init_esm_shims();
+      init_terminal();
+      init_utils();
+      init_prebuild_loader();
+      ;
+      helperPath = "../build/Release/spawn-helper";
+      helperPath = path$1.resolve(__dirname, helperPath);
+      helperPath = helperPath.replace("app.asar", "app.asar.unpacked");
+      helperPath = helperPath.replace("node_modules.asar", "node_modules.asar.unpacked");
+      DEFAULT_FILE = "sh";
+      DEFAULT_NAME = "xterm";
+      DESTROY_SOCKET_TIMEOUT_MS = 200;
+      UnixTerminal = (_class5 = class UnixTerminal2 extends Terminal {
+        
+        
+        
+        
+        
+        
+        __init15() {this._boundClose = false}
+        __init16() {this._emittedClose = false}
+        
+        
+        get master() {
+          return this._master;
+        }
+        get slave() {
+          return this._slave;
+        }
+        constructor(file, args, opt) {
+          super(opt);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);;
+          if (typeof args === "string") throw new Error("args as a string is not supported on unix.");
+          args = args || [];
+          file = file || DEFAULT_FILE;
+          opt = opt || {};
+          opt.env = opt.env || process.env;
+          this._cols = opt.cols || DEFAULT_COLS;
+          this._rows = opt.rows || DEFAULT_ROWS;
+          const uid = _nullishCoalesce(opt.uid, () => ( -1));
+          const gid = _nullishCoalesce(opt.gid, () => ( -1));
+          const env = assign({}, opt.env);
+          if (opt.env === process.env) this._sanitizeEnv(env);
+          const cwd = opt.cwd || process.cwd();
+          env.PWD = cwd;
+          const name = opt.name || env.TERM || DEFAULT_NAME;
+          env.TERM = name;
+          const parsedEnv = this._parseEnv(env);
+          const encoding = opt.encoding === void 0 ? "utf8" : opt.encoding;
+          const onexit = (code, signal) => {
+            if (!this._emittedClose) {
+              if (this._boundClose) return;
+              this._boundClose = true;
+              let timeout = setTimeout(() => {
+                timeout = null;
+                this._socket.destroy();
+              }, DESTROY_SOCKET_TIMEOUT_MS);
+              this.once("close", () => {
+                if (timeout !== null) clearTimeout(timeout);
+                this.emit("exit", code, signal);
+              });
+              return;
+            }
+            this.emit("exit", code, signal);
+          };
+          const term = pty.fork(file, args, parsedEnv, cwd, this._cols, this._rows, uid, gid, encoding === "utf8", helperPath, onexit);
+          this._socket = new tty.ReadStream(term.fd);
+          if (encoding !== null) this._socket.setEncoding(encoding);
+          this._socket.on("error", (err) => {
+            if (err.code) {
+              if (~err.code.indexOf("EAGAIN")) return;
+            }
+            this._close();
+            if (!this._emittedClose) {
+              this._emittedClose = true;
+              this.emit("close");
+            }
+            if (err.code) {
+              if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO")) return;
+            }
+            if (this.listeners("error").length < 2) throw err;
+          });
+          this._pid = term.pid;
+          this._fd = term.fd;
+          this._pty = term.pty;
+          this._file = file;
+          this._name = name;
+          this._readable = true;
+          this._writable = true;
+          this._socket.on("close", () => {
+            if (this._emittedClose) return;
+            this._emittedClose = true;
+            this._close();
+            this.emit("close");
+          });
+          this._forwardEvents();
+        }
+        _write(data) {
+          this._socket.write(data);
+        }
+        get fd() {
+          return this._fd;
+        }
+        get ptsName() {
+          return this._pty;
+        }
+        /**
+        * openpty
+        */
+        static open(opt) {
+          const self = Object.create(UnixTerminal2.prototype);
+          opt = opt || {};
+          if (arguments.length > 1) opt = {
+            cols: arguments[1],
+            rows: arguments[2]
+          };
+          const cols = opt.cols || DEFAULT_COLS;
+          const rows = opt.rows || DEFAULT_ROWS;
+          const encoding = opt.encoding === void 0 ? "utf8" : opt.encoding;
+          const term = pty.open(cols, rows);
+          self._master = new tty.ReadStream(term.master);
+          if (encoding !== null) self._master.setEncoding(encoding);
+          self._master.resume();
+          self._slave = new tty.ReadStream(term.slave);
+          if (encoding !== null) self._slave.setEncoding(encoding);
+          self._slave.resume();
+          self._socket = self._master;
+          self._pid = -1;
+          self._fd = term.master;
+          self._pty = term.pty;
+          self._file = process.argv[0] || "node";
+          self._name = process.env.TERM || "";
+          self._readable = true;
+          self._writable = true;
+          self._socket.on("error", (err) => {
+            self._close();
+            if (self.listeners("error").length < 2) throw err;
+          });
+          self._socket.on("close", () => {
+            self._close();
+          });
+          return self;
+        }
+        destroy() {
+          this._close();
+          this._socket.once("close", () => {
+            this.kill("SIGHUP");
+          });
+          this._socket.destroy();
+        }
+        kill(signal) {
+          try {
+            process.kill(this.pid, signal || "SIGHUP");
+          } catch (e) {
+          }
+        }
+        /**
+        * Gets the name of the process.
+        */
+        get process() {
+          if (process.platform === "darwin") {
+            const title = pty.process(this._fd);
+            return title !== "kernel_task" ? title : this._file;
+          }
+          return pty.process(this._fd, this._pty) || this._file;
+        }
+        /**
+        * TTY
+        */
+        resize(cols, rows) {
+          if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) throw new Error("resizing must be done using positive cols and rows");
+          pty.resize(this._fd, cols, rows);
+          this._cols = cols;
+          this._rows = rows;
+        }
+        clear() {
+        }
+        _sanitizeEnv(env) {
+          delete env["TMUX"];
+          delete env["TMUX_PANE"];
+          delete env["STY"];
+          delete env["WINDOW"];
+          delete env["WINDOWID"];
+          delete env["TERMCAP"];
+          delete env["COLUMNS"];
+          delete env["LINES"];
+        }
+      }, _class5);
+    }) });
+    init_prebuild_file_path();
+    if (process.platform === "win32") terminalCtor = (init_windowsTerminal(), __toCommonJS2(windowsTerminal_exports)).WindowsTerminal;
+    else terminalCtor = (init_unixTerminal(), __toCommonJS2(unixTerminal_exports)).UnixTerminal;
+    native = process.platform !== "win32" ? __require(ptyPath || "../build/Release/pty.node") : null;
+  }
+});
+
+// src/pty-adapter.ts
+var pty_adapter_exports = {};
+__export(pty_adapter_exports, {
+  buildPtyEnv: () => buildPtyEnv,
+  createPtyAdapter: () => createPtyAdapter
+});
+function buildPtyEnv(overlay) {
+  return overlay ? { ...process.env, ...overlay } : { ...process.env };
+}
+function createPtyAdapter(input) {
+  const nodePty = (init_dist(), __toCommonJS(dist_exports));
+  const shell = _nullishCoalesce(input.shell, () => ( (process.platform === "win32" ? "powershell.exe" : "/bin/bash")));
+  const pty2 = nodePty.spawn(shell, _nullishCoalesce(input.args, () => ( [])), {
+    name: "xterm-256color",
+    cols: _nullishCoalesce(input.cols, () => ( 120)),
+    rows: _nullishCoalesce(input.rows, () => ( 30)),
+    cwd: input.cwd,
+    env: buildPtyEnv(input.env)
+  });
+  const stdoutListeners = [];
+  const stderrListeners = [];
+  const dataDisposable = pty2.onData((data) => {
+    for (const cb of stdoutListeners) cb(data);
+  });
+  let exitResolve = null;
+  const exitPromise = new Promise((resolve2) => {
+    exitResolve = resolve2;
+  });
+  const exitDisposable = pty2.onExit(({ exitCode, signal }) => {
+    _optionalChain([exitResolve, 'optionalCall', _4 => _4({ code: exitCode, signal: signal != null ? String(signal) : null })]);
+  });
+  let disposed = false;
+  return {
+    pid: pty2.pid,
+    onStdout(cb) {
+      stdoutListeners.push(cb);
+    },
+    onStderr(cb) {
+      stderrListeners.push(cb);
+    },
+    stdin: {
+      write(data) {
+        if (!disposed) pty2.write(data);
+      },
+      end() {
+        if (!disposed) pty2.write("");
+      },
+      destroy() {
+      }
+    },
+    write(data) {
+      if (!disposed) pty2.write(data);
+    },
+    resize(cols, rows) {
+      if (!disposed) pty2.resize(cols, rows);
+    },
+    wait() {
+      return exitPromise;
+    },
+    kill(signal) {
+      if (disposed) return;
+      try {
+        pty2.kill(signal);
+      } catch (e2) {
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+      try {
+        pty2.kill();
+      } catch (e3) {
+      }
+    }
+  };
+}
+var init_pty_adapter = __esm({
+  "src/pty-adapter.ts"() {
+  }
+});
+
+
+
+
+
+
+
+exports.__toCommonJS = __toCommonJS; exports.buildPtyEnv = buildPtyEnv; exports.createPtyAdapter = createPtyAdapter; exports.pty_adapter_exports = pty_adapter_exports; exports.init_pty_adapter = init_pty_adapter;