@multisender.app/multisender-sdk 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,4514 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// node_modules/commander/lib/error.js
+var require_error = __commonJS((exports) => {
+  class CommanderError extends Error {
+    constructor(exitCode, code, message) {
+      super(message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+      this.code = code;
+      this.exitCode = exitCode;
+      this.nestedError = undefined;
+    }
+  }
+
+  class InvalidArgumentError extends CommanderError {
+    constructor(message) {
+      super(1, "commander.invalidArgument", message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+    }
+  }
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+});
+
+// node_modules/commander/lib/argument.js
+var require_argument = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Argument {
+    constructor(name, description) {
+      this.description = description || "";
+      this.variadic = false;
+      this.parseArg = undefined;
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.argChoices = undefined;
+      switch (name[0]) {
+        case "<":
+          this.required = true;
+          this._name = name.slice(1, -1);
+          break;
+        case "[":
+          this.required = false;
+          this._name = name.slice(1, -1);
+          break;
+        default:
+          this.required = true;
+          this._name = name;
+          break;
+      }
+      if (this._name.length > 3 && this._name.slice(-3) === "...") {
+        this.variadic = true;
+        this._name = this._name.slice(0, -3);
+      }
+    }
+    name() {
+      return this._name;
+    }
+    _concatValue(value, previous) {
+      if (previous === this.defaultValue || !Array.isArray(previous)) {
+        return [value];
+      }
+      return previous.concat(value);
+    }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
+    choices(values) {
+      this.argChoices = values.slice();
+      this.parseArg = (arg, previous) => {
+        if (!this.argChoices.includes(arg)) {
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+        }
+        if (this.variadic) {
+          return this._concatValue(arg, previous);
+        }
+        return arg;
+      };
+      return this;
+    }
+    argRequired() {
+      this.required = true;
+      return this;
+    }
+    argOptional() {
+      this.required = false;
+      return this;
+    }
+  }
+  function humanReadableArgName(arg) {
+    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  }
+  exports.Argument = Argument;
+  exports.humanReadableArgName = humanReadableArgName;
+});
+
+// node:events
+var exports_events = {};
+__export(exports_events, {
+  setMaxListeners: () => setMaxListeners2,
+  once: () => once2,
+  listenerCount: () => listenerCount2,
+  init: () => EventEmitter,
+  getMaxListeners: () => getMaxListeners2,
+  getEventListeners: () => getEventListeners,
+  default: () => events_default,
+  captureRejectionSymbol: () => captureRejectionSymbol,
+  addAbortListener: () => addAbortListener,
+  EventEmitter: () => EventEmitter
+});
+function emitError(emitter, args) {
+  var { _events: events } = emitter;
+  if (args[0] ??= Error("Unhandled error."), !events)
+    throw args[0];
+  var errorMonitor = events[kErrorMonitor];
+  if (errorMonitor)
+    for (var handler of ArrayPrototypeSlice.call(errorMonitor))
+      handler.apply(emitter, args);
+  var handlers = events.error;
+  if (!handlers)
+    throw args[0];
+  for (var handler of ArrayPrototypeSlice.call(handlers))
+    handler.apply(emitter, args);
+  return true;
+}
+function addCatch(emitter, promise, type, args) {
+  promise.then(undefined, function(err) {
+    queueMicrotask(() => emitUnhandledRejectionOrErr(emitter, err, type, args));
+  });
+}
+function emitUnhandledRejectionOrErr(emitter, err, type, args) {
+  if (typeof emitter[kRejection] === "function")
+    emitter[kRejection](err, type, ...args);
+  else
+    try {
+      emitter[kCapture] = false, emitter.emit("error", err);
+    } finally {
+      emitter[kCapture] = true;
+    }
+}
+function overflowWarning(emitter, type, handlers) {
+  handlers.warned = true;
+  let warn = Error(`Possible EventEmitter memory leak detected. ${handlers.length} ${String(type)} listeners added to [${emitter.constructor.name}]. Use emitter.setMaxListeners() to increase limit`);
+  warn.name = "MaxListenersExceededWarning", warn.emitter = emitter, warn.type = type, warn.count = handlers.length, console.warn(warn);
+}
+function onceWrapper(type, listener, ...args) {
+  this.removeListener(type, listener), listener.apply(this, args);
+}
+function once2(emitter, type, options) {
+  var signal = options?.signal;
+  if (validateAbortSignal(signal, "options.signal"), signal?.aborted)
+    throw new AbortError(undefined, { cause: signal?.reason });
+  let { resolve, reject, promise } = $newPromiseCapability(Promise), errorListener = (err) => {
+    if (emitter.removeListener(type, resolver), signal != null)
+      eventTargetAgnosticRemoveListener(signal, "abort", abortListener);
+    reject(err);
+  }, resolver = (...args) => {
+    if (typeof emitter.removeListener === "function")
+      emitter.removeListener("error", errorListener);
+    if (signal != null)
+      eventTargetAgnosticRemoveListener(signal, "abort", abortListener);
+    resolve(args);
+  };
+  if (eventTargetAgnosticAddListener(emitter, type, resolver, { once: true }), type !== "error" && typeof emitter.once === "function")
+    emitter.once("error", errorListener);
+  function abortListener() {
+    eventTargetAgnosticRemoveListener(emitter, type, resolver), eventTargetAgnosticRemoveListener(emitter, "error", errorListener), reject(new AbortError(undefined, { cause: signal?.reason }));
+  }
+  if (signal != null)
+    eventTargetAgnosticAddListener(signal, "abort", abortListener, { once: true });
+  return promise;
+}
+function getEventListeners(emitter, type) {
+  return emitter.listeners(type);
+}
+function setMaxListeners2(n, ...eventTargets) {
+  validateNumber(n, "setMaxListeners", 0);
+  var length;
+  if (eventTargets && (length = eventTargets.length))
+    for (let i = 0;i < length; i++)
+      eventTargets[i].setMaxListeners(n);
+  else
+    defaultMaxListeners = n;
+}
+function listenerCount2(emitter, type) {
+  return emitter.listenerCount(type);
+}
+function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
+  if (typeof emitter.removeListener === "function")
+    emitter.removeListener(name, listener);
+  else
+    emitter.removeEventListener(name, listener, flags);
+}
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === "function")
+    if (flags.once)
+      emitter.once(name, listener);
+    else
+      emitter.on(name, listener);
+  else
+    emitter.addEventListener(name, listener, flags);
+}
+function ERR_INVALID_ARG_TYPE(name, type, value) {
+  let err = TypeError(`The "${name}" argument must be of type ${type}. Received ${value}`);
+  return err.code = "ERR_INVALID_ARG_TYPE", err;
+}
+function ERR_OUT_OF_RANGE(name, range, value) {
+  let err = RangeError(`The "${name}" argument is out of range. It must be ${range}. Received ${value}`);
+  return err.code = "ERR_OUT_OF_RANGE", err;
+}
+function validateAbortSignal(signal, name) {
+  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal)))
+    throw ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
+}
+function validateNumber(value, name, min, max) {
+  if (typeof value !== "number")
+    throw ERR_INVALID_ARG_TYPE(name, "number", value);
+  if (min != null && value < min || max != null && value > max || (min != null || max != null) && Number.isNaN(value))
+    throw ERR_OUT_OF_RANGE(name, `${min != null ? `>= ${min}` : ""}${min != null && max != null ? " && " : ""}${max != null ? `<= ${max}` : ""}`, value);
+}
+function checkListener(listener) {
+  if (typeof listener !== "function")
+    throw TypeError("The listener must be a function");
+}
+function validateBoolean(value, name) {
+  if (typeof value !== "boolean")
+    throw ERR_INVALID_ARG_TYPE(name, "boolean", value);
+}
+function getMaxListeners2(emitterOrTarget) {
+  return emitterOrTarget?._maxListeners ?? defaultMaxListeners;
+}
+function addAbortListener(signal, listener) {
+  if (signal === undefined)
+    throw ERR_INVALID_ARG_TYPE("signal", "AbortSignal", signal);
+  if (validateAbortSignal(signal, "signal"), typeof listener !== "function")
+    throw ERR_INVALID_ARG_TYPE("listener", "function", listener);
+  let removeEventListener;
+  if (signal.aborted)
+    queueMicrotask(() => listener());
+  else
+    signal.addEventListener("abort", listener, { __proto__: null, once: true }), removeEventListener = () => {
+      signal.removeEventListener("abort", listener);
+    };
+  return { __proto__: null, [Symbol.dispose]() {
+    removeEventListener?.();
+  } };
+}
+var SymbolFor, kCapture, kErrorMonitor, kMaxEventTargetListeners, kMaxEventTargetListenersWarned, kRejection, captureRejectionSymbol, ArrayPrototypeSlice, defaultMaxListeners = 10, EventEmitter = function(opts) {
+  if (this._events === undefined || this._events === this.__proto__._events)
+    this._events = { __proto__: null }, this._eventsCount = 0;
+  if (this._maxListeners ??= undefined, this[kCapture] = opts?.captureRejections ? Boolean(opts?.captureRejections) : EventEmitterPrototype[kCapture])
+    this.emit = emitWithRejectionCapture;
+}, EventEmitterPrototype, emitWithoutRejectionCapture = function(type, ...args) {
+  if (type === "error")
+    return emitError(this, args);
+  var { _events: events } = this;
+  if (events === undefined)
+    return false;
+  var handlers = events[type];
+  if (handlers === undefined)
+    return false;
+  let maybeClonedHandlers = handlers.length > 1 ? handlers.slice() : handlers;
+  for (let i = 0, { length } = maybeClonedHandlers;i < length; i++) {
+    let handler = maybeClonedHandlers[i];
+    switch (args.length) {
+      case 0:
+        handler.call(this);
+        break;
+      case 1:
+        handler.call(this, args[0]);
+        break;
+      case 2:
+        handler.call(this, args[0], args[1]);
+        break;
+      case 3:
+        handler.call(this, args[0], args[1], args[2]);
+        break;
+      default:
+        handler.apply(this, args);
+        break;
+    }
+  }
+  return true;
+}, emitWithRejectionCapture = function(type, ...args) {
+  if (type === "error")
+    return emitError(this, args);
+  var { _events: events } = this;
+  if (events === undefined)
+    return false;
+  var handlers = events[type];
+  if (handlers === undefined)
+    return false;
+  let maybeClonedHandlers = handlers.length > 1 ? handlers.slice() : handlers;
+  for (let i = 0, { length } = maybeClonedHandlers;i < length; i++) {
+    let handler = maybeClonedHandlers[i], result;
+    switch (args.length) {
+      case 0:
+        result = handler.call(this);
+        break;
+      case 1:
+        result = handler.call(this, args[0]);
+        break;
+      case 2:
+        result = handler.call(this, args[0], args[1]);
+        break;
+      case 3:
+        result = handler.call(this, args[0], args[1], args[2]);
+        break;
+      default:
+        result = handler.apply(this, args);
+        break;
+    }
+    if (result !== undefined && typeof result?.then === "function" && result.then === Promise.prototype.then)
+      addCatch(this, result, type, args);
+  }
+  return true;
+}, AbortError, events_default;
+var init_events = __esm(() => {
+  SymbolFor = Symbol.for;
+  kCapture = Symbol("kCapture");
+  kErrorMonitor = SymbolFor("events.errorMonitor");
+  kMaxEventTargetListeners = Symbol("events.maxEventTargetListeners");
+  kMaxEventTargetListenersWarned = Symbol("events.maxEventTargetListenersWarned");
+  kRejection = SymbolFor("nodejs.rejection");
+  captureRejectionSymbol = SymbolFor("nodejs.rejection");
+  ArrayPrototypeSlice = Array.prototype.slice;
+  EventEmitterPrototype = EventEmitter.prototype = {};
+  EventEmitterPrototype._events = undefined;
+  EventEmitterPrototype._eventsCount = 0;
+  EventEmitterPrototype._maxListeners = undefined;
+  EventEmitterPrototype.setMaxListeners = function(n) {
+    return validateNumber(n, "setMaxListeners", 0), this._maxListeners = n, this;
+  };
+  EventEmitterPrototype.constructor = EventEmitter;
+  EventEmitterPrototype.getMaxListeners = function() {
+    return this?._maxListeners ?? defaultMaxListeners;
+  };
+  EventEmitterPrototype.emit = emitWithoutRejectionCapture;
+  EventEmitterPrototype.addListener = function(type, fn) {
+    checkListener(fn);
+    var events = this._events;
+    if (!events)
+      events = this._events = { __proto__: null }, this._eventsCount = 0;
+    else if (events.newListener)
+      this.emit("newListener", type, fn.listener ?? fn);
+    var handlers = events[type];
+    if (!handlers)
+      events[type] = [fn], this._eventsCount++;
+    else {
+      handlers.push(fn);
+      var m = this._maxListeners ?? defaultMaxListeners;
+      if (m > 0 && handlers.length > m && !handlers.warned)
+        overflowWarning(this, type, handlers);
+    }
+    return this;
+  };
+  EventEmitterPrototype.on = EventEmitterPrototype.addListener;
+  EventEmitterPrototype.prependListener = function(type, fn) {
+    checkListener(fn);
+    var events = this._events;
+    if (!events)
+      events = this._events = { __proto__: null }, this._eventsCount = 0;
+    else if (events.newListener)
+      this.emit("newListener", type, fn.listener ?? fn);
+    var handlers = events[type];
+    if (!handlers)
+      events[type] = [fn], this._eventsCount++;
+    else {
+      handlers.unshift(fn);
+      var m = this._maxListeners ?? defaultMaxListeners;
+      if (m > 0 && handlers.length > m && !handlers.warned)
+        overflowWarning(this, type, handlers);
+    }
+    return this;
+  };
+  EventEmitterPrototype.once = function(type, fn) {
+    checkListener(fn);
+    let bound = onceWrapper.bind(this, type, fn);
+    return bound.listener = fn, this.addListener(type, bound), this;
+  };
+  EventEmitterPrototype.prependOnceListener = function(type, fn) {
+    checkListener(fn);
+    let bound = onceWrapper.bind(this, type, fn);
+    return bound.listener = fn, this.prependListener(type, bound), this;
+  };
+  EventEmitterPrototype.removeListener = function(type, fn) {
+    checkListener(fn);
+    var { _events: events } = this;
+    if (!events)
+      return this;
+    var handlers = events[type];
+    if (!handlers)
+      return this;
+    var length = handlers.length;
+    let position = -1;
+    for (let i = length - 1;i >= 0; i--)
+      if (handlers[i] === fn || handlers[i].listener === fn) {
+        position = i;
+        break;
+      }
+    if (position < 0)
+      return this;
+    if (position === 0)
+      handlers.shift();
+    else
+      handlers.splice(position, 1);
+    if (handlers.length === 0)
+      delete events[type], this._eventsCount--;
+    return this;
+  };
+  EventEmitterPrototype.off = EventEmitterPrototype.removeListener;
+  EventEmitterPrototype.removeAllListeners = function(type) {
+    var { _events: events } = this;
+    if (type && events) {
+      if (events[type])
+        delete events[type], this._eventsCount--;
+    } else
+      this._events = { __proto__: null };
+    return this;
+  };
+  EventEmitterPrototype.listeners = function(type) {
+    var { _events: events } = this;
+    if (!events)
+      return [];
+    var handlers = events[type];
+    if (!handlers)
+      return [];
+    return handlers.map((x) => x.listener ?? x);
+  };
+  EventEmitterPrototype.rawListeners = function(type) {
+    var { _events } = this;
+    if (!_events)
+      return [];
+    var handlers = _events[type];
+    if (!handlers)
+      return [];
+    return handlers.slice();
+  };
+  EventEmitterPrototype.listenerCount = function(type) {
+    var { _events: events } = this;
+    if (!events)
+      return 0;
+    return events[type]?.length ?? 0;
+  };
+  EventEmitterPrototype.eventNames = function() {
+    return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+  };
+  EventEmitterPrototype[kCapture] = false;
+  AbortError = class AbortError extends Error {
+    constructor(message = "The operation was aborted", options = undefined) {
+      if (options !== undefined && typeof options !== "object")
+        throw ERR_INVALID_ARG_TYPE("options", "Object", options);
+      super(message, options);
+      this.code = "ABORT_ERR", this.name = "AbortError";
+    }
+  };
+  Object.defineProperties(EventEmitter, { captureRejections: { get() {
+    return EventEmitterPrototype[kCapture];
+  }, set(value) {
+    validateBoolean(value, "EventEmitter.captureRejections"), EventEmitterPrototype[kCapture] = value;
+  }, enumerable: true }, defaultMaxListeners: { enumerable: true, get: () => {
+    return defaultMaxListeners;
+  }, set: (arg) => {
+    validateNumber(arg, "defaultMaxListeners", 0), defaultMaxListeners = arg;
+  } }, kMaxEventTargetListeners: { value: kMaxEventTargetListeners, enumerable: false, configurable: false, writable: false }, kMaxEventTargetListenersWarned: { value: kMaxEventTargetListenersWarned, enumerable: false, configurable: false, writable: false } });
+  Object.assign(EventEmitter, { once: once2, getEventListeners, getMaxListeners: getMaxListeners2, setMaxListeners: setMaxListeners2, EventEmitter, usingDomains: false, captureRejectionSymbol, errorMonitor: kErrorMonitor, addAbortListener, init: EventEmitter, listenerCount: listenerCount2 });
+  events_default = EventEmitter;
+});
+
+// node:path
+var exports_path = {};
+__export(exports_path, {
+  sep: () => sep,
+  resolve: () => resolve,
+  relative: () => relative,
+  posix: () => posix,
+  parse: () => parse,
+  normalize: () => normalize,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  format: () => format,
+  extname: () => extname,
+  dirname: () => dirname,
+  delimiter: () => delimiter,
+  default: () => path_default,
+  basename: () => basename,
+  _makeLong: () => _makeLong
+});
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/", delimiter = ":", posix, path_default;
+var init_path = __esm(() => {
+  posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+  path_default = posix;
+});
+
+// node:process
+var exports_process = {};
+__export(exports_process, {
+  versions: () => versions,
+  version: () => version,
+  umask: () => umask,
+  title: () => title,
+  removeListener: () => removeListener,
+  removeAllListeners: () => removeAllListeners,
+  prependOnceListener: () => prependOnceListener,
+  prependListener: () => prependListener,
+  once: () => once,
+  on: () => on,
+  off: () => off,
+  nextTick: () => nextTick,
+  listeners: () => listeners,
+  env: () => env,
+  emit: () => emit,
+  cwd: () => cwd,
+  chdir: () => chdir,
+  browser: () => browser,
+  binding: () => binding,
+  argv: () => argv,
+  addListener: () => addListener
+});
+function cleanUpNextTick() {
+  if (!draining || !currentQueue)
+    return;
+  if (draining = false, currentQueue.length)
+    queue = currentQueue.concat(queue);
+  else
+    queueIndex = -1;
+  if (queue.length)
+    drainQueue();
+}
+function drainQueue() {
+  if (draining)
+    return;
+  var timeout = setTimeout(cleanUpNextTick, 0);
+  draining = true;
+  var len = queue.length;
+  while (len) {
+    currentQueue = queue, queue = [];
+    while (++queueIndex < len)
+      if (currentQueue) {
+        var item = currentQueue[queueIndex];
+        item.fun.apply(null, item.array);
+      }
+    queueIndex = -1, len = queue.length;
+  }
+  currentQueue = null, draining = false, clearTimeout(timeout, 0);
+}
+function nextTick(fun) {
+  var args = Array(arguments.length - 1);
+  if (arguments.length > 1)
+    for (var i = 1;i < arguments.length; i++)
+      args[i - 1] = arguments[i];
+  if (queue.push({ fun, args }), queue.length === 1 && !draining)
+    setTimeout(drainQueue, 0);
+}
+function noop() {}
+var queue, draining = false, currentQueue, queueIndex = -1, title = "browser", browser = true, env, argv, version = "", versions, on, addListener, once, off, removeListener, removeAllListeners, emit, prependListener, prependOnceListener, listeners = function(name) {
+  return [];
+}, binding = function(name) {
+  throw Error("process.binding is not supported in browser polyfill");
+}, cwd = function() {
+  return "/";
+}, chdir = function(dir) {
+  throw Error("process.chdir is not supported in browser polyfill");
+}, umask = function() {
+  return 0;
+};
+var init_process = __esm(() => {
+  queue = [];
+  env = {};
+  argv = [];
+  versions = {};
+  on = noop;
+  addListener = noop;
+  once = noop;
+  off = noop;
+  removeListener = noop;
+  removeAllListeners = noop;
+  emit = noop;
+  prependListener = noop;
+  prependOnceListener = noop;
+});
+
+// node_modules/commander/lib/help.js
+var require_help = __commonJS((exports) => {
+  var { humanReadableArgName } = require_argument();
+
+  class Help {
+    constructor() {
+      this.helpWidth = undefined;
+      this.sortSubcommands = false;
+      this.sortOptions = false;
+      this.showGlobalOptions = false;
+    }
+    visibleCommands(cmd) {
+      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const helpCommand = cmd._getHelpCommand();
+      if (helpCommand && !helpCommand._hidden) {
+        visibleCommands.push(helpCommand);
+      }
+      if (this.sortSubcommands) {
+        visibleCommands.sort((a, b) => {
+          return a.name().localeCompare(b.name());
+        });
+      }
+      return visibleCommands;
+    }
+    compareOptions(a, b) {
+      const getSortKey = (option) => {
+        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+      };
+      return getSortKey(a).localeCompare(getSortKey(b));
+    }
+    visibleOptions(cmd) {
+      const visibleOptions = cmd.options.filter((option) => !option.hidden);
+      const helpOption = cmd._getHelpOption();
+      if (helpOption && !helpOption.hidden) {
+        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+        if (!removeShort && !removeLong) {
+          visibleOptions.push(helpOption);
+        } else if (helpOption.long && !removeLong) {
+          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+        } else if (helpOption.short && !removeShort) {
+          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+        }
+      }
+      if (this.sortOptions) {
+        visibleOptions.sort(this.compareOptions);
+      }
+      return visibleOptions;
+    }
+    visibleGlobalOptions(cmd) {
+      if (!this.showGlobalOptions)
+        return [];
+      const globalOptions = [];
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+        globalOptions.push(...visibleOptions);
+      }
+      if (this.sortOptions) {
+        globalOptions.sort(this.compareOptions);
+      }
+      return globalOptions;
+    }
+    visibleArguments(cmd) {
+      if (cmd._argsDescription) {
+        cmd.registeredArguments.forEach((argument) => {
+          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+        });
+      }
+      if (cmd.registeredArguments.find((argument) => argument.description)) {
+        return cmd.registeredArguments;
+      }
+      return [];
+    }
+    subcommandTerm(cmd) {
+      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
+      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
+    }
+    optionTerm(option) {
+      return option.flags;
+    }
+    argumentTerm(argument) {
+      return argument.name();
+    }
+    longestSubcommandTermLength(cmd, helper) {
+      return helper.visibleCommands(cmd).reduce((max, command) => {
+        return Math.max(max, helper.subcommandTerm(command).length);
+      }, 0);
+    }
+    longestOptionTermLength(cmd, helper) {
+      return helper.visibleOptions(cmd).reduce((max, option) => {
+        return Math.max(max, helper.optionTerm(option).length);
+      }, 0);
+    }
+    longestGlobalOptionTermLength(cmd, helper) {
+      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+        return Math.max(max, helper.optionTerm(option).length);
+      }, 0);
+    }
+    longestArgumentTermLength(cmd, helper) {
+      return helper.visibleArguments(cmd).reduce((max, argument) => {
+        return Math.max(max, helper.argumentTerm(argument).length);
+      }, 0);
+    }
+    commandUsage(cmd) {
+      let cmdName = cmd._name;
+      if (cmd._aliases[0]) {
+        cmdName = cmdName + "|" + cmd._aliases[0];
+      }
+      let ancestorCmdNames = "";
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
+      }
+      return ancestorCmdNames + cmdName + " " + cmd.usage();
+    }
+    commandDescription(cmd) {
+      return cmd.description();
+    }
+    subcommandDescription(cmd) {
+      return cmd.summary() || cmd.description();
+    }
+    optionDescription(option) {
+      const extraInfo = [];
+      if (option.argChoices) {
+        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+      }
+      if (option.defaultValue !== undefined) {
+        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
+        if (showDefault) {
+          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+        }
+      }
+      if (option.presetArg !== undefined && option.optional) {
+        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
+      }
+      if (option.envVar !== undefined) {
+        extraInfo.push(`env: ${option.envVar}`);
+      }
+      if (extraInfo.length > 0) {
+        return `${option.description} (${extraInfo.join(", ")})`;
+      }
+      return option.description;
+    }
+    argumentDescription(argument) {
+      const extraInfo = [];
+      if (argument.argChoices) {
+        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+      }
+      if (argument.defaultValue !== undefined) {
+        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+      }
+      if (extraInfo.length > 0) {
+        const extraDescripton = `(${extraInfo.join(", ")})`;
+        if (argument.description) {
+          return `${argument.description} ${extraDescripton}`;
+        }
+        return extraDescripton;
+      }
+      return argument.description;
+    }
+    formatHelp(cmd, helper) {
+      const termWidth = helper.padWidth(cmd, helper);
+      const helpWidth = helper.helpWidth || 80;
+      const itemIndentWidth = 2;
+      const itemSeparatorWidth = 2;
+      function formatItem(term, description) {
+        if (description) {
+          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+        }
+        return term;
+      }
+      function formatList(textArray) {
+        return textArray.join(`
+`).replace(/^/gm, " ".repeat(itemIndentWidth));
+      }
+      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+      const commandDescription = helper.commandDescription(cmd);
+      if (commandDescription.length > 0) {
+        output = output.concat([
+          helper.wrap(commandDescription, helpWidth, 0),
+          ""
+        ]);
+      }
+      const argumentList = helper.visibleArguments(cmd).map((argument) => {
+        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+      });
+      if (argumentList.length > 0) {
+        output = output.concat(["Arguments:", formatList(argumentList), ""]);
+      }
+      const optionList = helper.visibleOptions(cmd).map((option) => {
+        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+      });
+      if (optionList.length > 0) {
+        output = output.concat(["Options:", formatList(optionList), ""]);
+      }
+      if (this.showGlobalOptions) {
+        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
+          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+        });
+        if (globalOptionList.length > 0) {
+          output = output.concat([
+            "Global Options:",
+            formatList(globalOptionList),
+            ""
+          ]);
+        }
+      }
+      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
+        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+      });
+      if (commandList.length > 0) {
+        output = output.concat(["Commands:", formatList(commandList), ""]);
+      }
+      return output.join(`
+`);
+    }
+    padWidth(cmd, helper) {
+      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
+    }
+    wrap(str, width, indent, minColumnWidth = 40) {
+      const indents = " \\f\\t\\v   -   　\uFEFF";
+      const manualIndent = new RegExp(`[\\n][${indents}]+`);
+      if (str.match(manualIndent))
+        return str;
+      const columnWidth = width - indent;
+      if (columnWidth < minColumnWidth)
+        return str;
+      const leadingStr = str.slice(0, indent);
+      const columnText = str.slice(indent).replace(`\r
+`, `
+`);
+      const indentString = " ".repeat(indent);
+      const zeroWidthSpace = "​";
+      const breaks = `\\s${zeroWidthSpace}`;
+      const regex = new RegExp(`
+|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
+      const lines = columnText.match(regex) || [];
+      return leadingStr + lines.map((line, i) => {
+        if (line === `
+`)
+          return "";
+        return (i > 0 ? indentString : "") + line.trimEnd();
+      }).join(`
+`);
+    }
+  }
+  exports.Help = Help;
+});
+
+// node_modules/commander/lib/option.js
+var require_option = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Option {
+    constructor(flags, description) {
+      this.flags = flags;
+      this.description = description || "";
+      this.required = flags.includes("<");
+      this.optional = flags.includes("[");
+      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
+      this.mandatory = false;
+      const optionFlags = splitOptionFlags(flags);
+      this.short = optionFlags.shortFlag;
+      this.long = optionFlags.longFlag;
+      this.negate = false;
+      if (this.long) {
+        this.negate = this.long.startsWith("--no-");
+      }
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.presetArg = undefined;
+      this.envVar = undefined;
+      this.parseArg = undefined;
+      this.hidden = false;
+      this.argChoices = undefined;
+      this.conflictsWith = [];
+      this.implied = undefined;
+    }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    preset(arg) {
+      this.presetArg = arg;
+      return this;
+    }
+    conflicts(names) {
+      this.conflictsWith = this.conflictsWith.concat(names);
+      return this;
+    }
+    implies(impliedOptionValues) {
+      let newImplied = impliedOptionValues;
+      if (typeof impliedOptionValues === "string") {
+        newImplied = { [impliedOptionValues]: true };
+      }
+      this.implied = Object.assign(this.implied || {}, newImplied);
+      return this;
+    }
+    env(name) {
+      this.envVar = name;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
+    makeOptionMandatory(mandatory = true) {
+      this.mandatory = !!mandatory;
+      return this;
+    }
+    hideHelp(hide = true) {
+      this.hidden = !!hide;
+      return this;
+    }
+    _concatValue(value, previous) {
+      if (previous === this.defaultValue || !Array.isArray(previous)) {
+        return [value];
+      }
+      return previous.concat(value);
+    }
+    choices(values) {
+      this.argChoices = values.slice();
+      this.parseArg = (arg, previous) => {
+        if (!this.argChoices.includes(arg)) {
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+        }
+        if (this.variadic) {
+          return this._concatValue(arg, previous);
+        }
+        return arg;
+      };
+      return this;
+    }
+    name() {
+      if (this.long) {
+        return this.long.replace(/^--/, "");
+      }
+      return this.short.replace(/^-/, "");
+    }
+    attributeName() {
+      return camelcase(this.name().replace(/^no-/, ""));
+    }
+    is(arg) {
+      return this.short === arg || this.long === arg;
+    }
+    isBoolean() {
+      return !this.required && !this.optional && !this.negate;
+    }
+  }
+
+  class DualOptions {
+    constructor(options) {
+      this.positiveOptions = new Map;
+      this.negativeOptions = new Map;
+      this.dualOptions = new Set;
+      options.forEach((option) => {
+        if (option.negate) {
+          this.negativeOptions.set(option.attributeName(), option);
+        } else {
+          this.positiveOptions.set(option.attributeName(), option);
+        }
+      });
+      this.negativeOptions.forEach((value, key) => {
+        if (this.positiveOptions.has(key)) {
+          this.dualOptions.add(key);
+        }
+      });
+    }
+    valueFromOption(value, option) {
+      const optionKey = option.attributeName();
+      if (!this.dualOptions.has(optionKey))
+        return true;
+      const preset = this.negativeOptions.get(optionKey).presetArg;
+      const negativeValue = preset !== undefined ? preset : false;
+      return option.negate === (negativeValue === value);
+    }
+  }
+  function camelcase(str) {
+    return str.split("-").reduce((str2, word) => {
+      return str2 + word[0].toUpperCase() + word.slice(1);
+    });
+  }
+  function splitOptionFlags(flags) {
+    let shortFlag;
+    let longFlag;
+    const flagParts = flags.split(/[ |,]+/);
+    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+      shortFlag = flagParts.shift();
+    longFlag = flagParts.shift();
+    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+      shortFlag = longFlag;
+      longFlag = undefined;
+    }
+    return { shortFlag, longFlag };
+  }
+  exports.Option = Option;
+  exports.DualOptions = DualOptions;
+});
+
+// node_modules/commander/lib/suggestSimilar.js
+var require_suggestSimilar = __commonJS((exports) => {
+  var maxDistance = 3;
+  function editDistance(a, b) {
+    if (Math.abs(a.length - b.length) > maxDistance)
+      return Math.max(a.length, b.length);
+    const d = [];
+    for (let i = 0;i <= a.length; i++) {
+      d[i] = [i];
+    }
+    for (let j = 0;j <= b.length; j++) {
+      d[0][j] = j;
+    }
+    for (let j = 1;j <= b.length; j++) {
+      for (let i = 1;i <= a.length; i++) {
+        let cost = 1;
+        if (a[i - 1] === b[j - 1]) {
+          cost = 0;
+        } else {
+          cost = 1;
+        }
+        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+        }
+      }
+    }
+    return d[a.length][b.length];
+  }
+  function suggestSimilar(word, candidates) {
+    if (!candidates || candidates.length === 0)
+      return "";
+    candidates = Array.from(new Set(candidates));
+    const searchingOptions = word.startsWith("--");
+    if (searchingOptions) {
+      word = word.slice(2);
+      candidates = candidates.map((candidate) => candidate.slice(2));
+    }
+    let similar = [];
+    let bestDistance = maxDistance;
+    const minSimilarity = 0.4;
+    candidates.forEach((candidate) => {
+      if (candidate.length <= 1)
+        return;
+      const distance = editDistance(word, candidate);
+      const length = Math.max(word.length, candidate.length);
+      const similarity = (length - distance) / length;
+      if (similarity > minSimilarity) {
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          similar = [candidate];
+        } else if (distance === bestDistance) {
+          similar.push(candidate);
+        }
+      }
+    });
+    similar.sort((a, b) => a.localeCompare(b));
+    if (searchingOptions) {
+      similar = similar.map((candidate) => `--${candidate}`);
+    }
+    if (similar.length > 1) {
+      return `
+(Did you mean one of ${similar.join(", ")}?)`;
+    }
+    if (similar.length === 1) {
+      return `
+(Did you mean ${similar[0]}?)`;
+    }
+    return "";
+  }
+  exports.suggestSimilar = suggestSimilar;
+});
+
+// node_modules/commander/lib/command.js
+var require_command = __commonJS((exports) => {
+  var EventEmitter2 = (init_events(), __toCommonJS(exports_events)).EventEmitter;
+  var childProcess = (() => ({}));
+  var path = (init_path(), __toCommonJS(exports_path));
+  var fs = (() => ({}));
+  var process2 = (init_process(), __toCommonJS(exports_process));
+  var { Argument, humanReadableArgName } = require_argument();
+  var { CommanderError } = require_error();
+  var { Help } = require_help();
+  var { Option, DualOptions } = require_option();
+  var { suggestSimilar } = require_suggestSimilar();
+
+  class Command extends EventEmitter2 {
+    constructor(name) {
+      super();
+      this.commands = [];
+      this.options = [];
+      this.parent = null;
+      this._allowUnknownOption = false;
+      this._allowExcessArguments = true;
+      this.registeredArguments = [];
+      this._args = this.registeredArguments;
+      this.args = [];
+      this.rawArgs = [];
+      this.processedArgs = [];
+      this._scriptPath = null;
+      this._name = name || "";
+      this._optionValues = {};
+      this._optionValueSources = {};
+      this._storeOptionsAsProperties = false;
+      this._actionHandler = null;
+      this._executableHandler = false;
+      this._executableFile = null;
+      this._executableDir = null;
+      this._defaultCommandName = null;
+      this._exitCallback = null;
+      this._aliases = [];
+      this._combineFlagAndOptionalValue = true;
+      this._description = "";
+      this._summary = "";
+      this._argsDescription = undefined;
+      this._enablePositionalOptions = false;
+      this._passThroughOptions = false;
+      this._lifeCycleHooks = {};
+      this._showHelpAfterError = false;
+      this._showSuggestionAfterError = true;
+      this._outputConfiguration = {
+        writeOut: (str) => process2.stdout.write(str),
+        writeErr: (str) => process2.stderr.write(str),
+        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
+        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
+        outputError: (str, write) => write(str)
+      };
+      this._hidden = false;
+      this._helpOption = undefined;
+      this._addImplicitHelpCommand = undefined;
+      this._helpCommand = undefined;
+      this._helpConfiguration = {};
+    }
+    copyInheritedSettings(sourceCommand) {
+      this._outputConfiguration = sourceCommand._outputConfiguration;
+      this._helpOption = sourceCommand._helpOption;
+      this._helpCommand = sourceCommand._helpCommand;
+      this._helpConfiguration = sourceCommand._helpConfiguration;
+      this._exitCallback = sourceCommand._exitCallback;
+      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
+      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
+      this._allowExcessArguments = sourceCommand._allowExcessArguments;
+      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
+      this._showHelpAfterError = sourceCommand._showHelpAfterError;
+      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
+      return this;
+    }
+    _getCommandAndAncestors() {
+      const result = [];
+      for (let command = this;command; command = command.parent) {
+        result.push(command);
+      }
+      return result;
+    }
+    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
+      let desc = actionOptsOrExecDesc;
+      let opts = execOpts;
+      if (typeof desc === "object" && desc !== null) {
+        opts = desc;
+        desc = null;
+      }
+      opts = opts || {};
+      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
+      const cmd = this.createCommand(name);
+      if (desc) {
+        cmd.description(desc);
+        cmd._executableHandler = true;
+      }
+      if (opts.isDefault)
+        this._defaultCommandName = cmd._name;
+      cmd._hidden = !!(opts.noHelp || opts.hidden);
+      cmd._executableFile = opts.executableFile || null;
+      if (args)
+        cmd.arguments(args);
+      this._registerCommand(cmd);
+      cmd.parent = this;
+      cmd.copyInheritedSettings(this);
+      if (desc)
+        return this;
+      return cmd;
+    }
+    createCommand(name) {
+      return new Command(name);
+    }
+    createHelp() {
+      return Object.assign(new Help, this.configureHelp());
+    }
+    configureHelp(configuration) {
+      if (configuration === undefined)
+        return this._helpConfiguration;
+      this._helpConfiguration = configuration;
+      return this;
+    }
+    configureOutput(configuration) {
+      if (configuration === undefined)
+        return this._outputConfiguration;
+      Object.assign(this._outputConfiguration, configuration);
+      return this;
+    }
+    showHelpAfterError(displayHelp = true) {
+      if (typeof displayHelp !== "string")
+        displayHelp = !!displayHelp;
+      this._showHelpAfterError = displayHelp;
+      return this;
+    }
+    showSuggestionAfterError(displaySuggestion = true) {
+      this._showSuggestionAfterError = !!displaySuggestion;
+      return this;
+    }
+    addCommand(cmd, opts) {
+      if (!cmd._name) {
+        throw new Error(`Command passed to .addCommand() must have a name
+- specify the name in Command constructor or using .name()`);
+      }
+      opts = opts || {};
+      if (opts.isDefault)
+        this._defaultCommandName = cmd._name;
+      if (opts.noHelp || opts.hidden)
+        cmd._hidden = true;
+      this._registerCommand(cmd);
+      cmd.parent = this;
+      cmd._checkForBrokenPassThrough();
+      return this;
+    }
+    createArgument(name, description) {
+      return new Argument(name, description);
+    }
+    argument(name, description, fn, defaultValue) {
+      const argument = this.createArgument(name, description);
+      if (typeof fn === "function") {
+        argument.default(defaultValue).argParser(fn);
+      } else {
+        argument.default(fn);
+      }
+      this.addArgument(argument);
+      return this;
+    }
+    arguments(names) {
+      names.trim().split(/ +/).forEach((detail) => {
+        this.argument(detail);
+      });
+      return this;
+    }
+    addArgument(argument) {
+      const previousArgument = this.registeredArguments.slice(-1)[0];
+      if (previousArgument && previousArgument.variadic) {
+        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
+      }
+      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
+        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
+      }
+      this.registeredArguments.push(argument);
+      return this;
+    }
+    helpCommand(enableOrNameAndArgs, description) {
+      if (typeof enableOrNameAndArgs === "boolean") {
+        this._addImplicitHelpCommand = enableOrNameAndArgs;
+        return this;
+      }
+      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
+      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+      const helpDescription = description ?? "display help for command";
+      const helpCommand = this.createCommand(helpName);
+      helpCommand.helpOption(false);
+      if (helpArgs)
+        helpCommand.arguments(helpArgs);
+      if (helpDescription)
+        helpCommand.description(helpDescription);
+      this._addImplicitHelpCommand = true;
+      this._helpCommand = helpCommand;
+      return this;
+    }
+    addHelpCommand(helpCommand, deprecatedDescription) {
+      if (typeof helpCommand !== "object") {
+        this.helpCommand(helpCommand, deprecatedDescription);
+        return this;
+      }
+      this._addImplicitHelpCommand = true;
+      this._helpCommand = helpCommand;
+      return this;
+    }
+    _getHelpCommand() {
+      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
+      if (hasImplicitHelpCommand) {
+        if (this._helpCommand === undefined) {
+          this.helpCommand(undefined, undefined);
+        }
+        return this._helpCommand;
+      }
+      return null;
+    }
+    hook(event, listener) {
+      const allowedValues = ["preSubcommand", "preAction", "postAction"];
+      if (!allowedValues.includes(event)) {
+        throw new Error(`Unexpected value for event passed to hook : '${event}'.
+Expecting one of '${allowedValues.join("', '")}'`);
+      }
+      if (this._lifeCycleHooks[event]) {
+        this._lifeCycleHooks[event].push(listener);
+      } else {
+        this._lifeCycleHooks[event] = [listener];
+      }
+      return this;
+    }
+    exitOverride(fn) {
+      if (fn) {
+        this._exitCallback = fn;
+      } else {
+        this._exitCallback = (err) => {
+          if (err.code !== "commander.executeSubCommandAsync") {
+            throw err;
+          } else {}
+        };
+      }
+      return this;
+    }
+    _exit(exitCode, code, message) {
+      if (this._exitCallback) {
+        this._exitCallback(new CommanderError(exitCode, code, message));
+      }
+      process2.exit(exitCode);
+    }
+    action(fn) {
+      const listener = (args) => {
+        const expectedArgsCount = this.registeredArguments.length;
+        const actionArgs = args.slice(0, expectedArgsCount);
+        if (this._storeOptionsAsProperties) {
+          actionArgs[expectedArgsCount] = this;
+        } else {
+          actionArgs[expectedArgsCount] = this.opts();
+        }
+        actionArgs.push(this);
+        return fn.apply(this, actionArgs);
+      };
+      this._actionHandler = listener;
+      return this;
+    }
+    createOption(flags, description) {
+      return new Option(flags, description);
+    }
+    _callParseArg(target, value, previous, invalidArgumentMessage) {
+      try {
+        return target.parseArg(value, previous);
+      } catch (err) {
+        if (err.code === "commander.invalidArgument") {
+          const message = `${invalidArgumentMessage} ${err.message}`;
+          this.error(message, { exitCode: err.exitCode, code: err.code });
+        }
+        throw err;
+      }
+    }
+    _registerOption(option) {
+      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
+      if (matchingOption) {
+        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
+        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
+-  already used by option '${matchingOption.flags}'`);
+      }
+      this.options.push(option);
+    }
+    _registerCommand(command) {
+      const knownBy = (cmd) => {
+        return [cmd.name()].concat(cmd.aliases());
+      };
+      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
+      if (alreadyUsed) {
+        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
+        const newCmd = knownBy(command).join("|");
+        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
+      }
+      this.commands.push(command);
+    }
+    addOption(option) {
+      this._registerOption(option);
+      const oname = option.name();
+      const name = option.attributeName();
+      if (option.negate) {
+        const positiveLongFlag = option.long.replace(/^--no-/, "--");
+        if (!this._findOption(positiveLongFlag)) {
+          this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, "default");
+        }
+      } else if (option.defaultValue !== undefined) {
+        this.setOptionValueWithSource(name, option.defaultValue, "default");
+      }
+      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
+        if (val == null && option.presetArg !== undefined) {
+          val = option.presetArg;
+        }
+        const oldValue = this.getOptionValue(name);
+        if (val !== null && option.parseArg) {
+          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
+        } else if (val !== null && option.variadic) {
+          val = option._concatValue(val, oldValue);
+        }
+        if (val == null) {
+          if (option.negate) {
+            val = false;
+          } else if (option.isBoolean() || option.optional) {
+            val = true;
+          } else {
+            val = "";
+          }
+        }
+        this.setOptionValueWithSource(name, val, valueSource);
+      };
+      this.on("option:" + oname, (val) => {
+        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
+        handleOptionValue(val, invalidValueMessage, "cli");
+      });
+      if (option.envVar) {
+        this.on("optionEnv:" + oname, (val) => {
+          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
+          handleOptionValue(val, invalidValueMessage, "env");
+        });
+      }
+      return this;
+    }
+    _optionEx(config, flags, description, fn, defaultValue) {
+      if (typeof flags === "object" && flags instanceof Option) {
+        throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
+      }
+      const option = this.createOption(flags, description);
+      option.makeOptionMandatory(!!config.mandatory);
+      if (typeof fn === "function") {
+        option.default(defaultValue).argParser(fn);
+      } else if (fn instanceof RegExp) {
+        const regex = fn;
+        fn = (val, def) => {
+          const m = regex.exec(val);
+          return m ? m[0] : def;
+        };
+        option.default(defaultValue).argParser(fn);
+      } else {
+        option.default(fn);
+      }
+      return this.addOption(option);
+    }
+    option(flags, description, parseArg, defaultValue) {
+      return this._optionEx({}, flags, description, parseArg, defaultValue);
+    }
+    requiredOption(flags, description, parseArg, defaultValue) {
+      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
+    }
+    combineFlagAndOptionalValue(combine = true) {
+      this._combineFlagAndOptionalValue = !!combine;
+      return this;
+    }
+    allowUnknownOption(allowUnknown = true) {
+      this._allowUnknownOption = !!allowUnknown;
+      return this;
+    }
+    allowExcessArguments(allowExcess = true) {
+      this._allowExcessArguments = !!allowExcess;
+      return this;
+    }
+    enablePositionalOptions(positional = true) {
+      this._enablePositionalOptions = !!positional;
+      return this;
+    }
+    passThroughOptions(passThrough = true) {
+      this._passThroughOptions = !!passThrough;
+      this._checkForBrokenPassThrough();
+      return this;
+    }
+    _checkForBrokenPassThrough() {
+      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
+        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
+      }
+    }
+    storeOptionsAsProperties(storeAsProperties = true) {
+      if (this.options.length) {
+        throw new Error("call .storeOptionsAsProperties() before adding options");
+      }
+      if (Object.keys(this._optionValues).length) {
+        throw new Error("call .storeOptionsAsProperties() before setting option values");
+      }
+      this._storeOptionsAsProperties = !!storeAsProperties;
+      return this;
+    }
+    getOptionValue(key) {
+      if (this._storeOptionsAsProperties) {
+        return this[key];
+      }
+      return this._optionValues[key];
+    }
+    setOptionValue(key, value) {
+      return this.setOptionValueWithSource(key, value, undefined);
+    }
+    setOptionValueWithSource(key, value, source) {
+      if (this._storeOptionsAsProperties) {
+        this[key] = value;
+      } else {
+        this._optionValues[key] = value;
+      }
+      this._optionValueSources[key] = source;
+      return this;
+    }
+    getOptionValueSource(key) {
+      return this._optionValueSources[key];
+    }
+    getOptionValueSourceWithGlobals(key) {
+      let source;
+      this._getCommandAndAncestors().forEach((cmd) => {
+        if (cmd.getOptionValueSource(key) !== undefined) {
+          source = cmd.getOptionValueSource(key);
+        }
+      });
+      return source;
+    }
+    _prepareUserArgs(argv2, parseOptions) {
+      if (argv2 !== undefined && !Array.isArray(argv2)) {
+        throw new Error("first parameter to parse must be array or undefined");
+      }
+      parseOptions = parseOptions || {};
+      if (argv2 === undefined && parseOptions.from === undefined) {
+        if (process2.versions?.electron) {
+          parseOptions.from = "electron";
+        }
+        const execArgv = process2.execArgv ?? [];
+        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
+          parseOptions.from = "eval";
+        }
+      }
+      if (argv2 === undefined) {
+        argv2 = process2.argv;
+      }
+      this.rawArgs = argv2.slice();
+      let userArgs;
+      switch (parseOptions.from) {
+        case undefined:
+        case "node":
+          this._scriptPath = argv2[1];
+          userArgs = argv2.slice(2);
+          break;
+        case "electron":
+          if (process2.defaultApp) {
+            this._scriptPath = argv2[1];
+            userArgs = argv2.slice(2);
+          } else {
+            userArgs = argv2.slice(1);
+          }
+          break;
+        case "user":
+          userArgs = argv2.slice(0);
+          break;
+        case "eval":
+          userArgs = argv2.slice(1);
+          break;
+        default:
+          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
+      }
+      if (!this._name && this._scriptPath)
+        this.nameFromFilename(this._scriptPath);
+      this._name = this._name || "program";
+      return userArgs;
+    }
+    parse(argv2, parseOptions) {
+      const userArgs = this._prepareUserArgs(argv2, parseOptions);
+      this._parseCommand([], userArgs);
+      return this;
+    }
+    async parseAsync(argv2, parseOptions) {
+      const userArgs = this._prepareUserArgs(argv2, parseOptions);
+      await this._parseCommand([], userArgs);
+      return this;
+    }
+    _executeSubCommand(subcommand, args) {
+      args = args.slice();
+      let launchWithNode = false;
+      const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
+      function findFile(baseDir, baseName) {
+        const localBin = path.resolve(baseDir, baseName);
+        if (fs.existsSync(localBin))
+          return localBin;
+        if (sourceExt.includes(path.extname(baseName)))
+          return;
+        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
+        if (foundExt)
+          return `${localBin}${foundExt}`;
+        return;
+      }
+      this._checkForMissingMandatoryOptions();
+      this._checkForConflictingOptions();
+      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
+      let executableDir = this._executableDir || "";
+      if (this._scriptPath) {
+        let resolvedScriptPath;
+        try {
+          resolvedScriptPath = fs.realpathSync(this._scriptPath);
+        } catch (err) {
+          resolvedScriptPath = this._scriptPath;
+        }
+        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+      }
+      if (executableDir) {
+        let localFile = findFile(executableDir, executableFile);
+        if (!localFile && !subcommand._executableFile && this._scriptPath) {
+          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+          if (legacyName !== this._name) {
+            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
+          }
+        }
+        executableFile = localFile || executableFile;
+      }
+      launchWithNode = sourceExt.includes(path.extname(executableFile));
+      let proc;
+      if (process2.platform !== "win32") {
+        if (launchWithNode) {
+          args.unshift(executableFile);
+          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+        } else {
+          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
+        }
+      } else {
+        args.unshift(executableFile);
+        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+      }
+      if (!proc.killed) {
+        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
+        signals.forEach((signal) => {
+          process2.on(signal, () => {
+            if (proc.killed === false && proc.exitCode === null) {
+              proc.kill(signal);
+            }
+          });
+        });
+      }
+      const exitCallback = this._exitCallback;
+      proc.on("close", (code) => {
+        code = code ?? 1;
+        if (!exitCallback) {
+          process2.exit(code);
+        } else {
+          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
+        }
+      });
+      proc.on("error", (err) => {
+        if (err.code === "ENOENT") {
+          const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+          const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+          throw new Error(executableMissing);
+        } else if (err.code === "EACCES") {
+          throw new Error(`'${executableFile}' not executable`);
+        }
+        if (!exitCallback) {
+          process2.exit(1);
+        } else {
+          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
+          wrappedError.nestedError = err;
+          exitCallback(wrappedError);
+        }
+      });
+      this.runningCommand = proc;
+    }
+    _dispatchSubcommand(commandName, operands, unknown) {
+      const subCommand = this._findCommand(commandName);
+      if (!subCommand)
+        this.help({ error: true });
+      let promiseChain;
+      promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
+      promiseChain = this._chainOrCall(promiseChain, () => {
+        if (subCommand._executableHandler) {
+          this._executeSubCommand(subCommand, operands.concat(unknown));
+        } else {
+          return subCommand._parseCommand(operands, unknown);
+        }
+      });
+      return promiseChain;
+    }
+    _dispatchHelpCommand(subcommandName) {
+      if (!subcommandName) {
+        this.help();
+      }
+      const subCommand = this._findCommand(subcommandName);
+      if (subCommand && !subCommand._executableHandler) {
+        subCommand.help();
+      }
+      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
+    }
+    _checkNumberOfArguments() {
+      this.registeredArguments.forEach((arg, i) => {
+        if (arg.required && this.args[i] == null) {
+          this.missingArgument(arg.name());
+        }
+      });
+      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
+        return;
+      }
+      if (this.args.length > this.registeredArguments.length) {
+        this._excessArguments(this.args);
+      }
+    }
+    _processArguments() {
+      const myParseArg = (argument, value, previous) => {
+        let parsedValue = value;
+        if (value !== null && argument.parseArg) {
+          const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
+          parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
+        }
+        return parsedValue;
+      };
+      this._checkNumberOfArguments();
+      const processedArgs = [];
+      this.registeredArguments.forEach((declaredArg, index) => {
+        let value = declaredArg.defaultValue;
+        if (declaredArg.variadic) {
+          if (index < this.args.length) {
+            value = this.args.slice(index);
+            if (declaredArg.parseArg) {
+              value = value.reduce((processed, v) => {
+                return myParseArg(declaredArg, v, processed);
+              }, declaredArg.defaultValue);
+            }
+          } else if (value === undefined) {
+            value = [];
+          }
+        } else if (index < this.args.length) {
+          value = this.args[index];
+          if (declaredArg.parseArg) {
+            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
+          }
+        }
+        processedArgs[index] = value;
+      });
+      this.processedArgs = processedArgs;
+    }
+    _chainOrCall(promise, fn) {
+      if (promise && promise.then && typeof promise.then === "function") {
+        return promise.then(() => fn());
+      }
+      return fn();
+    }
+    _chainOrCallHooks(promise, event) {
+      let result = promise;
+      const hooks = [];
+      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
+        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
+          hooks.push({ hookedCommand, callback });
+        });
+      });
+      if (event === "postAction") {
+        hooks.reverse();
+      }
+      hooks.forEach((hookDetail) => {
+        result = this._chainOrCall(result, () => {
+          return hookDetail.callback(hookDetail.hookedCommand, this);
+        });
+      });
+      return result;
+    }
+    _chainOrCallSubCommandHook(promise, subCommand, event) {
+      let result = promise;
+      if (this._lifeCycleHooks[event] !== undefined) {
+        this._lifeCycleHooks[event].forEach((hook) => {
+          result = this._chainOrCall(result, () => {
+            return hook(this, subCommand);
+          });
+        });
+      }
+      return result;
+    }
+    _parseCommand(operands, unknown) {
+      const parsed = this.parseOptions(unknown);
+      this._parseOptionsEnv();
+      this._parseOptionsImplied();
+      operands = operands.concat(parsed.operands);
+      unknown = parsed.unknown;
+      this.args = operands.concat(unknown);
+      if (operands && this._findCommand(operands[0])) {
+        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
+      }
+      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
+        return this._dispatchHelpCommand(operands[1]);
+      }
+      if (this._defaultCommandName) {
+        this._outputHelpIfRequested(unknown);
+        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+      }
+      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
+        this.help({ error: true });
+      }
+      this._outputHelpIfRequested(parsed.unknown);
+      this._checkForMissingMandatoryOptions();
+      this._checkForConflictingOptions();
+      const checkForUnknownOptions = () => {
+        if (parsed.unknown.length > 0) {
+          this.unknownOption(parsed.unknown[0]);
+        }
+      };
+      const commandEvent = `command:${this.name()}`;
+      if (this._actionHandler) {
+        checkForUnknownOptions();
+        this._processArguments();
+        let promiseChain;
+        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
+        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
+        if (this.parent) {
+          promiseChain = this._chainOrCall(promiseChain, () => {
+            this.parent.emit(commandEvent, operands, unknown);
+          });
+        }
+        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
+        return promiseChain;
+      }
+      if (this.parent && this.parent.listenerCount(commandEvent)) {
+        checkForUnknownOptions();
+        this._processArguments();
+        this.parent.emit(commandEvent, operands, unknown);
+      } else if (operands.length) {
+        if (this._findCommand("*")) {
+          return this._dispatchSubcommand("*", operands, unknown);
+        }
+        if (this.listenerCount("command:*")) {
+          this.emit("command:*", operands, unknown);
+        } else if (this.commands.length) {
+          this.unknownCommand();
+        } else {
+          checkForUnknownOptions();
+          this._processArguments();
+        }
+      } else if (this.commands.length) {
+        checkForUnknownOptions();
+        this.help({ error: true });
+      } else {
+        checkForUnknownOptions();
+        this._processArguments();
+      }
+    }
+    _findCommand(name) {
+      if (!name)
+        return;
+      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
+    }
+    _findOption(arg) {
+      return this.options.find((option) => option.is(arg));
+    }
+    _checkForMissingMandatoryOptions() {
+      this._getCommandAndAncestors().forEach((cmd) => {
+        cmd.options.forEach((anOption) => {
+          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
+            cmd.missingMandatoryOptionValue(anOption);
+          }
+        });
+      });
+    }
+    _checkForConflictingLocalOptions() {
+      const definedNonDefaultOptions = this.options.filter((option) => {
+        const optionKey = option.attributeName();
+        if (this.getOptionValue(optionKey) === undefined) {
+          return false;
+        }
+        return this.getOptionValueSource(optionKey) !== "default";
+      });
+      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
+      optionsWithConflicting.forEach((option) => {
+        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
+        if (conflictingAndDefined) {
+          this._conflictingOption(option, conflictingAndDefined);
+        }
+      });
+    }
+    _checkForConflictingOptions() {
+      this._getCommandAndAncestors().forEach((cmd) => {
+        cmd._checkForConflictingLocalOptions();
+      });
+    }
+    parseOptions(argv2) {
+      const operands = [];
+      const unknown = [];
+      let dest = operands;
+      const args = argv2.slice();
+      function maybeOption(arg) {
+        return arg.length > 1 && arg[0] === "-";
+      }
+      let activeVariadicOption = null;
+      while (args.length) {
+        const arg = args.shift();
+        if (arg === "--") {
+          if (dest === unknown)
+            dest.push(arg);
+          dest.push(...args);
+          break;
+        }
+        if (activeVariadicOption && !maybeOption(arg)) {
+          this.emit(`option:${activeVariadicOption.name()}`, arg);
+          continue;
+        }
+        activeVariadicOption = null;
+        if (maybeOption(arg)) {
+          const option = this._findOption(arg);
+          if (option) {
+            if (option.required) {
+              const value = args.shift();
+              if (value === undefined)
+                this.optionMissingArgument(option);
+              this.emit(`option:${option.name()}`, value);
+            } else if (option.optional) {
+              let value = null;
+              if (args.length > 0 && !maybeOption(args[0])) {
+                value = args.shift();
+              }
+              this.emit(`option:${option.name()}`, value);
+            } else {
+              this.emit(`option:${option.name()}`);
+            }
+            activeVariadicOption = option.variadic ? option : null;
+            continue;
+          }
+        }
+        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
+          const option = this._findOption(`-${arg[1]}`);
+          if (option) {
+            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
+              this.emit(`option:${option.name()}`, arg.slice(2));
+            } else {
+              this.emit(`option:${option.name()}`);
+              args.unshift(`-${arg.slice(2)}`);
+            }
+            continue;
+          }
+        }
+        if (/^--[^=]+=/.test(arg)) {
+          const index = arg.indexOf("=");
+          const option = this._findOption(arg.slice(0, index));
+          if (option && (option.required || option.optional)) {
+            this.emit(`option:${option.name()}`, arg.slice(index + 1));
+            continue;
+          }
+        }
+        if (maybeOption(arg)) {
+          dest = unknown;
+        }
+        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
+          if (this._findCommand(arg)) {
+            operands.push(arg);
+            if (args.length > 0)
+              unknown.push(...args);
+            break;
+          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
+            operands.push(arg);
+            if (args.length > 0)
+              operands.push(...args);
+            break;
+          } else if (this._defaultCommandName) {
+            unknown.push(arg);
+            if (args.length > 0)
+              unknown.push(...args);
+            break;
+          }
+        }
+        if (this._passThroughOptions) {
+          dest.push(arg);
+          if (args.length > 0)
+            dest.push(...args);
+          break;
+        }
+        dest.push(arg);
+      }
+      return { operands, unknown };
+    }
+    opts() {
+      if (this._storeOptionsAsProperties) {
+        const result = {};
+        const len = this.options.length;
+        for (let i = 0;i < len; i++) {
+          const key = this.options[i].attributeName();
+          result[key] = key === this._versionOptionName ? this._version : this[key];
+        }
+        return result;
+      }
+      return this._optionValues;
+    }
+    optsWithGlobals() {
+      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
+    }
+    error(message, errorOptions) {
+      this._outputConfiguration.outputError(`${message}
+`, this._outputConfiguration.writeErr);
+      if (typeof this._showHelpAfterError === "string") {
+        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
+`);
+      } else if (this._showHelpAfterError) {
+        this._outputConfiguration.writeErr(`
+`);
+        this.outputHelp({ error: true });
+      }
+      const config = errorOptions || {};
+      const exitCode = config.exitCode || 1;
+      const code = config.code || "commander.error";
+      this._exit(exitCode, code, message);
+    }
+    _parseOptionsEnv() {
+      this.options.forEach((option) => {
+        if (option.envVar && option.envVar in process2.env) {
+          const optionKey = option.attributeName();
+          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
+            if (option.required || option.optional) {
+              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+            } else {
+              this.emit(`optionEnv:${option.name()}`);
+            }
+          }
+        }
+      });
+    }
+    _parseOptionsImplied() {
+      const dualHelper = new DualOptions(this.options);
+      const hasCustomOptionValue = (optionKey) => {
+        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
+      };
+      this.options.filter((option) => option.implied !== undefined && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
+        Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
+          this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
+        });
+      });
+    }
+    missingArgument(name) {
+      const message = `error: missing required argument '${name}'`;
+      this.error(message, { code: "commander.missingArgument" });
+    }
+    optionMissingArgument(option) {
+      const message = `error: option '${option.flags}' argument missing`;
+      this.error(message, { code: "commander.optionMissingArgument" });
+    }
+    missingMandatoryOptionValue(option) {
+      const message = `error: required option '${option.flags}' not specified`;
+      this.error(message, { code: "commander.missingMandatoryOptionValue" });
+    }
+    _conflictingOption(option, conflictingOption) {
+      const findBestOptionFromValue = (option2) => {
+        const optionKey = option2.attributeName();
+        const optionValue = this.getOptionValue(optionKey);
+        const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
+        const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
+        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
+          return negativeOption;
+        }
+        return positiveOption || option2;
+      };
+      const getErrorMessage = (option2) => {
+        const bestOption = findBestOptionFromValue(option2);
+        const optionKey = bestOption.attributeName();
+        const source = this.getOptionValueSource(optionKey);
+        if (source === "env") {
+          return `environment variable '${bestOption.envVar}'`;
+        }
+        return `option '${bestOption.flags}'`;
+      };
+      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
+      this.error(message, { code: "commander.conflictingOption" });
+    }
+    unknownOption(flag) {
+      if (this._allowUnknownOption)
+        return;
+      let suggestion = "";
+      if (flag.startsWith("--") && this._showSuggestionAfterError) {
+        let candidateFlags = [];
+        let command = this;
+        do {
+          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
+          candidateFlags = candidateFlags.concat(moreFlags);
+          command = command.parent;
+        } while (command && !command._enablePositionalOptions);
+        suggestion = suggestSimilar(flag, candidateFlags);
+      }
+      const message = `error: unknown option '${flag}'${suggestion}`;
+      this.error(message, { code: "commander.unknownOption" });
+    }
+    _excessArguments(receivedArgs) {
+      if (this._allowExcessArguments)
+        return;
+      const expected = this.registeredArguments.length;
+      const s = expected === 1 ? "" : "s";
+      const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
+      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
+      this.error(message, { code: "commander.excessArguments" });
+    }
+    unknownCommand() {
+      const unknownName = this.args[0];
+      let suggestion = "";
+      if (this._showSuggestionAfterError) {
+        const candidateNames = [];
+        this.createHelp().visibleCommands(this).forEach((command) => {
+          candidateNames.push(command.name());
+          if (command.alias())
+            candidateNames.push(command.alias());
+        });
+        suggestion = suggestSimilar(unknownName, candidateNames);
+      }
+      const message = `error: unknown command '${unknownName}'${suggestion}`;
+      this.error(message, { code: "commander.unknownCommand" });
+    }
+    version(str, flags, description) {
+      if (str === undefined)
+        return this._version;
+      this._version = str;
+      flags = flags || "-V, --version";
+      description = description || "output the version number";
+      const versionOption = this.createOption(flags, description);
+      this._versionOptionName = versionOption.attributeName();
+      this._registerOption(versionOption);
+      this.on("option:" + versionOption.name(), () => {
+        this._outputConfiguration.writeOut(`${str}
+`);
+        this._exit(0, "commander.version", str);
+      });
+      return this;
+    }
+    description(str, argsDescription) {
+      if (str === undefined && argsDescription === undefined)
+        return this._description;
+      this._description = str;
+      if (argsDescription) {
+        this._argsDescription = argsDescription;
+      }
+      return this;
+    }
+    summary(str) {
+      if (str === undefined)
+        return this._summary;
+      this._summary = str;
+      return this;
+    }
+    alias(alias) {
+      if (alias === undefined)
+        return this._aliases[0];
+      let command = this;
+      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+        command = this.commands[this.commands.length - 1];
+      }
+      if (alias === command._name)
+        throw new Error("Command alias can't be the same as its name");
+      const matchingCommand = this.parent?._findCommand(alias);
+      if (matchingCommand) {
+        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
+        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+      }
+      command._aliases.push(alias);
+      return this;
+    }
+    aliases(aliases) {
+      if (aliases === undefined)
+        return this._aliases;
+      aliases.forEach((alias) => this.alias(alias));
+      return this;
+    }
+    usage(str) {
+      if (str === undefined) {
+        if (this._usage)
+          return this._usage;
+        const args = this.registeredArguments.map((arg) => {
+          return humanReadableArgName(arg);
+        });
+        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
+      }
+      this._usage = str;
+      return this;
+    }
+    name(str) {
+      if (str === undefined)
+        return this._name;
+      this._name = str;
+      return this;
+    }
+    nameFromFilename(filename) {
+      this._name = path.basename(filename, path.extname(filename));
+      return this;
+    }
+    executableDir(path2) {
+      if (path2 === undefined)
+        return this._executableDir;
+      this._executableDir = path2;
+      return this;
+    }
+    helpInformation(contextOptions) {
+      const helper = this.createHelp();
+      if (helper.helpWidth === undefined) {
+        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
+      }
+      return helper.formatHelp(this, helper);
+    }
+    _getHelpContext(contextOptions) {
+      contextOptions = contextOptions || {};
+      const context = { error: !!contextOptions.error };
+      let write;
+      if (context.error) {
+        write = (arg) => this._outputConfiguration.writeErr(arg);
+      } else {
+        write = (arg) => this._outputConfiguration.writeOut(arg);
+      }
+      context.write = contextOptions.write || write;
+      context.command = this;
+      return context;
+    }
+    outputHelp(contextOptions) {
+      let deprecatedCallback;
+      if (typeof contextOptions === "function") {
+        deprecatedCallback = contextOptions;
+        contextOptions = undefined;
+      }
+      const context = this._getHelpContext(contextOptions);
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
+      this.emit("beforeHelp", context);
+      let helpInformation = this.helpInformation(context);
+      if (deprecatedCallback) {
+        helpInformation = deprecatedCallback(helpInformation);
+        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
+          throw new Error("outputHelp callback must return a string or a Buffer");
+        }
+      }
+      context.write(helpInformation);
+      if (this._getHelpOption()?.long) {
+        this.emit(this._getHelpOption().long);
+      }
+      this.emit("afterHelp", context);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
+    }
+    helpOption(flags, description) {
+      if (typeof flags === "boolean") {
+        if (flags) {
+          this._helpOption = this._helpOption ?? undefined;
+        } else {
+          this._helpOption = null;
+        }
+        return this;
+      }
+      flags = flags ?? "-h, --help";
+      description = description ?? "display help for command";
+      this._helpOption = this.createOption(flags, description);
+      return this;
+    }
+    _getHelpOption() {
+      if (this._helpOption === undefined) {
+        this.helpOption(undefined, undefined);
+      }
+      return this._helpOption;
+    }
+    addHelpOption(option) {
+      this._helpOption = option;
+      return this;
+    }
+    help(contextOptions) {
+      this.outputHelp(contextOptions);
+      let exitCode = process2.exitCode || 0;
+      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode = 1;
+      }
+      this._exit(exitCode, "commander.help", "(outputHelp)");
+    }
+    addHelpText(position, text) {
+      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
+      if (!allowedValues.includes(position)) {
+        throw new Error(`Unexpected value for position to addHelpText.
+Expecting one of '${allowedValues.join("', '")}'`);
+      }
+      const helpEvent = `${position}Help`;
+      this.on(helpEvent, (context) => {
+        let helpStr;
+        if (typeof text === "function") {
+          helpStr = text({ error: context.error, command: context.command });
+        } else {
+          helpStr = text;
+        }
+        if (helpStr) {
+          context.write(`${helpStr}
+`);
+        }
+      });
+      return this;
+    }
+    _outputHelpIfRequested(args) {
+      const helpOption = this._getHelpOption();
+      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
+      if (helpRequested) {
+        this.outputHelp();
+        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      }
+    }
+  }
+  function incrementNodeInspectorPort(args) {
+    return args.map((arg) => {
+      if (!arg.startsWith("--inspect")) {
+        return arg;
+      }
+      let debugOption;
+      let debugHost = "127.0.0.1";
+      let debugPort = "9229";
+      let match;
+      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
+        debugOption = match[1];
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+        debugOption = match[1];
+        if (/^\d+$/.test(match[3])) {
+          debugPort = match[3];
+        } else {
+          debugHost = match[3];
+        }
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+        debugOption = match[1];
+        debugHost = match[3];
+        debugPort = match[4];
+      }
+      if (debugOption && debugPort !== "0") {
+        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
+      }
+      return arg;
+    });
+  }
+  exports.Command = Command;
+});
+
+// node_modules/commander/index.js
+var require_commander = __commonJS((exports) => {
+  var { Argument } = require_argument();
+  var { Command } = require_command();
+  var { CommanderError, InvalidArgumentError } = require_error();
+  var { Help } = require_help();
+  var { Option } = require_option();
+  exports.program = new Command;
+  exports.createCommand = (name) => new Command(name);
+  exports.createOption = (flags, description) => new Option(flags, description);
+  exports.createArgument = (name, description) => new Argument(name, description);
+  exports.Command = Command;
+  exports.Option = Option;
+  exports.Argument = Argument;
+  exports.Help = Help;
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+  exports.InvalidOptionArgumentError = InvalidArgumentError;
+});
+
+// node_modules/commander/esm.mjs
+var import__ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
+
+// src/gen/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+};
+// src/gen/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+// src/gen/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3000;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted)
+        break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== undefined) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body)
+          throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {}
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+            const chunks = buffer.split(`
+
+`);
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split(`
+`);
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join(`
+`);
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// src/gen/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+    allowReserved,
+    name: style === "deepObject" ? `${name}[${key}]` : key,
+    value: v
+  })).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// src/gen/core/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(match, serializeObjectParam({
+          explode,
+          name,
+          style,
+          value,
+          valueOnly: true
+        }));
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(match, `;${serializePrimitiveParam({
+          name,
+          value
+        })}`);
+        continue;
+      }
+      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== undefined;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return;
+}
+
+// src/gen/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// src/gen/client/utils.gen.ts
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === undefined || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray)
+            search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject)
+            search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive)
+            search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+var setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+var buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers;
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== undefined) {
+        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+      }
+    }
+  }
+  return mergedHeaders;
+};
+
+class Interceptors {
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+}
+var createInterceptors = () => ({
+  error: new Interceptors,
+  request: new Interceptors,
+  response: new Interceptors
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// src/gen/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === undefined || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response;
+    try {
+      response = await _fetch(request2);
+    } catch (error2) {
+      let finalError2 = error2;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(error2, undefined, request2, opts);
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? undefined : {
+        error: finalError2,
+        request: request2,
+        response: undefined
+      };
+    }
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData;
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === "data" ? emptyData : {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "json": {
+          const text = await response.text();
+          data = text ? JSON.parse(text) : {};
+          break;
+        }
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {}
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? undefined : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+// src/openapi-runtime.ts
+var DEFAULT_BASE_URL = "https://api.multisender.app";
+var DEFAULT_TIMEOUT = 30000;
+var defaultRuntimeConfig = {
+  apiKey: "",
+  baseUrl: DEFAULT_BASE_URL,
+  timeout: DEFAULT_TIMEOUT,
+  headers: {}
+};
+var mergeHeaders2 = (headers) => ({
+  ...headers
+});
+var withTimeoutFetch = (timeoutMs) => {
+  const timeout = timeoutMs ?? DEFAULT_TIMEOUT;
+  return async (input, init) => {
+    if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+      const timeoutSignal = AbortSignal.timeout(timeout);
+      if (!init?.signal) {
+        return fetch(input, { ...init, signal: timeoutSignal });
+      }
+      const controller2 = new AbortController;
+      const abort = () => controller2.abort();
+      timeoutSignal.addEventListener("abort", abort, { once: true });
+      init.signal.addEventListener("abort", abort, { once: true });
+      const signal2 = controller2.signal;
+      return fetch(input, { ...init, signal: signal2 });
+    }
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    init?.signal?.addEventListener("abort", () => controller.abort(), { once: true });
+    const signal = controller.signal;
+    try {
+      return await fetch(input, { ...init, signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+};
+var toClientConfig = (config) => ({
+  baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+  fetch: withTimeoutFetch(config.timeout),
+  headers: {
+    ...mergeHeaders2(config.headers),
+    ...config.apiKey ? { "X-API-Key": config.apiKey } : {}
+  }
+});
+var setRuntimeConfig = (config) => {
+  return toClientConfig({
+    ...defaultRuntimeConfig,
+    ...config,
+    headers: {
+      ...defaultRuntimeConfig.headers,
+      ...mergeHeaders2(config.headers)
+    }
+  });
+};
+var createClientConfig = (override = {}) => ({
+  ...toClientConfig(defaultRuntimeConfig),
+  ...override,
+  headers: {
+    ...toClientConfig(defaultRuntimeConfig).headers,
+    ...override.headers ?? {}
+  }
+});
+
+// src/core/errors.ts
+class MultisenderError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MultisenderError";
+    Object.setPrototypeOf(this, MultisenderError.prototype);
+  }
+}
+
+class ApiError extends MultisenderError {
+  status;
+  body;
+  constructor(status, body, message) {
+    super(message || `API request failed with status ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+    Object.setPrototypeOf(this, ApiError.prototype);
+  }
+}
+
+class NetworkError extends MultisenderError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, NetworkError.prototype);
+  }
+}
+
+class ValidationError extends MultisenderError {
+  fields;
+  constructor(message, fields) {
+    super(message);
+    this.fields = fields;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+}
+
+class TimeoutError extends MultisenderError {
+  constructor(message = "Request timeout") {
+    super(message);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+
+// src/core/generated-transport.ts
+var isGeneratedHttpError = (error) => typeof error === "object" && error !== null && (("status" in error) || ("body" in error));
+var isGeneratedWrappedResponse = (value) => typeof value === "object" && value !== null && ("data" in value);
+var mapGeneratedError = (error) => {
+  if (error instanceof Error) {
+    if (error.name === "AbortError" || error.name === "TimeoutError") {
+      throw new TimeoutError("Request timeout");
+    }
+    throw new NetworkError(error.message, error);
+  }
+  if (isGeneratedHttpError(error)) {
+    throw new ApiError(error.status ?? 500, error.body ?? error);
+  }
+  if (typeof error === "string") {
+    throw new ApiError(500, { message: error }, error);
+  }
+  throw new ApiError(500, error, "Unexpected API error");
+};
+var executeGenerated = async (operation) => {
+  try {
+    const result = await operation;
+    return isGeneratedWrappedResponse(result) ? result.data : result;
+  } catch (error) {
+    return mapGeneratedError(error);
+  }
+};
+
+// src/core/pagination.ts
+function buildPaginationQuery(params) {
+  if (!params)
+    return {};
+  const query = {};
+  if (params.page !== undefined) {
+    query.page = params.page.toString();
+  }
+  if (params.limit !== undefined) {
+    query.limit = params.limit.toString();
+  }
+  if (params.orderBy) {
+    query.orderBy = params.orderBy;
+  }
+  if (params.orderDir) {
+    query.orderDir = params.orderDir;
+  }
+  if (params.search) {
+    query.search = params.search;
+  }
+  return query;
+}
+
+// src/gen/client.gen.ts
+var client = createClient(createClientConfig(createConfig()));
+
+// src/gen/sdk.gen.ts
+var getProjectInfo = (options) => (options.client ?? client).get({ url: "/api/v1/project", ...options });
+var getProjectMembers = (options) => (options.client ?? client).get({ url: "/api/v1/project/members", ...options });
+var getApiKeys = (options) => (options.client ?? client).get({ url: "/api/v1/project/api-keys", ...options });
+var createApiKey = (options) => (options.client ?? client).post({
+  url: "/api/v1/project/api-keys",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var deleteApiKey = (options) => (options.client ?? client).delete({ url: "/api/v1/project/api-keys/{apiKeyId}", ...options });
+var updateApiKey = (options) => (options.client ?? client).patch({
+  url: "/api/v1/project/api-keys/{apiKeyId}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var findAll = (options) => (options.client ?? client).get({ url: "/api/v1/lists", ...options });
+var create = (options) => (options.client ?? client).post({
+  url: "/api/v1/lists",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var remove = (options) => (options.client ?? client).delete({ url: "/api/v1/lists/{listId}", ...options });
+var findOne = (options) => (options.client ?? client).get({ url: "/api/v1/lists/{listId}", ...options });
+var update = (options) => (options.client ?? client).patch({
+  url: "/api/v1/lists/{listId}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var getRecipients = (options) => (options.client ?? client).get({ url: "/api/v1/lists/{listId}/recipients", ...options });
+var addRecipient = (options) => (options.client ?? client).post({
+  url: "/api/v1/lists/{listId}/recipients",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var addRecipientsBulk = (options) => (options.client ?? client).post({
+  url: "/api/v1/lists/{listId}/recipients/bulk",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var removeRecipient = (options) => (options.client ?? client).delete({ url: "/api/v1/lists/{listId}/recipients/{recipientId}", ...options });
+var importFromFile = (options) => (options.client ?? client).post({ url: "/api/v1/lists/{listId}/import", ...options });
+var createDistributionList = (options) => (options.client ?? client).post({
+  url: "/api/v1/lists/distribution",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var importCsvDistribution = (options) => (options.client ?? client).post({
+  url: "/api/v1/lists/distribution/csv",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var distribute = (options) => (options.client ?? client).post({
+  url: "/api/v1/distribute",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var findAll2 = (options) => (options.client ?? client).get({ url: "/api/v1/distributions", ...options });
+var findOne2 = (options) => (options.client ?? client).get({ url: "/api/v1/distributions/{id}", ...options });
+var getTransactions = (options) => (options.client ?? client).get({ url: "/api/v1/distributions/{id}/transactions", ...options });
+var getStats = (options) => (options.client ?? client).get({ url: "/api/v1/distributions/{id}/stats", ...options });
+var cancel = (options) => (options.client ?? client).post({ url: "/api/v1/distributions/{id}/cancel", ...options });
+var getChains = (options) => (options.client ?? client).get({ url: "/api/v1/catalogs/chains", ...options });
+var getChain = (options) => (options.client ?? client).get({ url: "/api/v1/catalogs/chains/{chainId}", ...options });
+var getTokens = (options) => (options.client ?? client).get({ url: "/api/v1/catalogs/tokens", ...options });
+var searchTokens = (options) => (options.client ?? client).get({ url: "/api/v1/catalogs/tokens/search", ...options });
+var getToken = (options) => (options.client ?? client).get({ url: "/api/v1/catalogs/tokens/{chainId}/{address}", ...options });
+// src/services/response-utils.ts
+function unwrapData(result) {
+  const raw = result;
+  if (raw?.data != null)
+    return raw.data;
+  return result;
+}
+function unwrapDistribution(result) {
+  const raw = result;
+  if (raw?.data?.distribution != null)
+    return raw.data.distribution;
+  if (raw?.distribution != null)
+    return raw.distribution;
+  return result;
+}
+function normalizePaginatedResponse(result, page, limit) {
+  const raw = result;
+  if ("meta" in raw && raw.meta != null && Array.isArray(raw.data)) {
+    return raw;
+  }
+  const inner = raw.data && typeof raw.data === "object" && "data" in raw.data ? raw.data : null;
+  const items = inner && Array.isArray(inner.data) ? inner.data : [];
+  const total = inner && typeof inner.total === "number" ? inner.total : items.length;
+  return {
+    data: items,
+    meta: {
+      page,
+      limit,
+      total,
+      totalPages: Math.ceil(total / limit) || 1
+    }
+  };
+}
+
+// src/services/distributions.ts
+class DistributionsService {
+  headers;
+  client;
+  constructor(headers, client2) {
+    this.headers = headers;
+    this.client = client2;
+  }
+  async distribute(request) {
+    const result = await executeGenerated(distribute({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    return unwrapDistribution(result);
+  }
+  async list(params) {
+    const query = buildPaginationQuery(params);
+    const page = params?.page ?? 1;
+    const limit = params?.limit ?? 20;
+    const result = await executeGenerated(findAll2({
+      client: this.client,
+      headers: this.headers,
+      query,
+      throwOnError: true
+    }));
+    return normalizePaginatedResponse(result, page, limit);
+  }
+  async get(id) {
+    const result = await executeGenerated(findOne2({
+      client: this.client,
+      headers: this.headers,
+      path: { id },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async getTransactions(id, params) {
+    const query = buildPaginationQuery(params);
+    const page = params?.page ?? 1;
+    const limit = params?.limit ?? 20;
+    const result = await executeGenerated(getTransactions({
+      client: this.client,
+      headers: this.headers,
+      path: { id },
+      query,
+      throwOnError: true
+    }));
+    return normalizePaginatedResponse(result, page, limit);
+  }
+  async getStats(id) {
+    const result = await executeGenerated(getStats({
+      client: this.client,
+      headers: this.headers,
+      path: { id },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async cancel(id) {
+    const result = await executeGenerated(cancel({
+      client: this.client,
+      headers: this.headers,
+      path: { id },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+}
+
+// src/services/lists.ts
+class ListsService {
+  headers;
+  client;
+  constructor(headers, client2) {
+    this.headers = headers;
+    this.client = client2;
+  }
+  async list(params) {
+    const query = buildPaginationQuery(params);
+    const page = params?.page ?? 1;
+    const limit = params?.limit ?? 20;
+    const result = await executeGenerated(findAll({
+      client: this.client,
+      headers: this.headers,
+      query,
+      throwOnError: true
+    }));
+    return normalizePaginatedResponse(result, page, limit);
+  }
+  async create(request) {
+    const result = await executeGenerated(create({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async get(listId) {
+    const result = await executeGenerated(findOne({
+      client: this.client,
+      headers: this.headers,
+      path: { listId },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async update(listId, request) {
+    const result = await executeGenerated(update({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      path: { listId },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async delete(listId) {
+    await executeGenerated(remove({
+      client: this.client,
+      headers: this.headers,
+      path: { listId },
+      throwOnError: true
+    }));
+  }
+  async getRecipients(listId, params) {
+    const query = buildPaginationQuery(params);
+    const page = params?.page ?? 1;
+    const limit = params?.limit ?? 20;
+    const result = await executeGenerated(getRecipients({
+      client: this.client,
+      headers: this.headers,
+      path: { listId },
+      query,
+      throwOnError: true
+    }));
+    return normalizePaginatedResponse(result, page, limit);
+  }
+  async addRecipient(listId, request) {
+    const result = await executeGenerated(addRecipient({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      path: { listId },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async addRecipientsBulk(listId, request) {
+    const result = await executeGenerated(addRecipientsBulk({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      path: { listId },
+      throwOnError: true
+    }));
+    return {
+      added: result.added ?? 0,
+      skippedAddresses: result.skippedAddresses ?? [],
+      errors: result.errors ?? []
+    };
+  }
+  async removeRecipient(listId, recipientId) {
+    await executeGenerated(removeRecipient({
+      client: this.client,
+      headers: this.headers,
+      path: { listId, recipientId },
+      throwOnError: true
+    }));
+  }
+  async importFromCsv(listId, file) {
+    if (!file) {
+      throw new Error("importFromCsv: file is required");
+    }
+    const formData = new FormData;
+    if (file instanceof Buffer) {
+      formData.append("file", new Blob([new Uint8Array(file)]), "import.csv");
+    } else {
+      const f = file;
+      formData.append("file", f, f.name);
+    }
+    const result = await executeGenerated(importFromFile({
+      path: { listId },
+      body: formData,
+      bodySerializer: (b) => b,
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async createDistributionList(request) {
+    const result = await executeGenerated(createDistributionList({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    const raw = unwrapData(result);
+    if (raw?.list == null)
+      throw new Error("API response missing list");
+    return raw.list;
+  }
+  async importCsvDistribution(request) {
+    const result = await executeGenerated(importCsvDistribution({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    const raw = unwrapData(result);
+    if (raw?.list == null)
+      throw new Error("API response missing list");
+    return raw.list;
+  }
+}
+
+// src/services/project.ts
+class ProjectService {
+  headers;
+  client;
+  constructor(headers, client2) {
+    this.headers = headers;
+    this.client = client2;
+  }
+  async getInfo() {
+    const result = await executeGenerated(getProjectInfo({
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async getMembers() {
+    const result = await executeGenerated(getProjectMembers({
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    const members = unwrapData(result);
+    return Array.isArray(members) ? members : [members];
+  }
+  async listApiKeys() {
+    const result = await executeGenerated(getApiKeys({
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    const data = unwrapData(result);
+    return Array.isArray(data) ? data : result;
+  }
+  async createApiKey(request) {
+    const result = await executeGenerated(createApiKey({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async updateApiKey(apiKeyId, request) {
+    const result = await executeGenerated(updateApiKey({
+      body: request,
+      client: this.client,
+      headers: this.headers,
+      path: { apiKeyId },
+      throwOnError: true
+    }));
+    return unwrapData(result);
+  }
+  async deleteApiKey(apiKeyId) {
+    await executeGenerated(deleteApiKey({
+      client: this.client,
+      headers: this.headers,
+      path: { apiKeyId },
+      throwOnError: true
+    }));
+  }
+}
+
+// src/utils/validation.ts
+function validateEthereumAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function validatePositiveNumber(value) {
+  const num = typeof value === "string" ? parseFloat(value) : value;
+  return !isNaN(num) && num > 0;
+}
+function validateChainId(chainId) {
+  if (!Number.isInteger(chainId) || chainId <= 0) {
+    throw new ValidationError("Chain ID must be a positive integer");
+  }
+}
+function validateRecipients(recipients) {
+  if (!Array.isArray(recipients) || recipients.length === 0) {
+    throw new ValidationError("Recipients must be a non-empty array");
+  }
+  for (let i = 0;i < recipients.length; i++) {
+    const [address, amount] = recipients[i];
+    if (!address || typeof address !== "string") {
+      throw new ValidationError(`Invalid address at index ${i}`);
+    }
+    if (!validateEthereumAddress(address)) {
+      throw new ValidationError(`Invalid Ethereum address at index ${i}: ${address}`);
+    }
+    if (!validatePositiveNumber(amount)) {
+      throw new ValidationError(`Invalid amount at index ${i}: ${amount}`);
+    }
+  }
+}
+function validateTokenAddress(address) {
+  if (!validateEthereumAddress(address)) {
+    throw new ValidationError(`Invalid token address: ${address}`);
+  }
+}
+function validateApiKey(apiKey) {
+  if (!apiKey || apiKey.trim().length < 10) {
+    throw new ValidationError("Invalid API key format");
+  }
+}
+
+// src/services/catalogs.ts
+class CatalogsService {
+  headers;
+  client;
+  constructor(headers, client2) {
+    this.headers = headers;
+    this.client = client2;
+  }
+  async getChains() {
+    return executeGenerated(getChains({
+      client: this.client,
+      headers: this.headers,
+      throwOnError: true
+    }));
+  }
+  async getChain(chainId) {
+    const parsedChainId = Number(chainId);
+    validateChainId(parsedChainId);
+    return executeGenerated(getChain({
+      client: this.client,
+      headers: this.headers,
+      path: { chainId: parsedChainId },
+      throwOnError: true
+    }));
+  }
+  async getTokens(chainId) {
+    const parsedChainId = chainId !== undefined ? Number(chainId) : undefined;
+    if (parsedChainId !== undefined)
+      validateChainId(parsedChainId);
+    return executeGenerated(getTokens({
+      client: this.client,
+      headers: this.headers,
+      query: parsedChainId !== undefined ? { chainId: parsedChainId } : undefined,
+      throwOnError: true
+    }));
+  }
+  async getToken(chainId, address) {
+    const parsedChainId = Number(chainId);
+    validateChainId(parsedChainId);
+    return executeGenerated(getToken({
+      client: this.client,
+      headers: this.headers,
+      path: { address, chainId: parsedChainId },
+      throwOnError: true
+    }));
+  }
+  async searchTokens(symbol, chainId) {
+    const parsedChainId = Number(chainId);
+    validateChainId(parsedChainId);
+    return executeGenerated(searchTokens({
+      client: this.client,
+      headers: this.headers,
+      query: {
+        chainId: parsedChainId,
+        symbol
+      },
+      throwOnError: true
+    }));
+  }
+}
+
+// src/multisender.ts
+class Multisender {
+  distributions;
+  lists;
+  project;
+  catalogs;
+  client;
+  authHeaders;
+  constructor(config) {
+    validateApiKey(config.apiKey);
+    const resolvedConfig = {
+      baseUrl: config.baseUrl || "https://api.multisender.app",
+      apiKey: config.apiKey,
+      timeout: config.timeout,
+      headers: config.headers
+    };
+    this.client = createClient(setRuntimeConfig(resolvedConfig));
+    this.authHeaders = { "X-API-Key": config.apiKey };
+    this.client.interceptors.error.use((error, response) => {
+      if (!response) {
+        return error;
+      }
+      return {
+        body: error,
+        status: response.status
+      };
+    });
+    this.distributions = new DistributionsService(this.authHeaders, this.client);
+    this.lists = new ListsService(this.authHeaders, this.client);
+    this.project = new ProjectService(this.authHeaders, this.client);
+    this.catalogs = new CatalogsService(this.authHeaders, this.client);
+  }
+  static getVersion() {
+    return "1.0.0";
+  }
+}
+
+// src/utils/csv.ts
+function parseCsv(csvData, options = {}) {
+  const { delimiter: delimiter2 = ",", skipRows = 0, hasHeader = true } = options;
+  const lines = csvData.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length === 0) {
+    throw new ValidationError("CSV data is empty");
+  }
+  let startIndex = skipRows;
+  if (hasHeader) {
+    startIndex += 1;
+  }
+  const recipients = [];
+  for (let i = startIndex;i < lines.length; i++) {
+    const line = lines[i];
+    const parts = line.split(delimiter2).map((p) => p.trim());
+    if (parts.length < 2) {
+      throw new ValidationError(`Invalid CSV format at line ${i + 1}: expected at least 2 columns`);
+    }
+    const [address, amount] = parts;
+    if (!address || !amount) {
+      throw new ValidationError(`Invalid CSV format at line ${i + 1}: address and amount are required`);
+    }
+    recipients.push([address, amount]);
+  }
+  if (recipients.length === 0) {
+    throw new ValidationError("CSV must contain at least one recipient");
+  }
+  return recipients;
+}
+function toCsv(recipients, includeHeader = true) {
+  const lines = [];
+  if (includeHeader) {
+    lines.push("address,amount");
+  }
+  for (const [address, amount] of recipients) {
+    lines.push(`${address},${amount}`);
+  }
+  return lines.join(`
+`);
+}
+function validateCsv(csvData, options = {}) {
+  try {
+    parseCsv(csvData, options);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/commands/distribute.ts
+var {readFileSync} = (() => ({}));
+function createDistributeCommand() {
+  const command = new Command("distribute");
+  command.description("Create and execute a token distribution").requiredOption("-k, --api-key <key>", "API key for authentication").requiredOption("-c, --chain <chainId>", "Blockchain chain ID (1=Ethereum, 137=Polygon, etc.)", parseInt).requiredOption("-t, --token <address>", "Token contract address").requiredOption("-s, --symbol <symbol>", "Token symbol").option("-r, --recipients <file>", "CSV file with recipients (address,amount)").option("-a, --account <address>", "Sender wallet address").option("--base-url <url>", "Custom API base URL").action(async (options) => {
+    try {
+      if (!options.recipients) {
+        console.error("Error: --recipients flag is required");
+        process.exit(1);
+      }
+      const csvContent = readFileSync(options.recipients, "utf-8");
+      const recipients = parseCsv(csvContent, { hasHeader: true });
+      console.log(`\uD83D\uDCCB Loaded ${recipients.length} recipients from ${options.recipients}`);
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      console.log("\uD83D\uDE80 Creating distribution...");
+      const distribution = await sdk.distributions.distribute({
+        chainId: options.chain,
+        tokenAddress: options.token,
+        tokenSymbol: options.symbol,
+        recipients,
+        account: options.account
+      });
+      console.log("✅ Distribution created successfully!");
+      console.log(`   ID: ${distribution.id}`);
+      console.log(`   Name: ${distribution.name}`);
+      console.log(`   Status: ${distribution.status}`);
+      console.log(`   Total Recipients: ${distribution.totalRecipients}`);
+      console.log(`   Total Amount: ${distribution.totalAmount}`);
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/lists.ts
+function createListsCommand() {
+  const command = new Command("lists");
+  command.description("Manage recipient lists");
+  command.command("list").description("List all recipient lists").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").option("-p, --page <number>", "Page number", parseInt, 1).option("-l, --limit <number>", "Items per page", parseInt, 20).action(async (options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const response = await sdk.lists.list({
+        page: options.page,
+        limit: options.limit
+      });
+      console.log(`\uD83D\uDCCB Recipient Lists (Page ${response.meta.page} of ${response.meta.totalPages}):
+`);
+      for (const list of response.data) {
+        console.log(`  • ${list.name} (ID: ${list.id})`);
+        console.log(`    Recipients: ${list.totalItems}`);
+        console.log(`    Created: ${new Date(list.createdAt).toLocaleDateString()}`);
+        if (list.notes) {
+          console.log(`    Notes: ${list.notes}`);
+        }
+        console.log();
+      }
+      console.log(`Total: ${response.meta.total} lists`);
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  command.command("create").description("Create a new recipient list").requiredOption("-k, --api-key <key>", "API key for authentication").requiredOption("-n, --name <name>", "List name").option("--notes <notes>", "Optional notes about the list").option("--base-url <url>", "Custom API base URL").action(async (options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const list = await sdk.lists.create({
+        name: options.name,
+        notes: options.notes
+      });
+      console.log("✅ List created successfully!");
+      console.log(`   ID: ${list.id}`);
+      console.log(`   Name: ${list.name}`);
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  command.command("get <id>").description("Get details of a specific list").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").action(async (id, options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const list = await sdk.lists.get(id);
+      console.log(`\uD83D\uDCCB List Details:
+`);
+      console.log(`  ID: ${list.id}`);
+      console.log(`  Name: ${list.name}`);
+      console.log(`  Recipients: ${list.totalItems}`);
+      console.log(`  Created: ${new Date(list.createdAt).toLocaleDateString()}`);
+      if (list.notes) {
+        console.log(`  Notes: ${list.notes}`);
+      }
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  command.command("delete <id>").description("Delete a recipient list").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").action(async (id, options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      await sdk.lists.delete(id);
+      console.log("✅ List deleted successfully!");
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/distributions.ts
+function createDistributionsCommand() {
+  const command = new Command("distributions");
+  command.description("Manage token distributions");
+  command.command("list").description("List all distributions").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").option("-p, --page <number>", "Page number", parseInt, 1).option("-l, --limit <number>", "Items per page", parseInt, 20).action(async (options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const response = await sdk.distributions.list({
+        page: options.page,
+        limit: options.limit
+      });
+      console.log(`\uD83D\uDE80 Distributions (Page ${response.meta.page} of ${response.meta.totalPages}):
+`);
+      for (const dist of response.data) {
+        console.log(`  • ${dist.name} (ID: ${dist.id})`);
+        console.log(`    Status: ${dist.status}`);
+        console.log(`    Chain: ${dist.chainId} | Token: ${dist.tokenSymbol}`);
+        console.log(`    Recipients: ${dist.totalRecipients} | Amount: ${dist.totalAmount}`);
+        console.log(`    Created: ${new Date(dist.createdAt).toLocaleDateString()}`);
+        console.log();
+      }
+      console.log(`Total: ${response.meta.total} distributions`);
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  command.command("get <id>").description("Get details of a specific distribution").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").action(async (id, options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const dist = await sdk.distributions.get(id);
+      console.log(`\uD83D\uDE80 Distribution Details:
+`);
+      console.log(`  ID: ${dist.id}`);
+      console.log(`  Name: ${dist.name}`);
+      console.log(`  Status: ${dist.status}`);
+      console.log(`  Chain ID: ${dist.chainId}`);
+      console.log(`  Token: ${dist.tokenSymbol} (${dist.tokenAddress})`);
+      console.log(`  Recipients: ${dist.totalRecipients}`);
+      console.log(`  Total Amount: ${dist.totalAmount}`);
+      console.log(`  Created: ${new Date(dist.createdAt).toLocaleDateString()}`);
+      if (dist.notes) {
+        console.log(`  Notes: ${dist.notes}`);
+      }
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  command.command("stats <id>").description("Get statistics for a distribution").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").action(async (id, options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const stats = await sdk.distributions.getStats(id);
+      console.log(`\uD83D\uDCCA Distribution Statistics:
+`);
+      console.log(`  Total: ${stats.total}`);
+      console.log(`  Pending: ${stats.pending}`);
+      console.log(`  Submitted: ${stats.submitted}`);
+      console.log(`  Confirmed: ${stats.confirmed}`);
+      console.log(`  Failed: ${stats.failed}`);
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  command.command("cancel <id>").description("Cancel a distribution").requiredOption("-k, --api-key <key>", "API key for authentication").option("--base-url <url>", "Custom API base URL").action(async (id, options) => {
+    try {
+      const sdk = new Multisender({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      await sdk.distributions.cancel(id);
+      console.log("✅ Distribution cancelled successfully!");
+    } catch (error) {
+      console.error("❌ Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/index.ts
+function main() {
+  const program2 = new Command;
+  program2.name("multisender").description("Multisender SDK CLI - Manage token distributions across EVM chains").version("1.0.0");
+  program2.addCommand(createDistributeCommand());
+  program2.addCommand(createListsCommand());
+  program2.addCommand(createDistributionsCommand());
+  program2.parse(process.argv);
+}
+main();
+
+//# debugId=DAB00AC65560094464756E2164756E21