pubm 0.0.0-alpha.19 → 0.0.0-alpha.20

package/bin/cli.js

@@ -1,15 +1,4368 @@
 #!/usr/bin/env node
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l2 = handlers.length, ee = new Array(l2); i < l2; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = __commonJS({
+  "node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports, module) {
+    "use strict";
+    module.exports = rfdc2;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc2(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a2, fn) {
+        const keys = Object.keys(a2);
+        const a22 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k2 = keys[i];
+          const cur = a2[k2];
+          if (typeof cur !== "object" || cur === null) {
+            a22[k2] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a22[k2] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a22[k2] = copyBuffer(cur);
+          } else {
+            a22[k2] = fn(cur);
+          }
+        }
+        return a22;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone2);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone2);
+        }
+        const o2 = {};
+        for (const k2 in o) {
+          if (Object.hasOwnProperty.call(o, k2) === false) continue;
+          const cur = o[k2];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k2] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k2] = handler(cur, clone2);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k2] = copyBuffer(cur);
+          } else {
+            o2[k2] = clone2(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k2 in o) {
+          const cur = o[k2];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k2] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k2] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k2] = copyBuffer(cur);
+          } else {
+            o2[k2] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a2, fn) {
+        const keys = Object.keys(a2);
+        const a22 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k2 = keys[i];
+          const cur = a2[k2];
+          if (typeof cur !== "object" || cur === null) {
+            a22[k2] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a22[k2] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a22[k2] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a22[k2] = refsNew[index];
+            } else {
+              a22[k2] = fn(cur);
+            }
+          }
+        }
+        return a22;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone2);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone2);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k2 in o) {
+          if (Object.hasOwnProperty.call(o, k2) === false) continue;
+          const cur = o[k2];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k2] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k2] = handler(cur, clone2);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k2] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k2] = refsNew[i];
+            } else {
+              o2[k2] = clone2(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k2 in o) {
+          const cur = o[k2];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k2] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k2] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k2] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k2] = refsNew[i];
+            } else {
+              o2[k2] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/environment@1.1.0/node_modules/environment/index.js
+var isBrowser, isNode, isBun, isDeno, isElectron, isJsDom, isWebWorker, isDedicatedWorker, isSharedWorker, isServiceWorker, platform2, isMacOs, isWindows2, isLinux, isIos, isAndroid;
+var init_environment = __esm({
+  "node_modules/.pnpm/environment@1.1.0/node_modules/environment/index.js"() {
+    "use strict";
+    isBrowser = globalThis.window?.document !== void 0;
+    isNode = globalThis.process?.versions?.node !== void 0;
+    isBun = globalThis.process?.versions?.bun !== void 0;
+    isDeno = globalThis.Deno?.version?.deno !== void 0;
+    isElectron = globalThis.process?.versions?.electron !== void 0;
+    isJsDom = globalThis.navigator?.userAgent?.includes("jsdom") === true;
+    isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+    isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
+    isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
+    isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
+    platform2 = globalThis.navigator?.userAgentData?.platform;
+    isMacOs = platform2 === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+    isWindows2 = platform2 === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+    isLinux = platform2 === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+    isIos = platform2 === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+    isAndroid = platform2 === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+  }
+});
+
+// node_modules/.pnpm/ansi-escapes@7.0.0/node_modules/ansi-escapes/base.js
+var base_exports = {};
+__export(base_exports, {
+  beep: () => beep,
+  clearScreen: () => clearScreen,
+  clearTerminal: () => clearTerminal,
+  cursorBackward: () => cursorBackward,
+  cursorDown: () => cursorDown,
+  cursorForward: () => cursorForward,
+  cursorGetPosition: () => cursorGetPosition,
+  cursorHide: () => cursorHide,
+  cursorLeft: () => cursorLeft,
+  cursorMove: () => cursorMove,
+  cursorNextLine: () => cursorNextLine,
+  cursorPrevLine: () => cursorPrevLine,
+  cursorRestorePosition: () => cursorRestorePosition,
+  cursorSavePosition: () => cursorSavePosition,
+  cursorShow: () => cursorShow,
+  cursorTo: () => cursorTo,
+  cursorUp: () => cursorUp,
+  enterAlternativeScreen: () => enterAlternativeScreen,
+  eraseDown: () => eraseDown,
+  eraseEndLine: () => eraseEndLine,
+  eraseLine: () => eraseLine,
+  eraseLines: () => eraseLines,
+  eraseScreen: () => eraseScreen,
+  eraseStartLine: () => eraseStartLine,
+  eraseUp: () => eraseUp,
+  exitAlternativeScreen: () => exitAlternativeScreen,
+  iTerm: () => iTerm,
+  image: () => image,
+  link: () => link,
+  scrollDown: () => scrollDown,
+  scrollUp: () => scrollUp
+});
+import process2 from "node:process";
+var ESC, OSC, BEL, SEP, isTerminalApp, isWindows3, cwdFunction, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beep, link, image, iTerm;
+var init_base = __esm({
+  "node_modules/.pnpm/ansi-escapes@7.0.0/node_modules/ansi-escapes/base.js"() {
+    "use strict";
+    init_environment();
+    ESC = "\x1B[";
+    OSC = "\x1B]";
+    BEL = "\x07";
+    SEP = ";";
+    isTerminalApp = !isBrowser && process2.env.TERM_PROGRAM === "Apple_Terminal";
+    isWindows3 = !isBrowser && process2.platform === "win32";
+    cwdFunction = isBrowser ? () => {
+      throw new Error("`process.cwd()` only works in Node.js, not the browser.");
+    } : process2.cwd;
+    cursorTo = (x, y) => {
+      if (typeof x !== "number") {
+        throw new TypeError("The `x` argument is required");
+      }
+      if (typeof y !== "number") {
+        return ESC + (x + 1) + "G";
+      }
+      return ESC + (y + 1) + SEP + (x + 1) + "H";
+    };
+    cursorMove = (x, y) => {
+      if (typeof x !== "number") {
+        throw new TypeError("The `x` argument is required");
+      }
+      let returnValue = "";
+      if (x < 0) {
+        returnValue += ESC + -x + "D";
+      } else if (x > 0) {
+        returnValue += ESC + x + "C";
+      }
+      if (y < 0) {
+        returnValue += ESC + -y + "A";
+      } else if (y > 0) {
+        returnValue += ESC + y + "B";
+      }
+      return returnValue;
+    };
+    cursorUp = (count = 1) => ESC + count + "A";
+    cursorDown = (count = 1) => ESC + count + "B";
+    cursorForward = (count = 1) => ESC + count + "C";
+    cursorBackward = (count = 1) => ESC + count + "D";
+    cursorLeft = ESC + "G";
+    cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
+    cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
+    cursorGetPosition = ESC + "6n";
+    cursorNextLine = ESC + "E";
+    cursorPrevLine = ESC + "F";
+    cursorHide = ESC + "?25l";
+    cursorShow = ESC + "?25h";
+    eraseLines = (count) => {
+      let clear = "";
+      for (let i = 0; i < count; i++) {
+        clear += eraseLine + (i < count - 1 ? cursorUp() : "");
+      }
+      if (count) {
+        clear += cursorLeft;
+      }
+      return clear;
+    };
+    eraseEndLine = ESC + "K";
+    eraseStartLine = ESC + "1K";
+    eraseLine = ESC + "2K";
+    eraseDown = ESC + "J";
+    eraseUp = ESC + "1J";
+    eraseScreen = ESC + "2J";
+    scrollUp = ESC + "S";
+    scrollDown = ESC + "T";
+    clearScreen = "\x1Bc";
+    clearTerminal = isWindows3 ? `${eraseScreen}${ESC}0f` : `${eraseScreen}${ESC}3J${ESC}H`;
+    enterAlternativeScreen = ESC + "?1049h";
+    exitAlternativeScreen = ESC + "?1049l";
+    beep = BEL;
+    link = (text, url) => [
+      OSC,
+      "8",
+      SEP,
+      SEP,
+      url,
+      BEL,
+      text,
+      OSC,
+      "8",
+      SEP,
+      SEP,
+      BEL
+    ].join("");
+    image = (data, options2 = {}) => {
+      let returnValue = `${OSC}1337;File=inline=1`;
+      if (options2.width) {
+        returnValue += `;width=${options2.width}`;
+      }
+      if (options2.height) {
+        returnValue += `;height=${options2.height}`;
+      }
+      if (options2.preserveAspectRatio === false) {
+        returnValue += ";preserveAspectRatio=0";
+      }
+      return returnValue + ":" + Buffer.from(data).toString("base64") + BEL;
+    };
+    iTerm = {
+      setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
+      annotation(message, options2 = {}) {
+        let returnValue = `${OSC}1337;`;
+        const hasX = options2.x !== void 0;
+        const hasY = options2.y !== void 0;
+        if ((hasX || hasY) && !(hasX && hasY && options2.length !== void 0)) {
+          throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
+        }
+        message = message.replaceAll("|", "");
+        returnValue += options2.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
+        if (options2.length > 0) {
+          returnValue += (hasX ? [message, options2.length, options2.x, options2.y] : [options2.length, message]).join("|");
+        } else {
+          returnValue += message;
+        }
+        return returnValue + BEL;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/ansi-escapes@7.0.0/node_modules/ansi-escapes/index.js
+var init_ansi_escapes = __esm({
+  "node_modules/.pnpm/ansi-escapes@7.0.0/node_modules/ansi-escapes/index.js"() {
+    "use strict";
+    init_base();
+    init_base();
+  }
+});
+
+// node_modules/.pnpm/mimic-function@5.0.1/node_modules/mimic-function/index.js
+function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
+  const { name } = to;
+  for (const property of Reflect.ownKeys(from)) {
+    copyProperty(to, from, property, ignoreNonConfigurable);
+  }
+  changePrototype(to, from);
+  changeToString(to, from, name);
+  return to;
+}
+var copyProperty, canCopyProperty, changePrototype, wrappedToString, toStringDescriptor, toStringName, changeToString;
+var init_mimic_function = __esm({
+  "node_modules/.pnpm/mimic-function@5.0.1/node_modules/mimic-function/index.js"() {
+    "use strict";
+    copyProperty = (to, from, property, ignoreNonConfigurable) => {
+      if (property === "length" || property === "prototype") {
+        return;
+      }
+      if (property === "arguments" || property === "caller") {
+        return;
+      }
+      const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
+      const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+      if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
+        return;
+      }
+      Object.defineProperty(to, property, fromDescriptor);
+    };
+    canCopyProperty = function(toDescriptor, fromDescriptor) {
+      return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+    };
+    changePrototype = (to, from) => {
+      const fromPrototype = Object.getPrototypeOf(from);
+      if (fromPrototype === Object.getPrototypeOf(to)) {
+        return;
+      }
+      Object.setPrototypeOf(to, fromPrototype);
+    };
+    wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
+${fromBody}`;
+    toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
+    toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
+    changeToString = (to, from, name) => {
+      const withName = name === "" ? "" : `with ${name.trim()}() `;
+      const newToString = wrappedToString.bind(null, withName, from.toString());
+      Object.defineProperty(newToString, "name", toStringName);
+      const { writable, enumerable, configurable } = toStringDescriptor;
+      Object.defineProperty(to, "toString", { value: newToString, writable, enumerable, configurable });
+    };
+  }
+});
+
+// node_modules/.pnpm/onetime@7.0.0/node_modules/onetime/index.js
+var calledFunctions, onetime, onetime_default;
+var init_onetime = __esm({
+  "node_modules/.pnpm/onetime@7.0.0/node_modules/onetime/index.js"() {
+    "use strict";
+    init_mimic_function();
+    calledFunctions = /* @__PURE__ */ new WeakMap();
+    onetime = (function_, options2 = {}) => {
+      if (typeof function_ !== "function") {
+        throw new TypeError("Expected a function");
+      }
+      let returnValue;
+      let callCount = 0;
+      const functionName = function_.displayName || function_.name || "<anonymous>";
+      const onetime2 = function(...arguments_) {
+        calledFunctions.set(onetime2, ++callCount);
+        if (callCount === 1) {
+          returnValue = function_.apply(this, arguments_);
+          function_ = void 0;
+        } else if (options2.throw === true) {
+          throw new Error(`Function \`${functionName}\` can only be called once`);
+        }
+        return returnValue;
+      };
+      mimicFunction(onetime2, function_);
+      calledFunctions.set(onetime2, callCount);
+      return onetime2;
+    };
+    onetime.callCount = (function_) => {
+      if (!calledFunctions.has(function_)) {
+        throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+      }
+      return calledFunctions.get(function_);
+    };
+    onetime_default = onetime;
+  }
+});
+
+// node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals = __esm({
+  "node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js"() {
+    "use strict";
+    signals = [];
+    signals.push("SIGHUP", "SIGINT", "SIGTERM");
+    if (process.platform !== "win32") {
+      signals.push(
+        "SIGALRM",
+        "SIGABRT",
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+    }
+  }
+});
+
+// node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk, kExitEmitter, global, ObjectDefineProperty, Emitter, SignalExitBase, signalExitWrap, SignalExitFallback, _hupSig, _emitter, _process, _originalProcessEmit, _originalProcessReallyExit, _sigListeners, _loaded, _SignalExit_instances, processReallyExit_fn, processEmit_fn, SignalExit, process3, onExit, load, unload;
+var init_mjs = __esm({
+  "node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js"() {
+    "use strict";
+    init_signals();
+    processOk = (process9) => !!process9 && typeof process9 === "object" && typeof process9.removeListener === "function" && typeof process9.emit === "function" && typeof process9.reallyExit === "function" && typeof process9.listeners === "function" && typeof process9.kill === "function" && typeof process9.pid === "number" && typeof process9.on === "function";
+    kExitEmitter = Symbol.for("signal-exit emitter");
+    global = globalThis;
+    ObjectDefineProperty = Object.defineProperty.bind(Object);
+    Emitter = class {
+      constructor() {
+        __publicField(this, "emitted", {
+          afterExit: false,
+          exit: false
+        });
+        __publicField(this, "listeners", {
+          afterExit: [],
+          exit: []
+        });
+        __publicField(this, "count", 0);
+        __publicField(this, "id", Math.random());
+        if (global[kExitEmitter]) {
+          return global[kExitEmitter];
+        }
+        ObjectDefineProperty(global, kExitEmitter, {
+          value: this,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
+      on(ev, fn) {
+        this.listeners[ev].push(fn);
+      }
+      removeListener(ev, fn) {
+        const list = this.listeners[ev];
+        const i = list.indexOf(fn);
+        if (i === -1) {
+          return;
+        }
+        if (i === 0 && list.length === 1) {
+          list.length = 0;
+        } else {
+          list.splice(i, 1);
+        }
+      }
+      emit(ev, code, signal) {
+        if (this.emitted[ev]) {
+          return false;
+        }
+        this.emitted[ev] = true;
+        let ret = false;
+        for (const fn of this.listeners[ev]) {
+          ret = fn(code, signal) === true || ret;
+        }
+        if (ev === "exit") {
+          ret = this.emit("afterExit", code, signal) || ret;
+        }
+        return ret;
+      }
+    };
+    SignalExitBase = class {
+    };
+    signalExitWrap = (handler) => {
+      return {
+        onExit(cb, opts) {
+          return handler.onExit(cb, opts);
+        },
+        load() {
+          return handler.load();
+        },
+        unload() {
+          return handler.unload();
+        }
+      };
+    };
+    SignalExitFallback = class extends SignalExitBase {
+      onExit() {
+        return () => {
+        };
+      }
+      load() {
+      }
+      unload() {
+      }
+    };
+    SignalExit = class extends SignalExitBase {
+      constructor(process9) {
+        super();
+        __privateAdd(this, _SignalExit_instances);
+        // "SIGHUP" throws an `ENOSYS` error on Windows,
+        // so use a supported signal instead
+        /* c8 ignore start */
+        __privateAdd(this, _hupSig, process3.platform === "win32" ? "SIGINT" : "SIGHUP");
+        /* c8 ignore stop */
+        __privateAdd(this, _emitter, new Emitter());
+        __privateAdd(this, _process);
+        __privateAdd(this, _originalProcessEmit);
+        __privateAdd(this, _originalProcessReallyExit);
+        __privateAdd(this, _sigListeners, {});
+        __privateAdd(this, _loaded, false);
+        __privateSet(this, _process, process9);
+        __privateSet(this, _sigListeners, {});
+        for (const sig of signals) {
+          __privateGet(this, _sigListeners)[sig] = () => {
+            const listeners = __privateGet(this, _process).listeners(sig);
+            let { count } = __privateGet(this, _emitter);
+            const p = process9;
+            if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+              count += p.__signal_exit_emitter__.count;
+            }
+            if (listeners.length === count) {
+              this.unload();
+              const ret = __privateGet(this, _emitter).emit("exit", null, sig);
+              const s = sig === "SIGHUP" ? __privateGet(this, _hupSig) : sig;
+              if (!ret)
+                process9.kill(process9.pid, s);
+            }
+          };
+        }
+        __privateSet(this, _originalProcessReallyExit, process9.reallyExit);
+        __privateSet(this, _originalProcessEmit, process9.emit);
+      }
+      onExit(cb, opts) {
+        if (!processOk(__privateGet(this, _process))) {
+          return () => {
+          };
+        }
+        if (__privateGet(this, _loaded) === false) {
+          this.load();
+        }
+        const ev = opts?.alwaysLast ? "afterExit" : "exit";
+        __privateGet(this, _emitter).on(ev, cb);
+        return () => {
+          __privateGet(this, _emitter).removeListener(ev, cb);
+          if (__privateGet(this, _emitter).listeners["exit"].length === 0 && __privateGet(this, _emitter).listeners["afterExit"].length === 0) {
+            this.unload();
+          }
+        };
+      }
+      load() {
+        if (__privateGet(this, _loaded)) {
+          return;
+        }
+        __privateSet(this, _loaded, true);
+        __privateGet(this, _emitter).count += 1;
+        for (const sig of signals) {
+          try {
+            const fn = __privateGet(this, _sigListeners)[sig];
+            if (fn)
+              __privateGet(this, _process).on(sig, fn);
+          } catch (_) {
+          }
+        }
+        __privateGet(this, _process).emit = (ev, ...a2) => {
+          return __privateMethod(this, _SignalExit_instances, processEmit_fn).call(this, ev, ...a2);
+        };
+        __privateGet(this, _process).reallyExit = (code) => {
+          return __privateMethod(this, _SignalExit_instances, processReallyExit_fn).call(this, code);
+        };
+      }
+      unload() {
+        if (!__privateGet(this, _loaded)) {
+          return;
+        }
+        __privateSet(this, _loaded, false);
+        signals.forEach((sig) => {
+          const listener = __privateGet(this, _sigListeners)[sig];
+          if (!listener) {
+            throw new Error("Listener not defined for signal: " + sig);
+          }
+          try {
+            __privateGet(this, _process).removeListener(sig, listener);
+          } catch (_) {
+          }
+        });
+        __privateGet(this, _process).emit = __privateGet(this, _originalProcessEmit);
+        __privateGet(this, _process).reallyExit = __privateGet(this, _originalProcessReallyExit);
+        __privateGet(this, _emitter).count -= 1;
+      }
+    };
+    _hupSig = new WeakMap();
+    _emitter = new WeakMap();
+    _process = new WeakMap();
+    _originalProcessEmit = new WeakMap();
+    _originalProcessReallyExit = new WeakMap();
+    _sigListeners = new WeakMap();
+    _loaded = new WeakMap();
+    _SignalExit_instances = new WeakSet();
+    processReallyExit_fn = function(code) {
+      if (!processOk(__privateGet(this, _process))) {
+        return 0;
+      }
+      __privateGet(this, _process).exitCode = code || 0;
+      __privateGet(this, _emitter).emit("exit", __privateGet(this, _process).exitCode, null);
+      return __privateGet(this, _originalProcessReallyExit).call(__privateGet(this, _process), __privateGet(this, _process).exitCode);
+    };
+    processEmit_fn = function(ev, ...args) {
+      const og = __privateGet(this, _originalProcessEmit);
+      if (ev === "exit" && processOk(__privateGet(this, _process))) {
+        if (typeof args[0] === "number") {
+          __privateGet(this, _process).exitCode = args[0];
+        }
+        const ret = og.call(__privateGet(this, _process), ev, ...args);
+        __privateGet(this, _emitter).emit("exit", __privateGet(this, _process).exitCode, null);
+        return ret;
+      } else {
+        return og.call(__privateGet(this, _process), ev, ...args);
+      }
+    };
+    process3 = globalThis.process;
+    ({
+      onExit: (
+        /**
+         * Called when the process is exiting, whether via signal, explicit
+         * exit, or running out of stuff to do.
+         *
+         * If the global process object is not suitable for instrumentation,
+         * then this will be a no-op.
+         *
+         * Returns a function that may be used to unload signal-exit.
+         */
+        onExit
+      ),
+      load: (
+        /**
+         * Load the listeners.  Likely you never need to call this, unless
+         * doing a rather deep integration with signal-exit functionality.
+         * Mostly exposed for the benefit of testing.
+         *
+         * @internal
+         */
+        load
+      ),
+      unload: (
+        /**
+         * Unload the listeners.  Likely you never need to call this, unless
+         * doing a rather deep integration with signal-exit functionality.
+         * Mostly exposed for the benefit of testing.
+         *
+         * @internal
+         */
+        unload
+      )
+    } = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback()));
+  }
+});
+
+// node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js
+import process4 from "node:process";
+var terminal, restoreCursor, restore_cursor_default;
+var init_restore_cursor = __esm({
+  "node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js"() {
+    "use strict";
+    init_onetime();
+    init_mjs();
+    terminal = process4.stderr.isTTY ? process4.stderr : process4.stdout.isTTY ? process4.stdout : void 0;
+    restoreCursor = terminal ? onetime_default(() => {
+      onExit(() => {
+        terminal.write("\x1B[?25h");
+      }, { alwaysLast: true });
+    }) : () => {
+    };
+    restore_cursor_default = restoreCursor;
+  }
+});
+
+// node_modules/.pnpm/cli-cursor@5.0.0/node_modules/cli-cursor/index.js
+import process5 from "node:process";
+var isHidden, cliCursor, cli_cursor_default;
+var init_cli_cursor = __esm({
+  "node_modules/.pnpm/cli-cursor@5.0.0/node_modules/cli-cursor/index.js"() {
+    "use strict";
+    init_restore_cursor();
+    isHidden = false;
+    cliCursor = {};
+    cliCursor.show = (writableStream = process5.stderr) => {
+      if (!writableStream.isTTY) {
+        return;
+      }
+      isHidden = false;
+      writableStream.write("\x1B[?25h");
+    };
+    cliCursor.hide = (writableStream = process5.stderr) => {
+      if (!writableStream.isTTY) {
+        return;
+      }
+      restore_cursor_default();
+      isHidden = true;
+      writableStream.write("\x1B[?25l");
+    };
+    cliCursor.toggle = (force, writableStream) => {
+      if (force !== void 0) {
+        isHidden = force;
+      }
+      if (isHidden) {
+        cliCursor.show(writableStream);
+      } else {
+        cliCursor.hide(writableStream);
+      }
+    };
+    cli_cursor_default = cliCursor;
+  }
+});
+
+// node_modules/.pnpm/ansi-regex@6.1.0/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const pattern = [
+    `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+  ].join("|");
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+var init_ansi_regex = __esm({
+  "node_modules/.pnpm/ansi-regex@6.1.0/node_modules/ansi-regex/index.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(regex, "");
+}
+var regex;
+var init_strip_ansi = __esm({
+  "node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js"() {
+    "use strict";
+    init_ansi_regex();
+    regex = ansiRegex();
+  }
+});
+
+// node_modules/.pnpm/get-east-asian-width@1.2.0/node_modules/get-east-asian-width/lookup.js
+function isAmbiguous(x) {
+  return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
+}
+function isFullWidth(x) {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+}
+function isWide(x) {
+  return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9800 && x <= 9811 || x === 9855 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 19968 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101632 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129672 || x >= 129680 && x <= 129725 || x >= 129727 && x <= 129733 || x >= 129742 && x <= 129755 || x >= 129760 && x <= 129768 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+}
+var init_lookup = __esm({
+  "node_modules/.pnpm/get-east-asian-width@1.2.0/node_modules/get-east-asian-width/lookup.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/.pnpm/get-east-asian-width@1.2.0/node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+var init_get_east_asian_width = __esm({
+  "node_modules/.pnpm/get-east-asian-width@1.2.0/node_modules/get-east-asian-width/index.js"() {
+    "use strict";
+    init_lookup();
+  }
+});
+
+// node_modules/.pnpm/emoji-regex@10.4.0/node_modules/emoji-regex/index.mjs
+var emoji_regex_default;
+var init_emoji_regex = __esm({
+  "node_modules/.pnpm/emoji-regex@10.4.0/node_modules/emoji-regex/index.mjs"() {
+    "use strict";
+    emoji_regex_default = () => {
+      return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
+    };
+  }
+});
+
+// node_modules/.pnpm/string-width@7.2.0/node_modules/string-width/index.js
+function stringWidth(string, options2 = {}) {
+  if (typeof string !== "string" || string.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options2;
+  if (!countAnsiEscapeCodes) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment: character } of segmenter.segment(string)) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {
+      continue;
+    }
+    if (codePoint >= 8203 && codePoint <= 8207 || codePoint === 65279) {
+      continue;
+    }
+    if (codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071) {
+      continue;
+    }
+    if (codePoint >= 55296 && codePoint <= 57343) {
+      continue;
+    }
+    if (codePoint >= 65024 && codePoint <= 65039) {
+      continue;
+    }
+    if (defaultIgnorableCodePointRegex.test(character)) {
+      continue;
+    }
+    if (emoji_regex_default().test(character)) {
+      width += 2;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+var segmenter, defaultIgnorableCodePointRegex;
+var init_string_width = __esm({
+  "node_modules/.pnpm/string-width@7.2.0/node_modules/string-width/index.js"() {
+    "use strict";
+    init_strip_ansi();
+    init_get_east_asian_width();
+    init_emoji_regex();
+    segmenter = new Intl.Segmenter();
+    defaultIgnorableCodePointRegex = /^\p{Default_Ignorable_Code_Point}$/u;
+  }
+});
+
+// node_modules/.pnpm/ansi-styles@6.2.1/node_modules/ansi-styles/index.js
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value: (red2, green2, blue2) => {
+        if (red2 === green2 && green2 === blue2) {
+          if (red2 < 8) {
+            return 16;
+          }
+          if (red2 > 248) {
+            return 231;
+          }
+          return Math.round((red2 - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red2 / 255 * 5) + 6 * Math.round(green2 / 255 * 5) + Math.round(blue2 / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value: (hex) => {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value: (code) => {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red2;
+        let green2;
+        let blue2;
+        if (code >= 232) {
+          red2 = ((code - 232) * 10 + 8) / 255;
+          green2 = red2;
+          blue2 = red2;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red2 = Math.floor(code / 36) / 5;
+          green2 = Math.floor(remainder / 6) / 5;
+          blue2 = remainder % 6 / 5;
+        }
+        const value = Math.max(red2, green2, blue2) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue2) << 2 | Math.round(green2) << 1 | Math.round(red2));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red2, green2, blue2) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red2, green2, blue2)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "node_modules/.pnpm/ansi-styles@6.2.1/node_modules/ansi-styles/index.js"() {
+    "use strict";
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red2, green2, blue2) => `\x1B[${38 + offset};2;${red2};${green2};${blue2}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
+
+// node_modules/.pnpm/wrap-ansi@9.0.0/node_modules/wrap-ansi/index.js
+var wrap_ansi_exports = {};
+__export(wrap_ansi_exports, {
+  default: () => wrapAnsi
+});
+function wrapAnsi(string, columns, options2) {
+  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(line, columns, options2)).join("\n");
+}
+var ESCAPES, END_CODE, ANSI_ESCAPE_BELL, ANSI_CSI, ANSI_OSC, ANSI_SGR_TERMINATOR, ANSI_ESCAPE_LINK, wrapAnsiCode, wrapAnsiHyperlink, wordLengths, wrapWord, stringVisibleTrimSpacesRight, exec;
+var init_wrap_ansi = __esm({
+  "node_modules/.pnpm/wrap-ansi@9.0.0/node_modules/wrap-ansi/index.js"() {
+    "use strict";
+    init_string_width();
+    init_strip_ansi();
+    init_ansi_styles();
+    ESCAPES = /* @__PURE__ */ new Set([
+      "\x1B",
+      "\x9B"
+    ]);
+    END_CODE = 39;
+    ANSI_ESCAPE_BELL = "\x07";
+    ANSI_CSI = "[";
+    ANSI_OSC = "]";
+    ANSI_SGR_TERMINATOR = "m";
+    ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+    wrapAnsiCode = (code) => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+    wrapAnsiHyperlink = (url) => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+    wordLengths = (string) => string.split(" ").map((character) => stringWidth(character));
+    wrapWord = (rows, word, columns) => {
+      const characters = [...word];
+      let isInsideEscape = false;
+      let isInsideLinkEscape = false;
+      let visible = stringWidth(stripAnsi(rows.at(-1)));
+      for (const [index, character] of characters.entries()) {
+        const characterLength = stringWidth(character);
+        if (visible + characterLength <= columns) {
+          rows[rows.length - 1] += character;
+        } else {
+          rows.push(character);
+          visible = 0;
+        }
+        if (ESCAPES.has(character)) {
+          isInsideEscape = true;
+          const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join("");
+          isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+        }
+        if (isInsideEscape) {
+          if (isInsideLinkEscape) {
+            if (character === ANSI_ESCAPE_BELL) {
+              isInsideEscape = false;
+              isInsideLinkEscape = false;
+            }
+          } else if (character === ANSI_SGR_TERMINATOR) {
+            isInsideEscape = false;
+          }
+          continue;
+        }
+        visible += characterLength;
+        if (visible === columns && index < characters.length - 1) {
+          rows.push("");
+          visible = 0;
+        }
+      }
+      if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+        rows[rows.length - 2] += rows.pop();
+      }
+    };
+    stringVisibleTrimSpacesRight = (string) => {
+      const words = string.split(" ");
+      let last = words.length;
+      while (last > 0) {
+        if (stringWidth(words[last - 1]) > 0) {
+          break;
+        }
+        last--;
+      }
+      if (last === words.length) {
+        return string;
+      }
+      return words.slice(0, last).join(" ") + words.slice(last).join("");
+    };
+    exec = (string, columns, options2 = {}) => {
+      if (options2.trim !== false && string.trim() === "") {
+        return "";
+      }
+      let returnValue = "";
+      let escapeCode;
+      let escapeUrl;
+      const lengths = wordLengths(string);
+      let rows = [""];
+      for (const [index, word] of string.split(" ").entries()) {
+        if (options2.trim !== false) {
+          rows[rows.length - 1] = rows.at(-1).trimStart();
+        }
+        let rowLength = stringWidth(rows.at(-1));
+        if (index !== 0) {
+          if (rowLength >= columns && (options2.wordWrap === false || options2.trim === false)) {
+            rows.push("");
+            rowLength = 0;
+          }
+          if (rowLength > 0 || options2.trim === false) {
+            rows[rows.length - 1] += " ";
+            rowLength++;
+          }
+        }
+        if (options2.hard && lengths[index] > columns) {
+          const remainingColumns = columns - rowLength;
+          const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+          const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+          if (breaksStartingNextLine < breaksStartingThisLine) {
+            rows.push("");
+          }
+          wrapWord(rows, word, columns);
+          continue;
+        }
+        if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+          if (options2.wordWrap === false && rowLength < columns) {
+            wrapWord(rows, word, columns);
+            continue;
+          }
+          rows.push("");
+        }
+        if (rowLength + lengths[index] > columns && options2.wordWrap === false) {
+          wrapWord(rows, word, columns);
+          continue;
+        }
+        rows[rows.length - 1] += word;
+      }
+      if (options2.trim !== false) {
+        rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+      }
+      const preString = rows.join("\n");
+      const pre = [...preString];
+      let preStringIndex = 0;
+      for (const [index, character] of pre.entries()) {
+        returnValue += character;
+        if (ESCAPES.has(character)) {
+          const { groups } = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(preString.slice(preStringIndex)) || { groups: {} };
+          if (groups.code !== void 0) {
+            const code2 = Number.parseFloat(groups.code);
+            escapeCode = code2 === END_CODE ? void 0 : code2;
+          } else if (groups.uri !== void 0) {
+            escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+          }
+        }
+        const code = ansi_styles_default.codes.get(Number(escapeCode));
+        if (pre[index + 1] === "\n") {
+          if (escapeUrl) {
+            returnValue += wrapAnsiHyperlink("");
+          }
+          if (escapeCode && code) {
+            returnValue += wrapAnsiCode(code);
+          }
+        } else if (character === "\n") {
+          if (escapeCode && code) {
+            returnValue += wrapAnsiCode(escapeCode);
+          }
+          if (escapeUrl) {
+            returnValue += wrapAnsiHyperlink(escapeUrl);
+          }
+        }
+        preStringIndex += character.length;
+      }
+      return returnValue;
+    };
+  }
+});
+
+// node_modules/.pnpm/is-fullwidth-code-point@5.0.0/node_modules/is-fullwidth-code-point/index.js
+function isFullwidthCodePoint(codePoint) {
+  if (!Number.isInteger(codePoint)) {
+    return false;
+  }
+  return eastAsianWidth(codePoint) === 2;
+}
+var init_is_fullwidth_code_point = __esm({
+  "node_modules/.pnpm/is-fullwidth-code-point@5.0.0/node_modules/is-fullwidth-code-point/index.js"() {
+    "use strict";
+    init_get_east_asian_width();
+  }
+});
+
+// node_modules/.pnpm/slice-ansi@7.1.0/node_modules/slice-ansi/index.js
+function getEndCode(code) {
+  if (endCodesSet.has(code)) {
+    return code;
+  }
+  if (endCodesMap.has(code)) {
+    return endCodesMap.get(code);
+  }
+  code = code.slice(2);
+  if (code.includes(";")) {
+    code = code[0] + "0";
+  }
+  const returnValue = ansi_styles_default.codes.get(Number.parseInt(code, 10));
+  if (returnValue) {
+    return ansi_styles_default.color.ansi(returnValue);
+  }
+  return ansi_styles_default.reset.open;
+}
+function findNumberIndex(string) {
+  for (let index = 0; index < string.length; index++) {
+    const codePoint = string.codePointAt(index);
+    if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) {
+      return index;
+    }
+  }
+  return -1;
+}
+function parseAnsiCode(string, offset) {
+  string = string.slice(offset, offset + 19);
+  const startIndex = findNumberIndex(string);
+  if (startIndex !== -1) {
+    let endIndex = string.indexOf("m", startIndex);
+    if (endIndex === -1) {
+      endIndex = string.length;
+    }
+    return string.slice(0, endIndex + 1);
+  }
+}
+function tokenize(string, endCharacter = Number.POSITIVE_INFINITY) {
+  const returnValue = [];
+  let index = 0;
+  let visibleCount = 0;
+  while (index < string.length) {
+    const codePoint = string.codePointAt(index);
+    if (ESCAPES2.has(codePoint)) {
+      const code = parseAnsiCode(string, index);
+      if (code) {
+        returnValue.push({
+          type: "ansi",
+          code,
+          endCode: getEndCode(code)
+        });
+        index += code.length;
+        continue;
+      }
+    }
+    const isFullWidth2 = isFullwidthCodePoint(codePoint);
+    const character = String.fromCodePoint(codePoint);
+    returnValue.push({
+      type: "character",
+      value: character,
+      isFullWidth: isFullWidth2
+    });
+    index += character.length;
+    visibleCount += isFullWidth2 ? 2 : character.length;
+    if (visibleCount >= endCharacter) {
+      break;
+    }
+  }
+  return returnValue;
+}
+function reduceAnsiCodes(codes) {
+  let returnValue = [];
+  for (const code of codes) {
+    if (code.code === ansi_styles_default.reset.open) {
+      returnValue = [];
+    } else if (endCodesSet.has(code.code)) {
+      returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.code);
+    } else {
+      returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.endCode);
+      returnValue.push(code);
+    }
+  }
+  return returnValue;
+}
+function undoAnsiCodes(codes) {
+  const reduced = reduceAnsiCodes(codes);
+  const endCodes = reduced.map(({ endCode }) => endCode);
+  return endCodes.reverse().join("");
+}
+function sliceAnsi(string, start, end) {
+  const tokens = tokenize(string, end);
+  let activeCodes = [];
+  let position = 0;
+  let returnValue = "";
+  let include = false;
+  for (const token of tokens) {
+    if (end !== void 0 && position >= end) {
+      break;
+    }
+    if (token.type === "ansi") {
+      activeCodes.push(token);
+      if (include) {
+        returnValue += token.code;
+      }
+    } else {
+      if (!include && position >= start) {
+        include = true;
+        activeCodes = reduceAnsiCodes(activeCodes);
+        returnValue = activeCodes.map(({ code }) => code).join("");
+      }
+      if (include) {
+        returnValue += token.value;
+      }
+      position += token.isFullWidth ? 2 : token.value.length;
+    }
+  }
+  returnValue += undoAnsiCodes(activeCodes);
+  return returnValue;
+}
+var ESCAPES2, CODE_POINT_0, CODE_POINT_9, endCodesSet, endCodesMap;
+var init_slice_ansi = __esm({
+  "node_modules/.pnpm/slice-ansi@7.1.0/node_modules/slice-ansi/index.js"() {
+    "use strict";
+    init_ansi_styles();
+    init_is_fullwidth_code_point();
+    ESCAPES2 = /* @__PURE__ */ new Set([27, 155]);
+    CODE_POINT_0 = "0".codePointAt(0);
+    CODE_POINT_9 = "9".codePointAt(0);
+    endCodesSet = /* @__PURE__ */ new Set();
+    endCodesMap = /* @__PURE__ */ new Map();
+    for (const [start, end] of ansi_styles_default.codes) {
+      endCodesSet.add(ansi_styles_default.color.ansi(end));
+      endCodesMap.set(ansi_styles_default.color.ansi(start), ansi_styles_default.color.ansi(end));
+    }
+  }
+});
+
+// node_modules/.pnpm/log-update@6.1.0/node_modules/log-update/index.js
+var log_update_exports = {};
+__export(log_update_exports, {
+  createLogUpdate: () => createLogUpdate,
+  default: () => log_update_default,
+  logUpdateStderr: () => logUpdateStderr
+});
+import process6 from "node:process";
+function createLogUpdate(stream, { showCursor = false } = {}) {
+  let previousLineCount = 0;
+  let previousWidth = getWidth(stream);
+  let previousOutput = "";
+  const reset2 = () => {
+    previousOutput = "";
+    previousWidth = getWidth(stream);
+    previousLineCount = 0;
+  };
+  const render = (...arguments_) => {
+    if (!showCursor) {
+      cli_cursor_default.hide();
+    }
+    let output = fitToTerminalHeight(stream, arguments_.join(" ") + "\n");
+    const width = getWidth(stream);
+    if (output === previousOutput && previousWidth === width) {
+      return;
+    }
+    previousOutput = output;
+    previousWidth = width;
+    output = wrapAnsi(output, width, { trim: false, hard: true, wordWrap: false });
+    stream.write(base_exports.eraseLines(previousLineCount) + output);
+    previousLineCount = output.split("\n").length;
+  };
+  render.clear = () => {
+    stream.write(base_exports.eraseLines(previousLineCount));
+    reset2();
+  };
+  render.done = () => {
+    reset2();
+    if (!showCursor) {
+      cli_cursor_default.show();
+    }
+  };
+  return render;
+}
+var defaultTerminalHeight, getWidth, fitToTerminalHeight, logUpdate, log_update_default, logUpdateStderr;
+var init_log_update = __esm({
+  "node_modules/.pnpm/log-update@6.1.0/node_modules/log-update/index.js"() {
+    "use strict";
+    init_ansi_escapes();
+    init_cli_cursor();
+    init_wrap_ansi();
+    init_slice_ansi();
+    init_strip_ansi();
+    defaultTerminalHeight = 24;
+    getWidth = ({ columns = 80 }) => columns;
+    fitToTerminalHeight = (stream, text) => {
+      const terminalHeight = stream.rows ?? defaultTerminalHeight;
+      const lines = text.split("\n");
+      const toRemove = Math.max(0, lines.length - terminalHeight);
+      return toRemove ? sliceAnsi(text, stripAnsi(lines.slice(0, toRemove).join("\n")).length + 1) : text;
+    };
+    logUpdate = createLogUpdate(process6.stdout);
+    log_update_default = logUpdate;
+    logUpdateStderr = createLogUpdate(process6.stderr);
+  }
+});
+
+// node_modules/.pnpm/is-fullwidth-code-point@4.0.0/node_modules/is-fullwidth-code-point/index.js
+function isFullwidthCodePoint2(codePoint) {
+  if (!Number.isInteger(codePoint)) {
+    return false;
+  }
+  return codePoint >= 4352 && (codePoint <= 4447 || // Hangul Jamo
+  codePoint === 9001 || // LEFT-POINTING ANGLE BRACKET
+  codePoint === 9002 || // RIGHT-POINTING ANGLE BRACKET
+  // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+  11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+  12880 <= codePoint && codePoint <= 19903 || // CJK Unified Ideographs .. Yi Radicals
+  19968 <= codePoint && codePoint <= 42182 || // Hangul Jamo Extended-A
+  43360 <= codePoint && codePoint <= 43388 || // Hangul Syllables
+  44032 <= codePoint && codePoint <= 55203 || // CJK Compatibility Ideographs
+  63744 <= codePoint && codePoint <= 64255 || // Vertical Forms
+  65040 <= codePoint && codePoint <= 65049 || // CJK Compatibility Forms .. Small Form Variants
+  65072 <= codePoint && codePoint <= 65131 || // Halfwidth and Fullwidth Forms
+  65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || // Kana Supplement
+  110592 <= codePoint && codePoint <= 110593 || // Enclosed Ideographic Supplement
+  127488 <= codePoint && codePoint <= 127569 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+  131072 <= codePoint && codePoint <= 262141);
+}
+var init_is_fullwidth_code_point2 = __esm({
+  "node_modules/.pnpm/is-fullwidth-code-point@4.0.0/node_modules/is-fullwidth-code-point/index.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/.pnpm/slice-ansi@5.0.0/node_modules/slice-ansi/index.js
+function sliceAnsi2(string, begin, end) {
+  const characters = [...string];
+  const ansiCodes = [];
+  let stringEnd = typeof end === "number" ? end : characters.length;
+  let isInsideEscape = false;
+  let ansiCode;
+  let visible = 0;
+  let output = "";
+  for (const [index, character] of characters.entries()) {
+    let leftEscape = false;
+    if (ESCAPES3.includes(character)) {
+      const code = /\d[^m]*/.exec(string.slice(index, index + 18));
+      ansiCode = code && code.length > 0 ? code[0] : void 0;
+      if (visible < stringEnd) {
+        isInsideEscape = true;
+        if (ansiCode !== void 0) {
+          ansiCodes.push(ansiCode);
+        }
+      }
+    } else if (isInsideEscape && character === "m") {
+      isInsideEscape = false;
+      leftEscape = true;
+    }
+    if (!isInsideEscape && !leftEscape) {
+      visible++;
+    }
+    if (!astralRegex.test(character) && isFullwidthCodePoint2(character.codePointAt())) {
+      visible++;
+      if (typeof end !== "number") {
+        stringEnd++;
+      }
+    }
+    if (visible > begin && visible <= stringEnd) {
+      output += character;
+    } else if (visible === begin && !isInsideEscape && ansiCode !== void 0) {
+      output = checkAnsi(ansiCodes);
+    } else if (visible >= stringEnd) {
+      output += checkAnsi(ansiCodes, true, ansiCode);
+      break;
+    }
+  }
+  return output;
+}
+var astralRegex, ESCAPES3, wrapAnsi2, checkAnsi;
+var init_slice_ansi2 = __esm({
+  "node_modules/.pnpm/slice-ansi@5.0.0/node_modules/slice-ansi/index.js"() {
+    "use strict";
+    init_is_fullwidth_code_point2();
+    init_ansi_styles();
+    astralRegex = /^[\uD800-\uDBFF][\uDC00-\uDFFF]$/;
+    ESCAPES3 = [
+      "\x1B",
+      "\x9B"
+    ];
+    wrapAnsi2 = (code) => `${ESCAPES3[0]}[${code}m`;
+    checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => {
+      let output = [];
+      ansiCodes = [...ansiCodes];
+      for (let ansiCode of ansiCodes) {
+        const ansiCodeOrigin = ansiCode;
+        if (ansiCode.includes(";")) {
+          ansiCode = ansiCode.split(";")[0][0] + "0";
+        }
+        const item = ansi_styles_default.codes.get(Number.parseInt(ansiCode, 10));
+        if (item) {
+          const indexEscape = ansiCodes.indexOf(item.toString());
+          if (indexEscape === -1) {
+            output.push(wrapAnsi2(isEscapes ? item : ansiCodeOrigin));
+          } else {
+            ansiCodes.splice(indexEscape, 1);
+          }
+        } else if (isEscapes) {
+          output.push(wrapAnsi2(0));
+          break;
+        } else {
+          output.push(wrapAnsi2(ansiCodeOrigin));
+        }
+      }
+      if (isEscapes) {
+        output = output.filter((element, index) => output.indexOf(element) === index);
+        if (endAnsiCode !== void 0) {
+          const fistEscapeCode = wrapAnsi2(ansi_styles_default.codes.get(Number.parseInt(endAnsiCode, 10)));
+          output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
+        }
+      }
+      return output.join("");
+    };
+  }
+});
+
+// node_modules/.pnpm/cli-truncate@4.0.0/node_modules/cli-truncate/index.js
+var cli_truncate_exports = {};
+__export(cli_truncate_exports, {
+  default: () => cliTruncate
+});
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
+  if (string.charAt(wantedIndex) === " ") {
+    return wantedIndex;
+  }
+  const direction = shouldSearchRight ? 1 : -1;
+  for (let index = 0; index <= 3; index++) {
+    const finalIndex = wantedIndex + index * direction;
+    if (string.charAt(finalIndex) === " ") {
+      return finalIndex;
+    }
+  }
+  return wantedIndex;
+}
+function cliTruncate(text, columns, options2 = {}) {
+  const {
+    position = "end",
+    space = false,
+    preferTruncationOnSpace = false
+  } = options2;
+  let { truncationCharacter = "\u2026" } = options2;
+  if (typeof text !== "string") {
+    throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+  }
+  if (typeof columns !== "number") {
+    throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+  }
+  if (columns < 1) {
+    return "";
+  }
+  if (columns === 1) {
+    return truncationCharacter;
+  }
+  const length = stringWidth(text);
+  if (length <= columns) {
+    return text;
+  }
+  if (position === "start") {
+    if (preferTruncationOnSpace) {
+      const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+      return truncationCharacter + sliceAnsi2(text, nearestSpace, length).trim();
+    }
+    if (space === true) {
+      truncationCharacter += " ";
+    }
+    return truncationCharacter + sliceAnsi2(text, length - columns + stringWidth(truncationCharacter), length);
+  }
+  if (position === "middle") {
+    if (space === true) {
+      truncationCharacter = ` ${truncationCharacter} `;
+    }
+    const half = Math.floor(columns / 2);
+    if (preferTruncationOnSpace) {
+      const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+      const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
+      return sliceAnsi2(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + sliceAnsi2(text, spaceNearSecondBreakPoint, length).trim();
+    }
+    return sliceAnsi2(text, 0, half) + truncationCharacter + sliceAnsi2(text, length - (columns - half) + stringWidth(truncationCharacter), length);
+  }
+  if (position === "end") {
+    if (preferTruncationOnSpace) {
+      const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+      return sliceAnsi2(text, 0, nearestSpace) + truncationCharacter;
+    }
+    if (space === true) {
+      truncationCharacter = ` ${truncationCharacter}`;
+    }
+    return sliceAnsi2(text, 0, columns - stringWidth(truncationCharacter)) + truncationCharacter;
+  }
+  throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+}
+var init_cli_truncate = __esm({
+  "node_modules/.pnpm/cli-truncate@4.0.0/node_modules/cli-truncate/index.js"() {
+    "use strict";
+    init_slice_ansi2();
+    init_string_width();
+  }
+});
 
 // src/cli.ts
 import cac from "cac";
 import semver2 from "semver";
 
+// node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+var eventemitter3_default = import_index.default;
+
+// node_modules/.pnpm/colorette@2.0.20/node_modules/colorette/index.js
+import * as tty from "tty";
+var {
+  env = {},
+  argv = [],
+  platform = ""
+} = typeof process === "undefined" ? {} : process;
+var isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+var isForced = "FORCE_COLOR" in env || argv.includes("--color");
+var isWindows = platform === "win32";
+var isDumbTerminal = env.TERM === "dumb";
+var isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+var isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+var clearBleed = (index, string, open2, close, replace) => index < 0 ? open2 + string + close : open2 + replaceClose(index, string, close, replace) + close;
+var filterEmpty = (open2, close, replace = open2, at = open2.length + 1) => (string) => string || !(string === "" || string === void 0) ? clearBleed(
+  ("" + string).indexOf(close, at),
+  string,
+  open2,
+  close,
+  replace
+) : "";
+var init = (open2, close, replace) => filterEmpty(`\x1B[${open2}m`, `\x1B[${close}m`, replace);
+var colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49)
+};
+var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce(
+  (colors2, key) => ({ ...colors2, [key]: String }),
+  {}
+);
+var {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright
+} = createColors();
+
+// node_modules/.pnpm/listr2@8.2.5_patch_hash=dzzw7eoo3mv4jvfzuqul4v6lc4/node_modules/listr2/dist/index.js
+var import_rfdc = __toESM(require_rfdc(), 1);
+import { format } from "util";
+import { EOL } from "os";
+import { StringDecoder } from "string_decoder";
+import { EOL as EOL2 } from "os";
+import { Writable } from "stream";
+import { EOL as EOL3 } from "os";
+import { randomUUID } from "crypto";
+var __defProp2 = Object.defineProperty;
+var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+var ANSI_ESCAPE = "\x1B[";
+var ANSI_ESCAPE_CODES = {
+  CURSOR_HIDE: ANSI_ESCAPE + "?25l",
+  CURSOR_SHOW: ANSI_ESCAPE + "?25h"
+};
+var ListrTaskState = /* @__PURE__ */ ((ListrTaskState2) => {
+  ListrTaskState2["WAITING"] = "WAITING";
+  ListrTaskState2["STARTED"] = "STARTED";
+  ListrTaskState2["COMPLETED"] = "COMPLETED";
+  ListrTaskState2["FAILED"] = "FAILED";
+  ListrTaskState2["SKIPPED"] = "SKIPPED";
+  ListrTaskState2["ROLLING_BACK"] = "ROLLING_BACK";
+  ListrTaskState2["ROLLED_BACK"] = "ROLLED_BACK";
+  ListrTaskState2["RETRY"] = "RETRY";
+  ListrTaskState2["PAUSED"] = "PAUSED";
+  ListrTaskState2["PROMPT"] = "PROMPT";
+  ListrTaskState2["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
+  ListrTaskState2["PROMPT_FAILED"] = "PROMPT_FAILED";
+  return ListrTaskState2;
+})(ListrTaskState || {});
+var _a;
+var EventManager = (_a = class {
+  constructor() {
+    __publicField(this, "emitter", new eventemitter3_default());
+  }
+  emit(dispatch, args) {
+    this.emitter.emit(dispatch, args);
+  }
+  on(dispatch, handler) {
+    this.emitter.addListener(dispatch, handler);
+  }
+  once(dispatch, handler) {
+    this.emitter.once(dispatch, handler);
+  }
+  off(dispatch, handler) {
+    this.emitter.off(dispatch, handler);
+  }
+  complete() {
+    this.emitter.removeAllListeners();
+  }
+}, __name(_a, "EventManager"), _a);
+var _a2;
+var BaseEventMap = (_a2 = class {
+}, __name(_a2, "BaseEventMap"), _a2);
+function isObservable(obj) {
+  return !!obj && typeof obj === "object" && typeof obj.subscribe === "function";
+}
+__name(isObservable, "isObservable");
+function isReadable(obj) {
+  return !!obj && typeof obj === "object" && obj.readable === true && typeof obj.read === "function" && typeof obj.on === "function";
+}
+__name(isReadable, "isReadable");
+function isUnicodeSupported() {
+  return !!process.env[
+    "LISTR_FORCE_UNICODE"
+    /* FORCE_UNICODE */
+  ] || process.platform !== "win32" || !!process.env.CI || !!process.env.WT_SESSION || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
+}
+__name(isUnicodeSupported, "isUnicodeSupported");
+var CLEAR_LINE_REGEX = "(?:\\u001b|\\u009b)\\[[\\=><~/#&.:=?%@~_-]*[0-9]*[\\a-ln-tqyz=><~/#&.:=?%@~_-]+";
+var BELL_REGEX = /\u0007/;
+var HYPERLINK_REGEX = /(?:\u001b\]8;;.*?\u0007.*?\u001b\]8;;\u0007)/g;
+function cleanseAnsi(chunk) {
+  const hyperlinks = chunk.match(HYPERLINK_REGEX) || [];
+  let cleansedChunk = String(chunk).replace(new RegExp(HYPERLINK_REGEX, "g"), "__HYPERLINK__").replace(new RegExp(CLEAR_LINE_REGEX, "gmi"), "").replace(new RegExp(BELL_REGEX, "gmi"), "").trim();
+  hyperlinks.forEach((link3) => {
+    cleansedChunk = cleansedChunk.replace("__HYPERLINK__", link3);
+  });
+  return cleansedChunk;
+}
+__name(cleanseAnsi, "cleanseAnsi");
+var color = createColors();
+function indent(string, count) {
+  return string.replace(/^(?!\s*$)/gm, " ".repeat(count));
+}
+__name(indent, "indent");
+var FIGURES_MAIN = {
+  warning: "\u26A0",
+  cross: "\u2716",
+  arrowDown: "\u2193",
+  tick: "\u2714",
+  arrowRight: "\u2192",
+  pointer: "\u276F",
+  checkboxOn: "\u2612",
+  arrowLeft: "\u2190",
+  squareSmallFilled: "\u25FC",
+  pointerSmall: "\u203A"
+};
+var FIGURES_FALLBACK = {
+  ...FIGURES_MAIN,
+  warning: "\u203C",
+  cross: "\xD7",
+  tick: "\u221A",
+  pointer: ">",
+  checkboxOn: "[\xD7]",
+  squareSmallFilled: "\u25A0"
+};
+var figures = isUnicodeSupported() ? FIGURES_MAIN : FIGURES_FALLBACK;
+function splat(message, ...splat2) {
+  return format(String(message), ...splat2);
+}
+__name(splat, "splat");
+var LISTR_LOGGER_STYLE = {
+  icon: {
+    [
+      "STARTED"
+      /* STARTED */
+    ]: figures.pointer,
+    [
+      "FAILED"
+      /* FAILED */
+    ]: figures.cross,
+    [
+      "SKIPPED"
+      /* SKIPPED */
+    ]: figures.arrowDown,
+    [
+      "COMPLETED"
+      /* COMPLETED */
+    ]: figures.tick,
+    [
+      "OUTPUT"
+      /* OUTPUT */
+    ]: figures.pointerSmall,
+    [
+      "TITLE"
+      /* TITLE */
+    ]: figures.arrowRight,
+    [
+      "RETRY"
+      /* RETRY */
+    ]: figures.warning,
+    [
+      "ROLLBACK"
+      /* ROLLBACK */
+    ]: figures.arrowLeft,
+    [
+      "PAUSED"
+      /* PAUSED */
+    ]: figures.squareSmallFilled
+  },
+  color: {
+    [
+      "STARTED"
+      /* STARTED */
+    ]: color.yellow,
+    [
+      "FAILED"
+      /* FAILED */
+    ]: color.red,
+    [
+      "SKIPPED"
+      /* SKIPPED */
+    ]: color.yellow,
+    [
+      "COMPLETED"
+      /* COMPLETED */
+    ]: color.green,
+    [
+      "RETRY"
+      /* RETRY */
+    ]: color.yellowBright,
+    [
+      "ROLLBACK"
+      /* ROLLBACK */
+    ]: color.redBright,
+    [
+      "PAUSED"
+      /* PAUSED */
+    ]: color.yellowBright
+  }
+};
+var LISTR_LOGGER_STDERR_LEVELS = [
+  "RETRY",
+  "ROLLBACK",
+  "FAILED"
+  /* FAILED */
+];
+var _a3;
+var ListrLogger = (_a3 = class {
+  constructor(options2) {
+    __publicField(this, "process");
+    var _a24, _b, _c;
+    this.options = options2;
+    this.options = {
+      useIcons: true,
+      toStderr: [],
+      ...options2 ?? {}
+    };
+    (_a24 = this.options).fields ?? (_a24.fields = {});
+    (_b = this.options.fields).prefix ?? (_b.prefix = []);
+    (_c = this.options.fields).suffix ?? (_c.suffix = []);
+    this.process = this.options.processOutput ?? new ProcessOutput();
+  }
+  log(level, message, options2) {
+    const output = this.format(level, message, options2);
+    if (this.options.toStderr.includes(level)) {
+      this.process.toStderr(output);
+      return;
+    }
+    this.process.toStdout(output);
+  }
+  toStdout(message, options2, eol = true) {
+    this.process.toStdout(this.format(null, message, options2), eol);
+  }
+  toStderr(message, options2, eol = true) {
+    this.process.toStderr(this.format(null, message, options2), eol);
+  }
+  wrap(message, options2) {
+    if (!message) {
+      return message;
+    }
+    return this.applyFormat(`[${message}]`, options2);
+  }
+  splat(...args) {
+    const message = args.shift() ?? "";
+    return args.length === 0 ? message : splat(message, args);
+  }
+  suffix(message, ...suffixes) {
+    suffixes.filter(Boolean).forEach((suffix) => {
+      message += this.spacing(message);
+      if (typeof suffix === "string") {
+        message += this.wrap(suffix);
+      } else if (typeof suffix === "object") {
+        suffix.args ?? (suffix.args = []);
+        if (typeof suffix.condition === "function" ? !suffix.condition(...suffix.args) : !(suffix.condition ?? true)) {
+          return message;
+        }
+        message += this.wrap(typeof suffix.field === "function" ? suffix.field(...suffix.args) : suffix.field, {
+          format: suffix?.format(...suffix.args)
+        });
+      }
+    });
+    return message;
+  }
+  prefix(message, ...prefixes) {
+    prefixes.filter(Boolean).forEach((prefix) => {
+      message = this.spacing(message) + message;
+      if (typeof prefix === "string") {
+        message = this.wrap(prefix) + message;
+      } else if (typeof prefix === "object") {
+        prefix.args ?? (prefix.args = []);
+        if (typeof prefix.condition === "function" ? !prefix.condition(...prefix.args) : !(prefix.condition ?? true)) {
+          return message;
+        }
+        message = this.wrap(typeof prefix.field === "function" ? prefix.field(...prefix.args) : prefix.field, {
+          format: prefix?.format()
+        }) + message;
+      }
+    });
+    return message;
+  }
+  fields(message, options2) {
+    if (this.options?.fields?.prefix) {
+      message = this.prefix(message, ...this.options.fields.prefix);
+    }
+    if (options2?.prefix) {
+      message = this.prefix(message, ...options2.prefix);
+    }
+    if (options2?.suffix) {
+      message = this.suffix(message, ...options2.suffix);
+    }
+    if (this.options?.fields?.suffix) {
+      message = this.suffix(message, ...this.options.fields.suffix);
+    }
+    return message;
+  }
+  icon(level, icon) {
+    if (!level) {
+      return null;
+    }
+    icon || (icon = this.options.icon?.[level]);
+    const coloring = this.options.color?.[level];
+    if (icon && coloring) {
+      icon = coloring(icon);
+    }
+    return icon;
+  }
+  format(level, message, options2) {
+    if (!Array.isArray(message)) {
+      message = [message];
+    }
+    message = this.splat(message.shift(), ...message).toString().split(EOL).filter((m) => !m || m.trim() !== "").map((m) => {
+      return this.style(
+        level,
+        this.fields(m, {
+          prefix: Array.isArray(options2?.prefix) ? options2.prefix : [options2?.prefix],
+          suffix: Array.isArray(options2?.suffix) ? options2.suffix : [options2?.suffix]
+        })
+      );
+    }).join(EOL);
+    return message;
+  }
+  style(level, message) {
+    if (!level || !message) {
+      return message;
+    }
+    const icon = this.icon(level, !this.options.useIcons && this.wrap(level));
+    if (icon) {
+      message = icon + " " + message;
+    }
+    return message;
+  }
+  applyFormat(message, options2) {
+    if (options2?.format) {
+      return options2.format(message);
+    }
+    return message;
+  }
+  spacing(message) {
+    return typeof message === "undefined" || message.trim() === "" ? "" : " ";
+  }
+}, __name(_a3, "ListrLogger"), _a3);
+var _a4;
+var ProcessOutputBuffer = (_a4 = class {
+  constructor(options2) {
+    __publicField(this, "buffer", []);
+    __publicField(this, "decoder", new StringDecoder());
+    this.options = options2;
+  }
+  get all() {
+    return this.buffer;
+  }
+  get last() {
+    return this.buffer.at(-1);
+  }
+  get length() {
+    return this.buffer.length;
+  }
+  write(data, ...args) {
+    const callback = args[args.length - 1];
+    this.buffer.push({
+      time: Date.now(),
+      stream: this.options?.stream,
+      entry: this.decoder.write(typeof data === "string" ? Buffer.from(data, typeof args[0] === "string" ? args[0] : void 0) : Buffer.from(data))
+    });
+    if (this.options?.limit) {
+      this.buffer = this.buffer.slice(-this.options.limit);
+    }
+    if (typeof callback === "function") {
+      callback();
+    }
+    return true;
+  }
+  reset() {
+    this.buffer = [];
+  }
+}, __name(_a4, "ProcessOutputBuffer"), _a4);
+var _a5;
+var ProcessOutputStream = (_a5 = class {
+  constructor(stream) {
+    __publicField(this, "method");
+    __publicField(this, "buffer");
+    this.stream = stream;
+    this.method = stream.write;
+    this.buffer = new ProcessOutputBuffer({ stream });
+  }
+  get out() {
+    return Object.assign({}, this.stream, {
+      write: this.write.bind(this)
+    });
+  }
+  hijack() {
+    this.stream.write = this.buffer.write.bind(this.buffer);
+  }
+  release() {
+    this.stream.write = this.method;
+    const buffer = [...this.buffer.all];
+    this.buffer.reset();
+    return buffer;
+  }
+  write(...args) {
+    return this.method.apply(this.stream, args);
+  }
+}, __name(_a5, "ProcessOutputStream"), _a5);
+var _a6;
+var ProcessOutput = (_a6 = class {
+  constructor(stdout, stderr, options2) {
+    __publicField(this, "stream");
+    __publicField(this, "active");
+    this.options = options2;
+    this.stream = {
+      stdout: new ProcessOutputStream(stdout ?? process.stdout),
+      stderr: new ProcessOutputStream(stderr ?? process.stderr)
+    };
+    this.options = {
+      dump: ["stdout", "stderr"],
+      leaveEmptyLine: true,
+      ...options2
+    };
+  }
+  get stdout() {
+    return this.stream.stdout.out;
+  }
+  get stderr() {
+    return this.stream.stderr.out;
+  }
+  hijack() {
+    if (this.active) {
+      throw new Error("ProcessOutput has been already hijacked!");
+    }
+    this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_HIDE);
+    Object.values(this.stream).forEach((stream) => stream.hijack());
+    this.active = true;
+  }
+  release() {
+    const output = Object.entries(this.stream).map(([name, stream]) => ({ name, buffer: stream.release() })).filter((output2) => this.options.dump.includes(output2.name)).flatMap((output2) => output2.buffer).sort((a2, b) => a2.time - b.time).map((message) => {
+      return {
+        ...message,
+        entry: cleanseAnsi(message.entry)
+      };
+    }).filter((message) => message.entry);
+    if (output.length > 0) {
+      if (this.options.leaveEmptyLine) {
+        this.stdout.write(EOL2);
+      }
+      output.forEach((message) => {
+        const stream = message.stream ?? this.stdout;
+        stream.write(message.entry + EOL2);
+      });
+    }
+    this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_SHOW);
+    this.active = false;
+  }
+  toStdout(buffer, eol = true) {
+    if (eol) {
+      buffer = buffer + EOL2;
+    }
+    return this.stream.stdout.write(buffer);
+  }
+  toStderr(buffer, eol = true) {
+    if (eol) {
+      buffer = buffer + EOL2;
+    }
+    return this.stream.stderr.write(buffer);
+  }
+}, __name(_a6, "ProcessOutput"), _a6);
+function createWritable(cb) {
+  const writable = new Writable();
+  writable.rows = Infinity;
+  writable.columns = Infinity;
+  writable.write = (chunk) => {
+    cb(chunk.toString());
+    return true;
+  };
+  return writable;
+}
+__name(createWritable, "createWritable");
+var _a7;
+var ListrPromptAdapter = (_a7 = class {
+  constructor(task, wrapper) {
+    __publicField(this, "state");
+    this.task = task;
+    this.wrapper = wrapper;
+  }
+  reportStarted() {
+    this.state = this.task.state;
+    if (this.task.prompt) {
+      throw new PromptError("There is already an active prompt attached to this task which may not be cleaned up properly.");
+    }
+    this.task.prompt = this;
+    this.task.state$ = "PROMPT";
+  }
+  reportFailed() {
+    this.task.state$ = "PROMPT_FAILED";
+    this.restoreState();
+  }
+  reportCompleted() {
+    this.task.state$ = "PROMPT_COMPLETED";
+    this.restoreState();
+  }
+  restoreState() {
+    this.task.prompt = void 0;
+    if (this.state) {
+      this.task.state = this.state;
+    }
+  }
+}, __name(_a7, "ListrPromptAdapter"), _a7);
+var _a8;
+var Spinner = (_a8 = class {
+  constructor() {
+    __publicField(this, "spinner", !isUnicodeSupported() ? ["-", "\\", "|", "/"] : ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]);
+    __publicField(this, "id");
+    __publicField(this, "spinnerPosition", 0);
+  }
+  spin() {
+    this.spinnerPosition = ++this.spinnerPosition % this.spinner.length;
+  }
+  fetch() {
+    return this.spinner[this.spinnerPosition];
+  }
+  isRunning() {
+    return !!this.id;
+  }
+  start(cb, interval = 100) {
+    this.id = setInterval(() => {
+      this.spin();
+      if (cb) {
+        cb();
+      }
+    }, interval);
+  }
+  stop() {
+    clearInterval(this.id);
+  }
+}, __name(_a8, "Spinner"), _a8);
+var LISTR_DEFAULT_RENDERER_STYLE = {
+  icon: {
+    [
+      "SKIPPED_WITH_COLLAPSE"
+      /* SKIPPED_WITH_COLLAPSE */
+    ]: figures.arrowDown,
+    [
+      "SKIPPED_WITHOUT_COLLAPSE"
+      /* SKIPPED_WITHOUT_COLLAPSE */
+    ]: figures.warning,
+    [
+      "OUTPUT"
+      /* OUTPUT */
+    ]: figures.pointerSmall,
+    [
+      "OUTPUT_WITH_BOTTOMBAR"
+      /* OUTPUT_WITH_BOTTOMBAR */
+    ]: figures.pointerSmall,
+    [
+      "PENDING"
+      /* PENDING */
+    ]: figures.pointer,
+    [
+      "COMPLETED"
+      /* COMPLETED */
+    ]: figures.tick,
+    [
+      "COMPLETED_WITH_FAILED_SUBTASKS"
+      /* COMPLETED_WITH_FAILED_SUBTASKS */
+    ]: figures.warning,
+    [
+      "COMPLETED_WITH_SISTER_TASKS_FAILED"
+      /* COMPLETED_WITH_FAILED_SISTER_TASKS */
+    ]: figures.squareSmallFilled,
+    [
+      "RETRY"
+      /* RETRY */
+    ]: figures.warning,
+    [
+      "ROLLING_BACK"
+      /* ROLLING_BACK */
+    ]: figures.warning,
+    [
+      "ROLLED_BACK"
+      /* ROLLED_BACK */
+    ]: figures.arrowLeft,
+    [
+      "FAILED"
+      /* FAILED */
+    ]: figures.cross,
+    [
+      "FAILED_WITH_SUBTASKS"
+      /* FAILED_WITH_FAILED_SUBTASKS */
+    ]: figures.pointer,
+    [
+      "WAITING"
+      /* WAITING */
+    ]: figures.squareSmallFilled,
+    [
+      "PAUSED"
+      /* PAUSED */
+    ]: figures.squareSmallFilled
+  },
+  color: {
+    [
+      "SKIPPED_WITH_COLLAPSE"
+      /* SKIPPED_WITH_COLLAPSE */
+    ]: color.yellow,
+    [
+      "SKIPPED_WITHOUT_COLLAPSE"
+      /* SKIPPED_WITHOUT_COLLAPSE */
+    ]: color.yellow,
+    [
+      "PENDING"
+      /* PENDING */
+    ]: color.yellow,
+    [
+      "COMPLETED"
+      /* COMPLETED */
+    ]: color.green,
+    [
+      "COMPLETED_WITH_FAILED_SUBTASKS"
+      /* COMPLETED_WITH_FAILED_SUBTASKS */
+    ]: color.yellow,
+    [
+      "COMPLETED_WITH_SISTER_TASKS_FAILED"
+      /* COMPLETED_WITH_FAILED_SISTER_TASKS */
+    ]: color.red,
+    [
+      "RETRY"
+      /* RETRY */
+    ]: color.yellowBright,
+    [
+      "ROLLING_BACK"
+      /* ROLLING_BACK */
+    ]: color.redBright,
+    [
+      "ROLLED_BACK"
+      /* ROLLED_BACK */
+    ]: color.redBright,
+    [
+      "FAILED"
+      /* FAILED */
+    ]: color.red,
+    [
+      "FAILED_WITH_SUBTASKS"
+      /* FAILED_WITH_FAILED_SUBTASKS */
+    ]: color.red,
+    [
+      "WAITING"
+      /* WAITING */
+    ]: color.dim,
+    [
+      "PAUSED"
+      /* PAUSED */
+    ]: color.yellowBright
+  }
+};
+function parseTimer(duration) {
+  const seconds = Math.floor(duration / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  let parsedTime;
+  if (seconds === 0 && minutes === 0) {
+    parsedTime = `0.${Math.floor(duration / 100)}s`;
+  }
+  if (seconds > 0) {
+    parsedTime = `${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    parsedTime = `${minutes}m${parsedTime}`;
+  }
+  return parsedTime;
+}
+__name(parseTimer, "parseTimer");
+var PRESET_TIMER = {
+  condition: true,
+  field: parseTimer,
+  format: /* @__PURE__ */ __name(() => color.dim, "format")
+};
+function parseTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return String(now.getHours()).padStart(2, "0") + ":" + String(now.getMinutes()).padStart(2, "0") + ":" + String(now.getSeconds()).padStart(2, "0");
+}
+__name(parseTimestamp, "parseTimestamp");
+var _a9;
+var DefaultRenderer = (_a9 = class {
+  constructor(tasks, options2, events) {
+    __publicField(this, "prompt");
+    __publicField(this, "activePrompt");
+    __publicField(this, "spinner");
+    __publicField(this, "logger");
+    __publicField(this, "updater");
+    __publicField(this, "truncate");
+    __publicField(this, "wrap");
+    __publicField(this, "buffer", {
+      output: /* @__PURE__ */ new Map(),
+      bottom: /* @__PURE__ */ new Map()
+    });
+    __publicField(this, "cache", {
+      render: /* @__PURE__ */ new Map(),
+      rendererOptions: /* @__PURE__ */ new Map(),
+      rendererTaskOptions: /* @__PURE__ */ new Map()
+    });
+    this.tasks = tasks;
+    this.options = options2;
+    this.events = events;
+    this.options = {
+      ..._a9.rendererOptions,
+      ...this.options,
+      icon: {
+        ...LISTR_DEFAULT_RENDERER_STYLE.icon,
+        ...options2?.icon ?? {}
+      },
+      color: {
+        ...LISTR_DEFAULT_RENDERER_STYLE.color,
+        ...options2?.color ?? {}
+      }
+    };
+    this.spinner = this.options.spinner ?? new Spinner();
+    this.logger = this.options.logger ?? new ListrLogger({ useIcons: true, toStderr: [] });
+    this.logger.options.icon = this.options.icon;
+    this.logger.options.color = this.options.color;
+  }
+  async render() {
+    const { createLogUpdate: createLogUpdate2 } = await Promise.resolve().then(() => (init_log_update(), log_update_exports));
+    const { default: truncate } = await Promise.resolve().then(() => (init_cli_truncate(), cli_truncate_exports));
+    const { default: wrap } = await Promise.resolve().then(() => (init_wrap_ansi(), wrap_ansi_exports));
+    this.updater = createLogUpdate2(this.logger.process.stdout);
+    this.truncate = truncate;
+    this.wrap = wrap;
+    this.logger.process.hijack();
+    if (!this.options?.lazy) {
+      this.spinner.start(() => {
+        this.update();
+      });
+    }
+    this.events.on("SHOUD_REFRESH_RENDER", () => {
+      this.update();
+    });
+  }
+  update() {
+    this.updater(this.create());
+  }
+  end() {
+    this.spinner.stop();
+    this.updater.clear();
+    this.updater.done();
+    if (!this.options.clearOutput) {
+      this.logger.process.toStdout(this.create({ prompt: false }));
+    }
+    this.logger.process.release();
+  }
+  create(options2) {
+    options2 = {
+      tasks: true,
+      bottomBar: true,
+      prompt: true,
+      ...options2
+    };
+    const render = [];
+    const renderTasks = this.renderer(this.tasks);
+    const renderBottomBar = this.renderBottomBar();
+    const renderPrompt = this.renderPrompt();
+    if (options2.tasks && renderTasks.length > 0) {
+      render.push(...renderTasks);
+    }
+    if (options2.bottomBar && renderBottomBar.length > 0) {
+      if (render.length > 0) {
+        render.push("");
+      }
+      render.push(...renderBottomBar);
+    }
+    if (options2.prompt && renderPrompt.length > 0) {
+      if (render.length > 0) {
+        render.push("");
+      }
+      render.push(...renderPrompt);
+    }
+    return render.join(EOL3);
+  }
+  // eslint-disable-next-line complexity
+  style(task, output = false) {
+    const rendererOptions = this.cache.rendererOptions.get(task.id);
+    if (task.isSkipped()) {
+      if (output || rendererOptions.collapseSkips) {
+        return this.logger.icon(
+          "SKIPPED_WITH_COLLAPSE"
+          /* SKIPPED_WITH_COLLAPSE */
+        );
+      } else if (rendererOptions.collapseSkips === false) {
+        return this.logger.icon(
+          "SKIPPED_WITHOUT_COLLAPSE"
+          /* SKIPPED_WITHOUT_COLLAPSE */
+        );
+      }
+    }
+    if (output) {
+      if (this.shouldOutputToBottomBar(task)) {
+        return this.logger.icon(
+          "OUTPUT_WITH_BOTTOMBAR"
+          /* OUTPUT_WITH_BOTTOMBAR */
+        );
+      }
+      return this.logger.icon(
+        "OUTPUT"
+        /* OUTPUT */
+      );
+    }
+    if (task.hasSubtasks()) {
+      if (task.isStarted() || task.isPrompt() && rendererOptions.showSubtasks !== false && !task.subtasks.every((subtask) => !subtask.hasTitle())) {
+        return this.logger.icon(
+          "PENDING"
+          /* PENDING */
+        );
+      } else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) {
+        return this.logger.icon(
+          "COMPLETED_WITH_FAILED_SUBTASKS"
+          /* COMPLETED_WITH_FAILED_SUBTASKS */
+        );
+      } else if (task.hasFailed()) {
+        return this.logger.icon(
+          "FAILED_WITH_SUBTASKS"
+          /* FAILED_WITH_FAILED_SUBTASKS */
+        );
+      }
+    }
+    if (task.isStarted() || task.isPrompt()) {
+      return this.logger.icon("PENDING", !this.options?.lazy && this.spinner.fetch());
+    } else if (task.isCompleted()) {
+      return this.logger.icon(
+        "COMPLETED"
+        /* COMPLETED */
+      );
+    } else if (task.isRetrying()) {
+      return this.logger.icon("RETRY", !this.options?.lazy && this.spinner.fetch());
+    } else if (task.isRollingBack()) {
+      return this.logger.icon("ROLLING_BACK", !this.options?.lazy && this.spinner.fetch());
+    } else if (task.hasRolledBack()) {
+      return this.logger.icon(
+        "ROLLED_BACK"
+        /* ROLLED_BACK */
+      );
+    } else if (task.hasFailed()) {
+      return this.logger.icon(
+        "FAILED"
+        /* FAILED */
+      );
+    } else if (task.isPaused()) {
+      return this.logger.icon(
+        "PAUSED"
+        /* PAUSED */
+      );
+    }
+    return this.logger.icon(
+      "WAITING"
+      /* WAITING */
+    );
+  }
+  format(message, icon, level) {
+    if (message.trim() === "") {
+      return [];
+    }
+    if (icon) {
+      message = icon + " " + message;
+    }
+    let parsed;
+    const columns = (process.stdout.columns ?? 80) - level * this.options.indentation - 2;
+    switch (this.options.formatOutput) {
+      case "truncate":
+        parsed = message.split(EOL3).map((s, i) => {
+          return this.truncate(this.indent(s, i), columns);
+        });
+        break;
+      case "wrap":
+        parsed = this.wrap(message, columns, { hard: true }).split(EOL3).map((s, i) => this.indent(s, i));
+        break;
+      default:
+        throw new ListrRendererError("Format option for the renderer is wrong.");
+    }
+    if (this.options.removeEmptyLines) {
+      parsed = parsed.filter(Boolean);
+    }
+    return parsed.map((str) => indent(str, level * this.options.indentation));
+  }
+  shouldOutputToOutputBar(task) {
+    const outputBar = this.cache.rendererTaskOptions.get(task.id).outputBar;
+    return typeof outputBar === "number" && outputBar !== 0 || typeof outputBar === "boolean" && outputBar !== false;
+  }
+  shouldOutputToBottomBar(task) {
+    const bottomBar = this.cache.rendererTaskOptions.get(task.id).bottomBar;
+    return typeof bottomBar === "number" && bottomBar !== 0 || typeof bottomBar === "boolean" && bottomBar !== false || !task.hasTitle();
+  }
+  renderer(tasks, level = 0) {
+    return tasks.flatMap((task) => {
+      if (!task.isEnabled()) {
+        return [];
+      }
+      if (this.cache.render.has(task.id)) {
+        return this.cache.render.get(task.id);
+      }
+      this.calculate(task);
+      this.setupBuffer(task);
+      const rendererOptions = this.cache.rendererOptions.get(task.id);
+      const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+      const output = [];
+      if (task.isPrompt()) {
+        if (this.activePrompt && this.activePrompt !== task.id) {
+          throw new ListrRendererError("Only one prompt can be active at the given time, please re-evaluate your task design.");
+        } else if (!this.activePrompt) {
+          task.on("PROMPT", (prompt) => {
+            const cleansed = cleanseAnsi(prompt);
+            if (cleansed) {
+              this.prompt = cleansed;
+            }
+          });
+          task.on("STATE", (state) => {
+            if (state === "PROMPT_COMPLETED" || task.hasFinalized() || task.hasReset()) {
+              this.prompt = null;
+              this.activePrompt = null;
+              task.off(
+                "PROMPT"
+                /* PROMPT */
+              );
+            }
+          });
+          this.activePrompt = task.id;
+        }
+      }
+      if (task.hasTitle()) {
+        if (!(tasks.some((task2) => task2.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) {
+          if (task.hasFailed() && rendererOptions.collapseErrors) {
+            output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
+          } else if (task.isSkipped() && rendererOptions.collapseSkips) {
+            output.push(
+              ...this.format(
+                this.logger.suffix(task.message.skip && rendererOptions.showSkipMessage ? task.message.skip : task.title, {
+                  field: "SKIPPED",
+                  condition: rendererOptions.suffixSkips,
+                  format: /* @__PURE__ */ __name(() => color.dim, "format")
+                }),
+                this.style(task),
+                level
+              )
+            );
+          } else if (task.isRetrying()) {
+            output.push(
+              ...this.format(
+                this.logger.suffix(task.title, {
+                  field: `${"RETRY"}:${task.message.retry.count}`,
+                  format: /* @__PURE__ */ __name(() => color.yellow, "format"),
+                  condition: rendererOptions.suffixRetries
+                }),
+                this.style(task),
+                level
+              )
+            );
+          } else if (task.isCompleted() && task.hasTitle() && assertFunctionOrSelf(rendererTaskOptions.timer?.condition, task.message.duration)) {
+            output.push(
+              ...this.format(
+                this.logger.suffix(task?.title, {
+                  ...rendererTaskOptions.timer,
+                  args: [task.message.duration]
+                }),
+                this.style(task),
+                level
+              )
+            );
+          } else if (task.isPaused()) {
+            output.push(
+              ...this.format(
+                this.logger.suffix(task.title, {
+                  ...rendererOptions.pausedTimer,
+                  args: [task.message.paused - Date.now()]
+                }),
+                this.style(task),
+                level
+              )
+            );
+          } else {
+            output.push(...this.format(task.title, this.style(task), level));
+          }
+        } else {
+          output.push(...this.format(task.title, this.logger.icon(
+            "COMPLETED_WITH_SISTER_TASKS_FAILED"
+            /* COMPLETED_WITH_FAILED_SISTER_TASKS */
+          ), level));
+        }
+      }
+      if (!task.hasSubtasks() || !rendererOptions.showSubtasks) {
+        if (task.hasFailed() && rendererOptions.collapseErrors === false && (rendererOptions.showErrorMessage || !rendererOptions.showSubtasks)) {
+          output.push(...this.dump(
+            task,
+            level,
+            "FAILED"
+            /* FAILED */
+          ));
+        } else if (task.isSkipped() && rendererOptions.collapseSkips === false && (rendererOptions.showSkipMessage || !rendererOptions.showSubtasks)) {
+          output.push(...this.dump(
+            task,
+            level,
+            "SKIPPED"
+            /* SKIPPED */
+          ));
+        }
+      }
+      if (task.isPending() || rendererTaskOptions.persistentOutput) {
+        output.push(...this.renderOutputBar(task, level));
+      }
+      if (
+        // check if renderer option is on first
+        rendererOptions.showSubtasks !== false && // if it doesnt have subtasks no need to check
+        task.hasSubtasks() && (task.isPending() || task.hasFinalized() && !task.hasTitle() || // have to be completed and have subtasks
+        task.isCompleted() && rendererOptions.collapseSubtasks === false && !task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === true) || // if any of the subtasks have the collapse option of
+        task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === false) || // if any of the subtasks has failed
+        task.subtasks.some((subtask) => subtask.hasFailed()) || // if any of the subtasks rolled back
+        task.subtasks.some((subtask) => subtask.hasRolledBack()))
+      ) {
+        const subtaskLevel = !task.hasTitle() ? level : level + 1;
+        const subtaskRender = this.renderer(task.subtasks, subtaskLevel);
+        output.push(...subtaskRender);
+      }
+      if (task.hasFinalized()) {
+        if (!rendererTaskOptions.persistentOutput) {
+          this.buffer.bottom.delete(task.id);
+          this.buffer.output.delete(task.id);
+        }
+      }
+      if (task.isClosed()) {
+        this.cache.render.set(task.id, output);
+        this.reset(task);
+      }
+      return output;
+    });
+  }
+  renderOutputBar(task, level) {
+    const output = this.buffer.output.get(task.id);
+    if (!output) {
+      return [];
+    }
+    return output.all.flatMap((o) => this.dump(task, level, "OUTPUT", o.entry));
+  }
+  renderBottomBar() {
+    if (this.buffer.bottom.size === 0) {
+      return [];
+    }
+    return Array.from(this.buffer.bottom.values()).flatMap((output) => output.all).sort((a2, b) => a2.time - b.time).map((output) => output.entry);
+  }
+  renderPrompt() {
+    if (!this.prompt) {
+      return [];
+    }
+    return [this.prompt];
+  }
+  calculate(task) {
+    if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) {
+      return;
+    }
+    const rendererOptions = {
+      ...this.options,
+      ...task.rendererOptions
+    };
+    this.cache.rendererOptions.set(task.id, rendererOptions);
+    this.cache.rendererTaskOptions.set(task.id, {
+      ..._a9.rendererTaskOptions,
+      timer: rendererOptions.timer,
+      ...task.rendererTaskOptions
+    });
+  }
+  setupBuffer(task) {
+    if (this.buffer.bottom.has(task.id) || this.buffer.output.has(task.id)) {
+      return;
+    }
+    const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+    if (this.shouldOutputToBottomBar(task) && !this.buffer.bottom.has(task.id)) {
+      this.buffer.bottom.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.bottomBar === "number" ? rendererTaskOptions.bottomBar : 1 }));
+      task.on("OUTPUT", (output) => {
+        const data = this.dump(task, -1, "OUTPUT", output);
+        this.buffer.bottom.get(task.id).write(data.join(EOL3));
+      });
+      task.on("STATE", (state) => {
+        switch (state) {
+          case "RETRY":
+            this.buffer.bottom.delete(task.id);
+            break;
+        }
+      });
+    } else if (this.shouldOutputToOutputBar(task) && !this.buffer.output.has(task.id)) {
+      this.buffer.output.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.outputBar === "number" ? rendererTaskOptions.outputBar : 1 }));
+      task.on("OUTPUT", (output) => {
+        this.buffer.output.get(task.id).write(output);
+      });
+      task.on("STATE", (state) => {
+        switch (state) {
+          case "RETRY":
+            this.buffer.output.delete(task.id);
+            break;
+        }
+      });
+    }
+  }
+  reset(task) {
+    this.cache.rendererOptions.delete(task.id);
+    this.cache.rendererTaskOptions.delete(task.id);
+    this.buffer.output.delete(task.id);
+  }
+  dump(task, level, source = "OUTPUT", data) {
+    if (!data) {
+      switch (source) {
+        case "OUTPUT":
+          data = task.output;
+          break;
+        case "SKIPPED":
+          data = task.message.skip;
+          break;
+        case "FAILED":
+          data = task.message.error;
+          break;
+      }
+    }
+    if (task.hasTitle() && source === "FAILED" && data === task.title || typeof data !== "string") {
+      return [];
+    }
+    if (source === "OUTPUT") {
+      data = cleanseAnsi(data);
+    }
+    return this.format(data, this.style(task, true), level + 1);
+  }
+  indent(str, i) {
+    return i > 0 ? indent(str.trim(), this.options.indentation) : str.trim();
+  }
+}, __name(_a9, "DefaultRenderer"), __publicField(_a9, "nonTTY", false), __publicField(_a9, "rendererOptions", {
+  indentation: 2,
+  clearOutput: false,
+  showSubtasks: true,
+  collapseSubtasks: true,
+  collapseSkips: true,
+  showSkipMessage: true,
+  suffixSkips: false,
+  collapseErrors: true,
+  showErrorMessage: true,
+  suffixRetries: true,
+  lazy: false,
+  removeEmptyLines: true,
+  formatOutput: "wrap",
+  pausedTimer: {
+    ...PRESET_TIMER,
+    format: /* @__PURE__ */ __name(() => color.yellowBright, "format")
+  }
+}), __publicField(_a9, "rendererTaskOptions", {
+  outputBar: true
+}), _a9);
+var _a10;
+var SilentRenderer = (_a10 = class {
+  constructor(tasks, options2) {
+    this.tasks = tasks;
+    this.options = options2;
+  }
+  render() {
+    return;
+  }
+  end() {
+    return;
+  }
+}, __name(_a10, "SilentRenderer"), __publicField(_a10, "nonTTY", true), __publicField(_a10, "rendererOptions"), __publicField(_a10, "rendererTaskOptions"), _a10);
+var _a11;
+var SimpleRenderer = (_a11 = class {
+  constructor(tasks, options2) {
+    __publicField(this, "logger");
+    __publicField(this, "cache", {
+      rendererOptions: /* @__PURE__ */ new Map(),
+      rendererTaskOptions: /* @__PURE__ */ new Map()
+    });
+    this.tasks = tasks;
+    this.options = options2;
+    this.options = {
+      ..._a11.rendererOptions,
+      ...options2,
+      icon: {
+        ...LISTR_LOGGER_STYLE.icon,
+        ...options2?.icon ?? {}
+      },
+      color: {
+        ...LISTR_LOGGER_STYLE.color,
+        ...options2?.color ?? {}
+      }
+    };
+    this.logger = this.options.logger ?? new ListrLogger({ useIcons: true, toStderr: LISTR_LOGGER_STDERR_LEVELS });
+    this.logger.options.icon = this.options.icon;
+    this.logger.options.color = this.options.color;
+    if (this.options.timestamp) {
+      this.logger.options.fields.prefix.unshift(this.options.timestamp);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  end() {
+  }
+  render() {
+    this.renderer(this.tasks);
+  }
+  renderer(tasks) {
+    tasks.forEach((task) => {
+      this.calculate(task);
+      task.once("CLOSED", () => {
+        this.reset(task);
+      });
+      const rendererOptions = this.cache.rendererOptions.get(task.id);
+      const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+      task.on("SUBTASK", (subtasks) => {
+        this.renderer(subtasks);
+      });
+      task.on("STATE", (state) => {
+        if (!task.hasTitle()) {
+          return;
+        }
+        if (state === "STARTED") {
+          this.logger.log("STARTED", task.title);
+        } else if (state === "COMPLETED") {
+          const timer = rendererTaskOptions?.timer;
+          this.logger.log(
+            "COMPLETED",
+            task.title,
+            timer && {
+              suffix: {
+                ...timer,
+                condition: !!task.message?.duration && timer.condition,
+                args: [task.message.duration]
+              }
+            }
+          );
+        } else if (state === "PROMPT") {
+          this.logger.process.hijack();
+          task.on("PROMPT", (prompt) => {
+            this.logger.process.toStderr(prompt, false);
+          });
+        } else if (state === "PROMPT_COMPLETED") {
+          task.off(
+            "PROMPT"
+            /* PROMPT */
+          );
+          this.logger.process.release();
+        }
+      });
+      task.on("OUTPUT", (output) => {
+        this.logger.log("OUTPUT", output);
+      });
+      task.on("MESSAGE", (message) => {
+        if (message.error) {
+          this.logger.log("FAILED", task.title, {
+            suffix: {
+              field: `${"FAILED"}: ${message.error}`,
+              format: /* @__PURE__ */ __name(() => color.red, "format")
+            }
+          });
+        } else if (message.skip) {
+          this.logger.log("SKIPPED", task.title, {
+            suffix: {
+              field: `${"SKIPPED"}: ${message.skip}`,
+              format: /* @__PURE__ */ __name(() => color.yellow, "format")
+            }
+          });
+        } else if (message.rollback) {
+          this.logger.log("ROLLBACK", task.title, {
+            suffix: {
+              field: `${"ROLLBACK"}: ${message.rollback}`,
+              format: /* @__PURE__ */ __name(() => color.red, "format")
+            }
+          });
+        } else if (message.retry) {
+          this.logger.log("RETRY", task.title, {
+            suffix: {
+              field: `${"RETRY"}:${message.retry.count}`,
+              format: /* @__PURE__ */ __name(() => color.red, "format")
+            }
+          });
+        } else if (message.paused) {
+          const timer = rendererOptions?.pausedTimer;
+          this.logger.log(
+            "PAUSED",
+            task.title,
+            timer && {
+              suffix: {
+                ...timer,
+                condition: !!message?.paused && timer.condition,
+                args: [message.paused - Date.now()]
+              }
+            }
+          );
+        }
+      });
+    });
+  }
+  calculate(task) {
+    if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) {
+      return;
+    }
+    const rendererOptions = {
+      ...this.options,
+      ...task.rendererOptions
+    };
+    this.cache.rendererOptions.set(task.id, rendererOptions);
+    this.cache.rendererTaskOptions.set(task.id, {
+      ..._a11.rendererTaskOptions,
+      timer: rendererOptions.timer,
+      ...task.rendererTaskOptions
+    });
+  }
+  reset(task) {
+    this.cache.rendererOptions.delete(task.id);
+    this.cache.rendererTaskOptions.delete(task.id);
+  }
+}, __name(_a11, "SimpleRenderer"), __publicField(_a11, "nonTTY", true), __publicField(_a11, "rendererOptions", {
+  pausedTimer: {
+    ...PRESET_TIMER,
+    field: /* @__PURE__ */ __name((time) => `${"PAUSED"}:${time}`, "field"),
+    format: /* @__PURE__ */ __name(() => color.yellowBright, "format")
+  }
+}), __publicField(_a11, "rendererTaskOptions", {}), _a11);
+var _a12;
+var TestRendererSerializer = (_a12 = class {
+  constructor(options2) {
+    this.options = options2;
+  }
+  serialize(event, data, task) {
+    return JSON.stringify(this.generate(event, data, task));
+  }
+  generate(event, data, task) {
+    const output = {
+      event,
+      data
+    };
+    if (typeof this.options?.task !== "boolean") {
+      const t = Object.fromEntries(
+        this.options.task.map((entity) => {
+          const property = task[entity];
+          if (typeof property === "function") {
+            return [entity, property.call(task)];
+          }
+          return [entity, property];
+        })
+      );
+      if (Object.keys(task).length > 0) {
+        output.task = t;
+      }
+    }
+    return output;
+  }
+}, __name(_a12, "TestRendererSerializer"), _a12);
+var _a13;
+var TestRenderer = (_a13 = class {
+  constructor(tasks, options2) {
+    __publicField(this, "logger");
+    __publicField(this, "serializer");
+    this.tasks = tasks;
+    this.options = options2;
+    this.options = { ..._a13.rendererOptions, ...this.options };
+    this.logger = this.options.logger ?? new ListrLogger({ useIcons: false });
+    this.serializer = new TestRendererSerializer(this.options);
+  }
+  render() {
+    this.renderer(this.tasks);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  end() {
+  }
+  // verbose renderer multi-level
+  renderer(tasks) {
+    tasks.forEach((task) => {
+      if (this.options.subtasks) {
+        task.on("SUBTASK", (subtasks) => {
+          this.renderer(subtasks);
+        });
+      }
+      if (this.options.state) {
+        task.on("STATE", (state) => {
+          this.logger.toStdout(this.serializer.serialize("STATE", state, task));
+        });
+      }
+      if (this.options.output) {
+        task.on("OUTPUT", (data) => {
+          this.logger.toStdout(this.serializer.serialize("OUTPUT", data, task));
+        });
+      }
+      if (this.options.prompt) {
+        task.on("PROMPT", (prompt) => {
+          this.logger.toStdout(this.serializer.serialize("PROMPT", prompt, task));
+        });
+      }
+      if (this.options.title) {
+        task.on("TITLE", (title) => {
+          this.logger.toStdout(this.serializer.serialize("TITLE", title, task));
+        });
+      }
+      task.on("MESSAGE", (message) => {
+        const parsed = Object.fromEntries(
+          Object.entries(message).map(([key, value]) => {
+            if (this.options.messages.includes(key)) {
+              return [key, value];
+            }
+          }).filter(Boolean)
+        );
+        if (Object.keys(parsed).length > 0) {
+          const output = this.serializer.serialize("MESSAGE", parsed, task);
+          if (this.options.messagesToStderr.some((state) => Object.keys(parsed).includes(state))) {
+            this.logger.toStderr(output);
+          } else {
+            this.logger.toStdout(output);
+          }
+        }
+      });
+    });
+  }
+}, __name(_a13, "TestRenderer"), __publicField(_a13, "nonTTY", true), __publicField(_a13, "rendererOptions", {
+  subtasks: true,
+  state: Object.values(ListrTaskState),
+  output: true,
+  prompt: true,
+  title: true,
+  messages: ["skip", "error", "retry", "rollback", "paused"],
+  messagesToStderr: ["error", "rollback", "retry"],
+  task: [
+    "hasRolledBack",
+    "isRollingBack",
+    "isCompleted",
+    "isSkipped",
+    "hasFinalized",
+    "hasSubtasks",
+    "title",
+    "hasReset",
+    "hasTitle",
+    "isPrompt",
+    "isPaused",
+    "isPending",
+    "isSkipped",
+    "isStarted",
+    "hasFailed",
+    "isEnabled",
+    "isRetrying",
+    "path"
+  ]
+}), __publicField(_a13, "rendererTaskOptions"), _a13);
+var _a14;
+var VerboseRenderer = (_a14 = class {
+  constructor(tasks, options2) {
+    __publicField(this, "logger");
+    __publicField(this, "cache", {
+      rendererOptions: /* @__PURE__ */ new Map(),
+      rendererTaskOptions: /* @__PURE__ */ new Map()
+    });
+    this.tasks = tasks;
+    this.options = options2;
+    this.options = {
+      ..._a14.rendererOptions,
+      ...this.options,
+      icon: {
+        ...LISTR_LOGGER_STYLE.icon,
+        ...options2?.icon ?? {}
+      },
+      color: {
+        ...LISTR_LOGGER_STYLE.color,
+        ...options2?.color ?? {}
+      }
+    };
+    this.logger = this.options.logger ?? new ListrLogger({ useIcons: false, toStderr: LISTR_LOGGER_STDERR_LEVELS });
+    this.logger.options.icon = this.options.icon;
+    this.logger.options.color = this.options.color;
+    if (this.options.timestamp) {
+      this.logger.options.fields.prefix.unshift(this.options.timestamp);
+    }
+  }
+  render() {
+    this.renderer(this.tasks);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  end() {
+  }
+  renderer(tasks) {
+    tasks.forEach((task) => {
+      this.calculate(task);
+      task.once("CLOSED", () => {
+        this.reset(task);
+      });
+      const rendererOptions = this.cache.rendererOptions.get(task.id);
+      const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+      task.on("SUBTASK", (subtasks) => {
+        this.renderer(subtasks);
+      });
+      task.on("STATE", (state) => {
+        if (!task.hasTitle()) {
+          return;
+        }
+        if (state === "STARTED") {
+          this.logger.log("STARTED", task.title);
+        } else if (state === "COMPLETED") {
+          const timer = rendererTaskOptions.timer;
+          this.logger.log(
+            "COMPLETED",
+            task.title,
+            timer && {
+              suffix: {
+                ...timer,
+                condition: !!task.message?.duration && timer.condition,
+                args: [task.message.duration]
+              }
+            }
+          );
+        }
+      });
+      task.on("OUTPUT", (data) => {
+        this.logger.log("OUTPUT", data);
+      });
+      task.on("PROMPT", (prompt) => {
+        const cleansed = cleanseAnsi(prompt);
+        if (cleansed) {
+          this.logger.log("PROMPT", cleansed);
+        }
+      });
+      if (this.options?.logTitleChange !== false) {
+        task.on("TITLE", (title) => {
+          this.logger.log("TITLE", title);
+        });
+      }
+      task.on("MESSAGE", (message) => {
+        if (message?.error) {
+          this.logger.log("FAILED", message.error);
+        } else if (message?.skip) {
+          this.logger.log("SKIPPED", message.skip);
+        } else if (message?.rollback) {
+          this.logger.log("ROLLBACK", message.rollback);
+        } else if (message?.retry) {
+          this.logger.log("RETRY", task.title, { suffix: message.retry.count.toString() });
+        } else if (message?.paused) {
+          const timer = rendererOptions?.pausedTimer;
+          this.logger.log(
+            "PAUSED",
+            task.title,
+            timer && {
+              suffix: {
+                ...timer,
+                condition: !!message?.paused && timer.condition,
+                args: [message.paused - Date.now()]
+              }
+            }
+          );
+        }
+      });
+    });
+  }
+  calculate(task) {
+    if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) {
+      return;
+    }
+    const rendererOptions = {
+      ...this.options,
+      ...task.rendererOptions
+    };
+    this.cache.rendererOptions.set(task.id, rendererOptions);
+    this.cache.rendererTaskOptions.set(task.id, {
+      ..._a14.rendererTaskOptions,
+      timer: rendererOptions.timer,
+      ...task.rendererTaskOptions
+    });
+  }
+  reset(task) {
+    this.cache.rendererOptions.delete(task.id);
+    this.cache.rendererTaskOptions.delete(task.id);
+  }
+}, __name(_a14, "VerboseRenderer"), __publicField(_a14, "nonTTY", true), __publicField(_a14, "rendererOptions", {
+  logTitleChange: false,
+  pausedTimer: {
+    ...PRESET_TIMER,
+    format: /* @__PURE__ */ __name(() => color.yellowBright, "format")
+  }
+}), __publicField(_a14, "rendererTaskOptions"), _a14);
+var RENDERERS = {
+  default: DefaultRenderer,
+  simple: SimpleRenderer,
+  verbose: VerboseRenderer,
+  test: TestRenderer,
+  silent: SilentRenderer
+};
+function isRendererSupported(renderer) {
+  return process.stdout.isTTY === true || renderer.nonTTY === true;
+}
+__name(isRendererSupported, "isRendererSupported");
+function getRendererClass(renderer) {
+  if (typeof renderer === "string") {
+    return RENDERERS[renderer] ?? RENDERERS.default;
+  }
+  return typeof renderer === "function" ? renderer : RENDERERS.default;
+}
+__name(getRendererClass, "getRendererClass");
+function getRenderer(options2) {
+  if (assertFunctionOrSelf(options2?.silentRendererCondition)) {
+    return {
+      renderer: getRendererClass("silent"),
+      selection: "SILENT"
+      /* SILENT */
+    };
+  }
+  const r = {
+    renderer: getRendererClass(options2.renderer),
+    options: options2.rendererOptions,
+    selection: "PRIMARY"
+    /* PRIMARY */
+  };
+  if (!isRendererSupported(r.renderer) || assertFunctionOrSelf(options2?.fallbackRendererCondition)) {
+    return {
+      renderer: getRendererClass(options2.fallbackRenderer),
+      options: options2.fallbackRendererOptions,
+      selection: "SECONDARY"
+      /* SECONDARY */
+    };
+  }
+  return r;
+}
+__name(getRenderer, "getRenderer");
+function assertFunctionOrSelf(functionOrSelf, ...args) {
+  if (typeof functionOrSelf === "function") {
+    return functionOrSelf(...args);
+  } else {
+    return functionOrSelf;
+  }
+}
+__name(assertFunctionOrSelf, "assertFunctionOrSelf");
+var clone = (0, import_rfdc.default)({ circles: true });
+function cloneObject(obj) {
+  return clone(obj);
+}
+__name(cloneObject, "cloneObject");
+var _a15;
+var Concurrency = (_a15 = class {
+  constructor(options2) {
+    __publicField(this, "concurrency");
+    __publicField(this, "count");
+    __publicField(this, "queue");
+    this.concurrency = options2.concurrency;
+    this.count = 0;
+    this.queue = /* @__PURE__ */ new Set();
+  }
+  add(fn) {
+    if (this.count < this.concurrency) {
+      return this.run(fn);
+    }
+    return new Promise((resolve) => {
+      const callback = /* @__PURE__ */ __name(() => resolve(this.run(fn)), "callback");
+      this.queue.add(callback);
+    });
+  }
+  flush() {
+    for (const callback of this.queue) {
+      if (this.count >= this.concurrency) {
+        break;
+      }
+      this.queue.delete(callback);
+      callback();
+    }
+  }
+  run(fn) {
+    this.count++;
+    const promise = fn();
+    const cleanup = /* @__PURE__ */ __name(() => {
+      this.count--;
+      this.flush();
+    }, "cleanup");
+    promise.then(cleanup, () => {
+      this.queue.clear();
+    });
+    return promise;
+  }
+}, __name(_a15, "Concurrency"), _a15);
+function delay(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+__name(delay, "delay");
+var _a16;
+var ListrError = (_a16 = class extends Error {
+  constructor(error, type, task) {
+    super(error.message);
+    __publicField(this, "path");
+    __publicField(this, "ctx");
+    this.error = error;
+    this.type = type;
+    this.task = task;
+    this.name = "ListrError";
+    this.path = task.path;
+    if (task?.options.collectErrors === "full") {
+      this.task = cloneObject(task);
+      this.ctx = cloneObject(task.listr.ctx);
+    }
+    this.stack = error?.stack;
+  }
+}, __name(_a16, "ListrError"), _a16);
+var _a17;
+var ListrRendererError = (_a17 = class extends Error {
+}, __name(_a17, "ListrRendererError"), _a17);
+var _a18;
+var PromptError = (_a18 = class extends Error {
+}, __name(_a18, "PromptError"), _a18);
+var _a19;
+var TaskWrapper = (_a19 = class {
+  constructor(task) {
+    this.task = task;
+  }
+  /* istanbul ignore next */
+  get title() {
+    return this.task.title;
+  }
+  /**
+   * Title of the current task.
+   *
+   * @see {@link https://listr2.kilic.dev/task/title.html}
+   */
+  set title(title) {
+    title = Array.isArray(title) ? title : [title];
+    this.task.title$ = splat(title.shift(), ...title);
+  }
+  /* istanbul ignore next */
+  get output() {
+    return this.task.output;
+  }
+  /* istanbul ignore next */
+  /**
+   * Send output from the current task to the renderer.
+   *
+   * @see {@link https://listr2.kilic.dev/task/output.html}
+   */
+  set output(output) {
+    output = Array.isArray(output) ? output : [output];
+    this.task.output$ = splat(output.shift(), ...output);
+  }
+  /* istanbul ignore next */
+  /** Send an output to the output channel as prompt. */
+  set promptOutput(output) {
+    this.task.promptOutput$ = output;
+  }
+  /**
+   * Creates a new set of Listr subtasks.
+   *
+   * @see {@link https://listr2.kilic.dev/task/subtasks.html}
+   */
+  newListr(task, options2) {
+    let tasks;
+    if (typeof task === "function") {
+      tasks = task(this);
+    } else {
+      tasks = task;
+    }
+    return new Listr(tasks, options2, this.task);
+  }
+  /**
+   * Report an error that has to be collected and handled.
+   *
+   * @see {@link https://listr2.kilic.dev/task/error-handling.html}
+   */
+  report(error, type) {
+    if (this.task.options.collectErrors !== false) {
+      this.task.listr.errors.push(new ListrError(error, type, this.task));
+    }
+    this.task.message$ = { error: error.message ?? this.task?.title };
+  }
+  /**
+   * Skip the current task.
+   *
+   * @see {@link https://listr2.kilic.dev/task/skip.html}
+   */
+  skip(message, ...metadata) {
+    this.task.state$ = "SKIPPED";
+    if (message) {
+      this.task.message$ = { skip: message ? splat(message, ...metadata) : this.task?.title };
+    }
+  }
+  /**
+   * Check whether this task is currently in a retry state.
+   *
+   * @see {@link https://listr2.kilic.dev/task/retry.html}
+   */
+  isRetrying() {
+    return this.task.isRetrying() ? this.task.retry : { count: 0 };
+  }
+  /* istanbul ignore next */
+  /**
+   * Create a new prompt for getting user input through the prompt adapter.
+   * This will create a new prompt through the adapter if the task is not currently rendering a prompt or will return the active instance.
+   *
+   * This part of the application requires optional peer dependencies, please refer to documentation.
+   *
+   * @see {@link https://listr2.kilic.dev/task/prompt.html}
+   */
+  prompt(adapter) {
+    if (this.task.prompt) {
+      return this.task.prompt;
+    }
+    return new adapter(this.task, this);
+  }
+  /* istanbul ignore next */
+  /**
+   * Generates a fake stdout for your use case, where it will be tunnelled through Listr to handle the rendering process.
+   *
+   * @see {@link https://listr2.kilic.dev/renderer/process-output.html}
+   */
+  stdout(type) {
+    return createWritable((chunk) => {
+      switch (type) {
+        case "PROMPT":
+          this.promptOutput = chunk;
+          break;
+        default:
+          this.output = chunk;
+      }
+    });
+  }
+  /** Run this task. */
+  run(ctx) {
+    return this.task.run(ctx, this);
+  }
+}, __name(_a19, "TaskWrapper"), _a19);
+var _a20;
+var ListrTaskEventManager = (_a20 = class extends EventManager {
+}, __name(_a20, "ListrTaskEventManager"), _a20);
+var _a21;
+var Task = (_a21 = class extends ListrTaskEventManager {
+  constructor(listr, task, options2, rendererOptions, rendererTaskOptions) {
+    super();
+    /** Unique id per task, can be used for identifying a Task. */
+    __publicField(this, "id", randomUUID());
+    /** The current state of the task. */
+    __publicField(this, "state", "WAITING");
+    /** Subtasks of the current task. */
+    __publicField(this, "subtasks");
+    /** Title of the task. */
+    __publicField(this, "title");
+    /** Initial/Untouched version of the title for using whenever task has a reset. */
+    __publicField(this, "initialTitle");
+    /** Output channel for the task. */
+    __publicField(this, "output");
+    /** Current state of the retry process whenever the task is retrying. */
+    __publicField(this, "retry");
+    /**
+     * A channel for messages.
+     *
+     * This requires a separate channel for messages like error, skip or runtime messages to further utilize in the renderers.
+     */
+    __publicField(this, "message", {});
+    /** Current prompt instance or prompt error whenever the task is prompting. */
+    __publicField(this, "prompt");
+    /** Parent task of the current task. */
+    __publicField(this, "parent");
+    /** Enable flag of this task. */
+    __publicField(this, "enabled");
+    /** User provided Task callback function to run. */
+    __publicField(this, "taskFn");
+    /** Marks the task as closed. This is different from finalized since this is not really related to task itself. */
+    __publicField(this, "closed");
+    this.listr = listr;
+    this.task = task;
+    this.options = options2;
+    this.rendererOptions = rendererOptions;
+    this.rendererTaskOptions = rendererTaskOptions;
+    if (task.title) {
+      const title = Array.isArray(task?.title) ? task.title : [task.title];
+      this.title = splat(title.shift(), ...title);
+      this.initialTitle = this.title;
+    }
+    this.taskFn = task.task;
+    this.parent = listr.parentTask;
+  }
+  /**
+   * Update the current state of the Task and emit the neccassary events.
+   */
+  set state$(state) {
+    this.state = state;
+    this.emit("STATE", state);
+    if (this.hasSubtasks() && this.hasFailed()) {
+      for (const subtask of this.subtasks) {
+        if (subtask.state === "STARTED") {
+          subtask.state$ = "FAILED";
+        }
+      }
+    }
+    this.listr.events.emit(
+      "SHOUD_REFRESH_RENDER"
+      /* SHOULD_REFRESH_RENDER */
+    );
+  }
+  /**
+   * Update the current output of the Task and emit the neccassary events.
+   */
+  set output$(data) {
+    this.output = data;
+    this.emit("OUTPUT", data);
+    this.listr.events.emit(
+      "SHOUD_REFRESH_RENDER"
+      /* SHOULD_REFRESH_RENDER */
+    );
+  }
+  /**
+   * Update the current prompt output of the Task and emit the neccassary events.
+   */
+  set promptOutput$(data) {
+    this.emit("PROMPT", data);
+    if (cleanseAnsi(data)) {
+      this.listr.events.emit(
+        "SHOUD_REFRESH_RENDER"
+        /* SHOULD_REFRESH_RENDER */
+      );
+    }
+  }
+  /**
+   * Update or extend the current message of the Task and emit the neccassary events.
+   */
+  set message$(data) {
+    this.message = { ...this.message, ...data };
+    this.emit("MESSAGE", data);
+    this.listr.events.emit(
+      "SHOUD_REFRESH_RENDER"
+      /* SHOULD_REFRESH_RENDER */
+    );
+  }
+  /**
+   * Update the current title of the Task and emit the neccassary events.
+   */
+  set title$(title) {
+    this.title = title;
+    this.emit("TITLE", title);
+    this.listr.events.emit(
+      "SHOUD_REFRESH_RENDER"
+      /* SHOULD_REFRESH_RENDER */
+    );
+  }
+  /**
+   * Current task path in the hierarchy.
+   */
+  get path() {
+    return [...this.listr.path, this.initialTitle];
+  }
+  /**
+   * Checks whether the current task with the given context should be set as enabled.
+   */
+  async check(ctx) {
+    if (this.state === "WAITING") {
+      this.enabled = await assertFunctionOrSelf(this.task?.enabled ?? true, ctx);
+      this.emit("ENABLED", this.enabled);
+      this.listr.events.emit(
+        "SHOUD_REFRESH_RENDER"
+        /* SHOULD_REFRESH_RENDER */
+      );
+    }
+    return this.enabled;
+  }
+  /** Returns whether this task has subtasks. */
+  hasSubtasks() {
+    return this.subtasks?.length > 0;
+  }
+  /** Returns whether this task is finalized in someform. */
+  hasFinalized() {
+    return this.isCompleted() || this.hasFailed() || this.isSkipped() || this.hasRolledBack();
+  }
+  /** Returns whether this task is in progress. */
+  isPending() {
+    return this.isStarted() || this.isPrompt() || this.hasReset();
+  }
+  /** Returns whether this task has started. */
+  isStarted() {
+    return this.state === "STARTED";
+  }
+  /** Returns whether this task is skipped. */
+  isSkipped() {
+    return this.state === "SKIPPED";
+  }
+  /** Returns whether this task has been completed. */
+  isCompleted() {
+    return this.state === "COMPLETED";
+  }
+  /** Returns whether this task has been failed. */
+  hasFailed() {
+    return this.state === "FAILED";
+  }
+  /** Returns whether this task has an active rollback task going on. */
+  isRollingBack() {
+    return this.state === "ROLLING_BACK";
+  }
+  /** Returns whether the rollback action was successful. */
+  hasRolledBack() {
+    return this.state === "ROLLED_BACK";
+  }
+  /** Returns whether this task has an actively retrying task going on. */
+  isRetrying() {
+    return this.state === "RETRY";
+  }
+  /** Returns whether this task has some kind of reset like retry and rollback going on. */
+  hasReset() {
+    return this.state === "RETRY" || this.state === "ROLLING_BACK";
+  }
+  /** Returns whether enabled function resolves to true. */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Returns whether this task actually has a title. */
+  hasTitle() {
+    return typeof this?.title === "string";
+  }
+  /** Returns whether this task has a prompt inside. */
+  isPrompt() {
+    return this.state === "PROMPT" || this.state === "PROMPT_COMPLETED";
+  }
+  /** Returns whether this task is currently paused. */
+  isPaused() {
+    return this.state === "PAUSED";
+  }
+  /** Returns whether this task is closed. */
+  isClosed() {
+    return this.closed;
+  }
+  /** Pause the given task for certain time. */
+  async pause(time) {
+    const state = this.state;
+    this.state$ = "PAUSED";
+    this.message$ = {
+      paused: Date.now() + time
+    };
+    await delay(time);
+    this.state$ = state;
+    this.message$ = {
+      paused: null
+    };
+  }
+  /** Run the current task. */
+  async run(context, wrapper) {
+    const handleResult = /* @__PURE__ */ __name((result) => {
+      if (result instanceof Listr) {
+        result.options = { ...this.options, ...result.options };
+        result.rendererClass = getRendererClass("silent");
+        this.subtasks = result.tasks;
+        result.errors = this.listr.errors;
+        this.emit("SUBTASK", this.subtasks);
+        result = result.run(context);
+      } else if (result instanceof Promise) {
+        result = result.then(handleResult);
+      } else if (isReadable(result)) {
+        result = new Promise((resolve, reject) => {
+          result.on("data", (data) => {
+            this.output$ = data.toString();
+          });
+          result.on("error", (error) => reject(error));
+          result.on("end", () => resolve(null));
+        });
+      } else if (isObservable(result)) {
+        result = new Promise((resolve, reject) => {
+          result.subscribe({
+            next: /* @__PURE__ */ __name((data) => {
+              this.output$ = data;
+            }, "next"),
+            error: reject,
+            complete: resolve
+          });
+        });
+      }
+      return result;
+    }, "handleResult");
+    const startTime = Date.now();
+    this.state$ = "STARTED";
+    const skipped = await assertFunctionOrSelf(this.task?.skip ?? false, context);
+    if (skipped) {
+      if (typeof skipped === "string") {
+        this.message$ = { skip: skipped };
+      } else if (this.hasTitle()) {
+        this.message$ = { skip: this.title };
+      } else {
+        this.message$ = { skip: "Skipped task without a title." };
+      }
+      this.state$ = "SKIPPED";
+      return;
+    }
+    try {
+      const retryCount = typeof this.task?.retry === "number" && this.task.retry > 0 ? this.task.retry + 1 : typeof this.task?.retry === "object" && this.task.retry.tries > 0 ? this.task.retry.tries + 1 : 1;
+      const retryDelay = typeof this.task.retry === "object" && this.task.retry.delay;
+      for (let retries = 1; retries <= retryCount; retries++) {
+        try {
+          await handleResult(this.taskFn(context, wrapper));
+          break;
+        } catch (err) {
+          if (retries !== retryCount) {
+            this.retry = { count: retries, error: err };
+            this.message$ = { retry: this.retry };
+            this.title$ = this.initialTitle;
+            this.output = void 0;
+            wrapper.report(
+              err,
+              "WILL_RETRY"
+              /* WILL_RETRY */
+            );
+            this.state$ = "RETRY";
+            if (retryDelay) {
+              await this.pause(retryDelay);
+            }
+          } else {
+            throw err;
+          }
+        }
+      }
+      if (this.isStarted() || this.isRetrying()) {
+        this.message$ = { duration: Date.now() - startTime };
+        this.state$ = "COMPLETED";
+      }
+    } catch (error) {
+      if (this.prompt instanceof PromptError) {
+        error = this.prompt;
+      }
+      if (this.task?.rollback) {
+        wrapper.report(
+          error,
+          "WILL_ROLLBACK"
+          /* WILL_ROLLBACK */
+        );
+        try {
+          this.state$ = "ROLLING_BACK";
+          await this.task.rollback(context, wrapper);
+          this.message$ = { rollback: this.title };
+          this.state$ = "ROLLED_BACK";
+        } catch (err) {
+          this.state$ = "FAILED";
+          wrapper.report(
+            err,
+            "HAS_FAILED_TO_ROLLBACK"
+            /* HAS_FAILED_TO_ROLLBACK */
+          );
+          this.close();
+          throw err;
+        }
+        if (this.listr.options?.exitAfterRollback !== false) {
+          this.close();
+          throw error;
+        }
+      } else {
+        this.state$ = "FAILED";
+        if (this.listr.options.exitOnError !== false && await assertFunctionOrSelf(this.task?.exitOnError, context) !== false) {
+          wrapper.report(
+            error,
+            "HAS_FAILED"
+            /* HAS_FAILED */
+          );
+          this.close();
+          throw error;
+        } else if (!this.hasSubtasks()) {
+          wrapper.report(
+            error,
+            "HAS_FAILED_WITHOUT_ERROR"
+            /* HAS_FAILED_WITHOUT_ERROR */
+          );
+        }
+      }
+    } finally {
+      this.close();
+    }
+  }
+  close() {
+    this.emit(
+      "CLOSED"
+      /* CLOSED */
+    );
+    this.listr.events.emit(
+      "SHOUD_REFRESH_RENDER"
+      /* SHOULD_REFRESH_RENDER */
+    );
+    this.complete();
+  }
+}, __name(_a21, "Task"), _a21);
+var _a22;
+var ListrEventManager = (_a22 = class extends EventManager {
+}, __name(_a22, "ListrEventManager"), _a22);
+var _a23;
+var Listr = (_a23 = class {
+  constructor(task, options2, parentTask) {
+    __publicField(this, "tasks", []);
+    __publicField(this, "errors", []);
+    __publicField(this, "ctx");
+    __publicField(this, "events");
+    __publicField(this, "path", []);
+    __publicField(this, "rendererClass");
+    __publicField(this, "rendererClassOptions");
+    __publicField(this, "rendererSelection");
+    __publicField(this, "boundSignalHandler");
+    __publicField(this, "concurrency");
+    __publicField(this, "renderer");
+    this.task = task;
+    this.options = options2;
+    this.parentTask = parentTask;
+    this.options = {
+      concurrent: false,
+      renderer: "default",
+      fallbackRenderer: "simple",
+      exitOnError: true,
+      exitAfterRollback: true,
+      collectErrors: false,
+      registerSignalListeners: true,
+      ...this.parentTask?.options ?? {},
+      ...options2
+    };
+    if (this.options.concurrent === true) {
+      this.options.concurrent = Infinity;
+    } else if (typeof this.options.concurrent !== "number") {
+      this.options.concurrent = 1;
+    }
+    this.concurrency = new Concurrency({ concurrency: this.options.concurrent });
+    if (parentTask) {
+      this.path = [...parentTask.listr.path, parentTask.title];
+      this.errors = parentTask.listr.errors;
+    }
+    if (this.parentTask?.listr.events instanceof ListrEventManager) {
+      this.events = this.parentTask.listr.events;
+    } else {
+      this.events = new ListrEventManager();
+    }
+    const renderer = getRenderer({
+      renderer: this.options.renderer,
+      rendererOptions: this.options.rendererOptions,
+      fallbackRenderer: this.options.fallbackRenderer,
+      fallbackRendererOptions: this.options.fallbackRendererOptions,
+      fallbackRendererCondition: this.options?.fallbackRendererCondition,
+      silentRendererCondition: this.options?.silentRendererCondition
+    });
+    this.rendererClass = renderer.renderer;
+    this.rendererClassOptions = renderer.options;
+    this.rendererSelection = renderer.selection;
+    this.add(task ?? []);
+    if (this.options.registerSignalListeners) {
+      this.boundSignalHandler = this.signalHandler.bind(this);
+      process.once("SIGINT", this.boundSignalHandler).setMaxListeners(0);
+    }
+    if (this.options?.forceTTY || process.env[
+      "LISTR_FORCE_TTY"
+      /* FORCE_TTY */
+    ]) {
+      process.stdout.isTTY = true;
+      process.stderr.isTTY = true;
+    }
+    if (this.options?.forceUnicode) {
+      process.env[
+        "LISTR_FORCE_UNICODE"
+        /* FORCE_UNICODE */
+      ] = "1";
+    }
+  }
+  /**
+   * Whether this is the root task.
+   */
+  isRoot() {
+    return !this.parentTask;
+  }
+  /**
+   * Whether this is a subtask of another task list.
+   */
+  isSubtask() {
+    return !!this.parentTask;
+  }
+  /**
+   * Add tasks to current task list.
+   *
+   * @see {@link https://listr2.kilic.dev/task/task.html}
+   */
+  add(tasks) {
+    this.tasks.push(...this.generate(tasks));
+  }
+  /**
+   * Run the task list.
+   *
+   * @see {@link https://listr2.kilic.dev/listr/listr.html#run-the-generated-task-list}
+   */
+  async run(context) {
+    if (!this.renderer) {
+      this.renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
+    }
+    await this.renderer.render();
+    this.ctx = this.options?.ctx ?? context ?? {};
+    await Promise.all(this.tasks.map((task) => task.check(this.ctx)));
+    try {
+      await Promise.all(this.tasks.map((task) => this.concurrency.add(() => this.runTask(task))));
+      this.renderer.end();
+      this.removeSignalHandler();
+    } catch (err) {
+      if (this.options.exitOnError !== false) {
+        this.renderer.end(err);
+        this.removeSignalHandler();
+        throw err;
+      }
+    }
+    return this.ctx;
+  }
+  generate(tasks) {
+    tasks = Array.isArray(tasks) ? tasks : [tasks];
+    return tasks.map((task) => {
+      let rendererTaskOptions;
+      if (this.rendererSelection === "PRIMARY") {
+        rendererTaskOptions = task.rendererOptions;
+      } else if (this.rendererSelection === "SECONDARY") {
+        rendererTaskOptions = task.fallbackRendererOptions;
+      }
+      return new Task(
+        this,
+        task,
+        this.options,
+        this.rendererClassOptions,
+        rendererTaskOptions
+      );
+    });
+  }
+  async runTask(task) {
+    if (!await task.check(this.ctx)) {
+      return;
+    }
+    return new TaskWrapper(task).run(this.ctx);
+  }
+  async signalHandler() {
+    this.tasks?.forEach(async (task) => {
+      if (task.isPending()) {
+        task.state$ = "FAILED";
+      }
+    });
+    await this.externalSignalHandler?.(this.ctx);
+    if (this.isRoot()) {
+      this.renderer.end(new Error("Interrupted."));
+      process.exit(127);
+    }
+  }
+  removeSignalHandler() {
+    if (this.boundSignalHandler) {
+      process.removeListener("SIGINT", this.boundSignalHandler);
+    }
+  }
+}, __name(_a23, "Listr"), _a23);
+
 // src/error.ts
-import { color } from "listr2";
 var AbstractError = class extends Error {
   constructor(message, { cause } = {}) {
     super(message, { cause });
@@ -58,14 +4411,13 @@ function resolveOptions(options2) {
 }
 
 // src/tasks/runner.ts
-import process2 from "node:process";
+import process8 from "node:process";
 import npmCli from "@npmcli/promise-spawn";
-import { color as color5 } from "listr2";
 import SemVer from "semver";
-import { exec as exec5 } from "tinyexec";
+import { exec as exec6 } from "tinyexec";
 
 // src/git.ts
-import { exec } from "tinyexec";
+import { exec as exec2 } from "tinyexec";
 var GitError = class extends AbstractError {
   constructor() {
     super(...arguments);
@@ -74,7 +4426,7 @@ var GitError = class extends AbstractError {
 };
 var Git = class {
   async git(args) {
-    const { stdout, stderr } = await exec("git", args);
+    const { stdout, stderr } = await exec2("git", args);
     if (stderr) throw stderr;
     return stdout;
   }
@@ -315,7 +4667,7 @@ var Git = class {
   async push(options2) {
     const args = ["push", options2].filter((v) => v);
     try {
-      const { stderr } = await exec("git", args, { throwOnError: true });
+      const { stderr } = await exec2("git", args, { throwOnError: true });
       if (`${stderr}`.includes("GH006")) {
         return false;
       }
@@ -332,15 +4684,11 @@ var Git = class {
 };
 
 // src/utils/cli.ts
-import { color as color2 } from "listr2";
-var warningBadge = color2.bgYellow(" Warning ");
-function link(text, url) {
+var warningBadge = color.bgYellow(" Warning ");
+function link2(text, url) {
   return `\x1B]8;;${url}\x07${text}\x1B]8;;\x07`;
 }
 
-// src/utils/listr.ts
-import { Listr } from "listr2";
-
 // src/utils/rollback.ts
 var rollbacks = [];
 function addRollback(rollback2, context) {
@@ -367,13 +4715,13 @@ function createListr(...args) {
 // src/utils/package.ts
 import { readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import process from "node:process";
+import process7 from "node:process";
 var cachedPackageJson = {};
 var cachedJsrJson = {};
-async function patchCachedJsrJson(contents, { cwd = process.cwd() } = {}) {
+async function patchCachedJsrJson(contents, { cwd = process7.cwd() } = {}) {
   cachedJsrJson[cwd] = { ...cachedJsrJson[cwd], ...contents };
 }
-async function findOutFile(file, { cwd = process.cwd() } = {}) {
+async function findOutFile(file, { cwd = process7.cwd() } = {}) {
   let directory = cwd;
   let filePath = "";
   const { root } = path.parse(cwd);
@@ -391,7 +4739,7 @@ async function findOutFile(file, { cwd = process.cwd() } = {}) {
   return filePath;
 }
 async function getPackageJson({
-  cwd = process.cwd(),
+  cwd = process7.cwd(),
   fallbackJsr = true
 } = {}) {
   if (cachedPackageJson[cwd]) return cachedPackageJson[cwd];
@@ -424,7 +4772,7 @@ async function getPackageJson({
   }
 }
 async function getJsrJson({
-  cwd = process.cwd(),
+  cwd = process7.cwd(),
   fallbackPackage = true
 } = {}) {
   if (cachedJsrJson[cwd]) return cachedJsrJson[cwd];
@@ -502,7 +4850,7 @@ async function jsrJsonToPackageJson(jsrJson) {
     return convertedExports;
   }
 }
-async function version({ cwd = process.cwd() } = {}) {
+async function version({ cwd = process7.cwd() } = {}) {
   let version2 = (await getPackageJson({ cwd }))?.version;
   if (!version2) {
     version2 = (await getJsrJson({ cwd }))?.version;
@@ -557,10 +4905,9 @@ async function getPackageManager() {
 
 // src/tasks/jsr.ts
 import { ListrEnquirerPromptAdapter } from "@listr2/prompt-adapter-enquirer";
-import { color as color3 } from "listr2";
 
 // src/registry/jsr.ts
-import { exec as exec2 } from "tinyexec";
+import { exec as exec3 } from "tinyexec";
 
 // src/utils/db.ts
 import { createCipheriv, createDecipheriv, createHash } from "node:crypto";
@@ -684,7 +5031,7 @@ var JsrRegisry = class extends Registry {
     this.client = new JsrClient(getApiEndpoint(this.registry));
   }
   async jsr(args) {
-    const { stdout, stderr } = await exec2("jsr", args);
+    const { stdout, stderr } = await exec3("jsr", args);
     if (stderr) throw stderr;
     return stdout;
   }
@@ -701,7 +5048,7 @@ var JsrRegisry = class extends Registry {
   }
   async ping() {
     try {
-      const { stdout, stderr } = await exec2("ping", [
+      const { stdout, stderr } = await exec3("ping", [
         new URL(this.registry).hostname,
         "-c",
         "1"
@@ -717,7 +5064,7 @@ var JsrRegisry = class extends Registry {
   }
   async publish() {
     try {
-      await exec2(
+      await exec3(
         "jsr",
         ["publish", "--allow-dirty", "--token", `${JsrClient.token}`],
         {
@@ -759,12 +5106,12 @@ var _JsrClient = class _JsrClient {
   constructor(apiEndpoint) {
     this.apiEndpoint = apiEndpoint;
   }
-  async fetch(endpoint, init) {
+  async fetch(endpoint, init2) {
     const pubmVersion = await version({ cwd: import.meta.dirname });
     return fetch(new URL(endpoint, this.apiEndpoint), {
-      ...init,
+      ...init2,
       headers: {
-        ...init?.headers,
+        ...init2?.headers,
         Authorization: `Bearer ${_JsrClient.token}`,
         "User-Agent": `pubm/${pubmVersion}; https://github.com/syi0808/pubm`
       }
@@ -908,7 +5255,7 @@ async function jsrRegistry() {
 }
 
 // src/registry/npm.ts
-import { exec as exec3 } from "tinyexec";
+import { exec as exec4 } from "tinyexec";
 var NpmError = class extends AbstractError {
   constructor() {
     super(...arguments);
@@ -921,7 +5268,7 @@ var NpmRegistry = class extends Registry {
     __publicField(this, "registry", "https://registry.npmjs.org");
   }
   async npm(args) {
-    const { stdout, stderr } = await exec3("npm", args);
+    const { stdout, stderr } = await exec4("npm", args);
     if (stderr) throw stderr;
     return stdout;
   }
@@ -1007,7 +5354,7 @@ var NpmRegistry = class extends Registry {
   }
   async ping() {
     try {
-      await exec3("npm", ["ping"], { throwOnError: true });
+      await exec4("npm", ["ping"], { throwOnError: true });
       return true;
     } catch (error) {
       throw new NpmError("Failed to run `npm ping`", { cause: error });
@@ -1066,9 +5413,9 @@ var jsrAvailableCheckTasks = {
       while (true) {
         JsrClient.token = await task.prompt(ListrEnquirerPromptAdapter).run({
           type: "password",
-          message: `Please enter the jsr ${color3.bold("API token")}`,
+          message: `Please enter the jsr ${color.bold("API token")}`,
           footer: `
-Generate a token from ${color3.bold(link("jsr.io", "https://jsr.io/account/tokens/create/"))}. ${color3.red("You should select")} ${color3.bold("'Interact with the JSR API'")}.`
+Generate a token from ${color.bold(link2("jsr.io", "https://jsr.io/account/tokens/create/"))}. ${color.red("You should select")} ${color.bold("'Interact with the JSR API'")}.`
         });
         try {
           if (await jsr.client.user()) break;
@@ -1113,17 +5460,17 @@ Generate a token from ${color3.bold(link("jsr.io", "https://jsr.io/account/token
           message: "jsr.json does not exist, and the package name is not scoped. Please select a scope for the 'jsr' package",
           choices: [
             {
-              message: `@${jsr.packageName}/${jsr.packageName} ${color3.dim("scoped by package name")}${scopes.includes(jsr.packageName) ? " (already created)" : ""}`,
+              message: `@${jsr.packageName}/${jsr.packageName} ${color.dim("scoped by package name")}${scopes.includes(jsr.packageName) ? " (already created)" : ""}`,
               name: `@${jsr.packageName}/${jsr.packageName}`
             },
             {
-              message: `@${userName}/${jsr.packageName} ${color3.dim("scoped by git name")}${scopes.includes(userName) ? " (already created)" : ""}`,
+              message: `@${userName}/${jsr.packageName} ${color.dim("scoped by git name")}${scopes.includes(userName) ? " (already created)" : ""}`,
               name: `@${userName}/${jsr.packageName}`
             },
             ...scopes.flatMap(
               (scope2) => scope2 === jsr.packageName || scope2 === userName ? [] : [
                 {
-                  message: `@${scope2}/${jsr.packageName} ${color3.dim("scope from jsr")}`,
+                  message: `@${scope2}/${jsr.packageName} ${color.dim("scope from jsr")}`,
                   name: `@${scope2}/${jsr.packageName}`
                 }
               ]
@@ -1161,21 +5508,21 @@ Generate a token from ${color3.bold(link("jsr.io", "https://jsr.io/account/token
     const hasPermission = await jsr.hasPermission();
     if (isScopedPackage(npm.packageName) && !hasPermission) {
       throw new JsrAvailableError(
-        `You do not have permission to publish scope '${getScope(npm.packageName)}'. If you want to claim it, please contact ${link("help@jsr.io", "mailto:help@jsr.io")}.`
+        `You do not have permission to publish scope '${getScope(npm.packageName)}'. If you want to claim it, please contact ${link2("help@jsr.io", "mailto:help@jsr.io")}.`
       );
     }
     if (await jsr.isPublished()) {
       if (!hasPermission) {
         throw new JsrAvailableError(
-          `You do not have permission to publish this package on ${color3.yellow("jsr")}.`
+          `You do not have permission to publish this package on ${color.yellow("jsr")}.`
         );
       }
       return void 0;
     }
     if (!await jsr.isPackageNameAvaliable()) {
       throw new JsrAvailableError(
-        `Package is not published on ${color3.yellow("jsr")}, and the package name is not available. Please change the package name.
-More information: ${link("npm naming rules", "https://github.com/npm/validate-npm-package-name?tab=readme-ov-file#naming-rules")}`
+        `Package is not published on ${color.yellow("jsr")}, and the package name is not available. Please change the package name.
+More information: ${link2("npm naming rules", "https://github.com/npm/validate-npm-package-name?tab=readme-ov-file#naming-rules")}`
       );
     }
   }
@@ -1191,7 +5538,6 @@ var jsrPublishTasks = {
 
 // src/tasks/npm.ts
 import { ListrEnquirerPromptAdapter as ListrEnquirerPromptAdapter2 } from "@listr2/prompt-adapter-enquirer";
-import { color as color4 } from "listr2";
 var NpmAvailableError = class extends AbstractError {
   constructor(message, { cause } = {}) {
     super(message, { cause });
@@ -1207,15 +5553,15 @@ var npmAvailableCheckTasks = {
     if (await npm.isPublished()) {
       if (!await npm.hasPermission()) {
         throw new NpmAvailableError(
-          `You do not have permission to publish this package on ${color4.green("npm")}.`
+          `You do not have permission to publish this package on ${color.green("npm")}.`
         );
       }
       return void 0;
     }
     if (!await npm.isPackageNameAvaliable()) {
       throw new NpmAvailableError(
-        `Package is not published on ${color4.green("npm")}, and the package name is not available. Please change the package name.
-More information: ${link("npm naming rules", "https://github.com/npm/validate-npm-package-name?tab=readme-ov-file#naming-rules")}`
+        `Package is not published on ${color.green("npm")}, and the package name is not available. Please change the package name.
+More information: ${link2("npm naming rules", "https://github.com/npm/validate-npm-package-name?tab=readme-ov-file#naming-rules")}`
       );
     }
   }
@@ -1394,10 +5740,10 @@ var prerequisitesCheckTask = (options2) => {
 import { ListrEnquirerPromptAdapter as ListrEnquirerPromptAdapter4 } from "@listr2/prompt-adapter-enquirer";
 
 // src/registry/custom-registry.ts
-import { exec as exec4 } from "tinyexec";
+import { exec as exec5 } from "tinyexec";
 var CustomRegistry = class extends NpmRegistry {
   async npm(args) {
-    const { stdout, stderr } = await exec4(
+    const { stdout, stderr } = await exec5(
       "npm",
       args.concat("--registry", this.registry)
     );
@@ -1573,7 +5919,7 @@ async function run(options2) {
     lastRev: await git.latestTag() || await git.firstCommit()
   };
   try {
-    if (options2.contents) process2.chdir(options2.contents);
+    if (options2.contents) process8.chdir(options2.contents);
     await prerequisitesCheckTask({ skip: options2.skipPrerequisitesCheck }).run(
       ctx
     );
@@ -1586,7 +5932,7 @@ async function run(options2) {
         title: "Running tests",
         task: async (ctx2) => {
           const packageManager = await getPackageManager();
-          const { stderr } = await exec5(packageManager, [
+          const { stderr } = await exec6(packageManager, [
             "run",
             ctx2.testScript
           ]);
@@ -1604,7 +5950,7 @@ async function run(options2) {
         task: async (ctx2) => {
           const packageManager = await getPackageManager();
           try {
-            await exec5(packageManager, ["run", ctx2.buildScript], {
+            await exec6(packageManager, ["run", ctx2.buildScript], {
               throwOnError: true
             });
           } catch (error) {
@@ -1698,7 +6044,7 @@ ${repositoryUrl}/compare/${ctx2.lastRev}...${latestTag}`;
             "prerelease",
             `${!!prerelease(ctx2.version)}`
           );
-          const linkUrl = link("Link", releaseDraftUrl.toString());
+          const linkUrl = link2("Link", releaseDraftUrl.toString());
           task.title += ` ${linkUrl}`;
           await open(releaseDraftUrl.toString());
         }
@@ -1709,13 +6055,13 @@ ${repositoryUrl}/compare/${ctx2.lastRev}...${latestTag}`;
     console.log(
       `
 
-\u{1F680} Successfully published ${color5.bold(npmPackageName)} on ${color5.green("npm")} and ${color5.bold(jsrPackageName)} on ${color5.yellow("jsr")} ${color5.blueBright(`v${ctx.version}`)} \u{1F680}
+\u{1F680} Successfully published ${color.bold(npmPackageName)} on ${color.green("npm")} and ${color.bold(jsrPackageName)} on ${color.yellow("jsr")} ${color.blueBright(`v${ctx.version}`)} \u{1F680}
 `
     );
   } catch (e2) {
     consoleError(e2);
     await rollback();
-    process2.exit(1);
+    process8.exit(1);
   }
 }
 
@@ -1727,7 +6073,6 @@ async function pubm(options2) {
 
 // src/tasks/required-missing-information.ts
 import { ListrEnquirerPromptAdapter as ListrEnquirerPromptAdapter5 } from "@listr2/prompt-adapter-enquirer";
-import { color as color6 } from "listr2";
 import semver from "semver";
 var { RELEASE_TYPES, SemVer: SemVer2, prerelease: prerelease2 } = semver;
 var requiredMissingInformationTasks = (options2) => createListr({
@@ -1745,7 +6090,7 @@ var requiredMissingInformationTasks = (options2) => createListr({
           choices: RELEASE_TYPES.map((releaseType) => {
             const increasedVersion = new SemVer2(currentVersion).inc(releaseType).toString();
             return {
-              message: `${releaseType} ${color6.dim(increasedVersion)}`,
+              message: `${releaseType} ${color.dim(increasedVersion)}`,
               name: increasedVersion
             };
           }).concat([
@@ -1802,8 +6147,7 @@ var requiredMissingInformationTasks = (options2) => createListr({
 });
 
 // src/utils/notify-new-version.ts
-import { color as color7 } from "listr2";
-import { exec as exec6 } from "tinyexec";
+import { exec as exec7 } from "tinyexec";
 async function notifyNewVersion() {
   const currentVersion = await version({ cwd: import.meta.dirname });
   await Promise.all([
@@ -1817,12 +6161,12 @@ async function notifyNewVersion() {
           cwd: import.meta.dirname,
           fallbackJsr: false
         });
-        const { stdout } = await exec6("npm", ["info", name, "version"]);
+        const { stdout } = await exec7("npm", ["info", name, "version"]);
         const newVersion = stdout.trim();
         if (newVersion !== currentVersion) {
           console.log(
             `
-Update available! \`${name}\` ${color7.red(currentVersion)} \u2192 ${color7.green(newVersion)}
+Update available! \`${name}\` ${color.red(currentVersion)} \u2192 ${color.green(newVersion)}
 `
           );
         }
@@ -1847,7 +6191,7 @@ Update available! \`${name}\` ${color7.red(currentVersion)} \u2192 ${color7.gree
         if (newVersion && newVersion !== currentVersion) {
           console.log(
             `
-Update available! \`${name}\` ${color7.red(currentVersion)} \u2192 ${color7.green(newVersion)}
+Update available! \`${name}\` ${color.red(currentVersion)} \u2192 ${color.green(newVersion)}
 `
           );
         }