@chneau/x 0.0.131 → 0.0.132

package/x.js

@@ -1844,6 +1844,185 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS((exports, module) => {
+  function Events() {
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -1862,6 +2041,7 @@ var {
 
 // command.ts
 import { readdir } from "fs/promises";
+import { cpus } from "os";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -2661,6 +2841,385 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
 
+// node_modules/eventemitter3/index.mjs
+var import__2 = __toESM(require_eventemitter3(), 1);
+
+// node_modules/p-timeout/index.js
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+}
+var getDOMException = (errorMessage) => globalThis.DOMException === undefined ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === undefined ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      signal.addEventListener("abort", () => {
+        reject(getAbortedReason(signal));
+      });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError;
+    timer = customTimers.setTimeout.call(undefined, () => {
+      if (fallback) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(undefined, timer);
+    timer = undefined;
+  };
+  return cancelablePromise;
+}
+
+// node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// node_modules/p-queue/dist/priority-queue.js
+class PriorityQueue {
+  #queue = [];
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      run
+    };
+    if (this.size && this.#queue[this.size - 1].priority >= options.priority) {
+      this.#queue.push(element);
+      return;
+    }
+    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    this.#queue.splice(index, 0, element);
+  }
+  dequeue() {
+    const item = this.#queue.shift();
+    return item?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return this.#queue.length;
+  }
+}
+
+// node_modules/p-queue/dist/index.js
+class PQueue extends import__2.default {
+  #carryoverConcurrencyCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #interval;
+  #intervalEnd = 0;
+  #intervalId;
+  #timeoutId;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  #concurrency;
+  #isPaused;
+  #throwOnTimeout;
+  timeout;
+  constructor(options) {
+    super();
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+    }
+    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#queue = new options.queueClass;
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    this.#throwOnTimeout = options.throwOnTimeout === true;
+    this.#isPaused = options.autoStart === false;
+  }
+  get #doesIntervalAllowAnother() {
+    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+    this.#timeoutId = undefined;
+  }
+  get #isIntervalPaused() {
+    const now = Date.now();
+    if (this.#intervalId === undefined) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+      } else {
+        if (this.#timeoutId === undefined) {
+          this.#timeoutId = setTimeout(() => {
+            this.#onResumeInterval();
+          }, delay);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      if (this.#intervalId) {
+        clearInterval(this.#intervalId);
+      }
+      this.#intervalId = undefined;
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (!this.#isPaused) {
+      const canInitializeInterval = !this.#isIntervalPaused;
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!job) {
+          return false;
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = undefined;
+    }
+    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#processQueue();
+  }
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  async#throwOnAbort(signal) {
+    return new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      }, { once: true });
+    });
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: this.#throwOnTimeout,
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#intervalCount++;
+        try {
+          options.signal?.throwIfAborted();
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          this.#next();
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  pause() {
+    this.#isPaused = true;
+  }
+  clear() {
+    this.#queue = new this.#queueClass;
+  }
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  async#onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  get size() {
+    return this.#queue.size;
+  }
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  get pending() {
+    return this.#pending;
+  }
+  get isPaused() {
+    return this.#isPaused;
+  }
+}
+
 // command.ts
 var getDirectories = async (path = ".") => (await readdir(path, { withFileTypes: true })).filter((x) => x.isDirectory()).filter((x) => !x.name.startsWith(".")).filter((x) => !x.name.includes("node_modules")).map((x) => `${path}/${x.name}`);
 var getDirectoriesDeep = async (path = ".", level = 0) => {
@@ -2690,7 +3249,8 @@ var command = async () => {
     process.exit(1);
   }
   const directories = await getDirectoriesDeep(cwd, recursive);
-  await Promise.all(directories.map((x) => purify(x)));
+  const queue = new PQueue({ concurrency: cpus().length });
+  await Promise.all(directories.map((dir) => queue.add(() => purify(dir).catch(console.error)))).catch(console.error);
 };
 var purify = async (dir) => {
   console.log(`\uD83D\uDE80 Managing files in ${dir}`);
@@ -3193,5 +3753,5 @@ program.command("system").description("Update/install the system packages").acti
 program.command("doctor").description("Check the system for issues").action(commandDoctor);
 program.parse();
 
-//# debugId=91DA86CCC903618064756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["node_modules/commander/lib/error.js", "node_modules/commander/lib/argument.js", "node_modules/commander/lib/help.js", "node_modules/commander/lib/option.js", "node_modules/commander/lib/suggestSimilar.js", "node_modules/commander/lib/command.js", "node_modules/commander/index.js", "node_modules/commander/esm.mjs", "command.ts", "node_modules/jsonc-parser/lib/esm/impl/scanner.js", "node_modules/jsonc-parser/lib/esm/impl/string-intern.js", "node_modules/jsonc-parser/lib/esm/impl/parser.js", "node_modules/jsonc-parser/lib/esm/main.js", "commandDoctor.ts", "helpers.ts", "pkgs.ts", "commandFmt.ts", "commandSystem.ts", "commandUpdate.ts", "fetchLatestVersion.ts", "index.ts"],
  "sourcesContent": [
    "/**\n * CommanderError class\n */\nclass CommanderError extends Error {\n  /**\n   * Constructs the CommanderError class\n   * @param {number} exitCode suggested exit code which could be used with process.exit\n   * @param {string} code an id string representing the error\n   * @param {string} message human-readable description of the error\n   */\n  constructor(exitCode, code, message) {\n    super(message);\n    // properly capture stack trace in Node.js\n    Error.captureStackTrace(this, this.constructor);\n    this.name = this.constructor.name;\n    this.code = code;\n    this.exitCode = exitCode;\n    this.nestedError = undefined;\n  }\n}\n\n/**\n * InvalidArgumentError class\n */\nclass InvalidArgumentError extends CommanderError {\n  /**\n   * Constructs the InvalidArgumentError class\n   * @param {string} [message] explanation of why argument is invalid\n   */\n  constructor(message) {\n    super(1, 'commander.invalidArgument', message);\n    // properly capture stack trace in Node.js\n    Error.captureStackTrace(this, this.constructor);\n    this.name = this.constructor.name;\n  }\n}\n\nexports.CommanderError = CommanderError;\nexports.InvalidArgumentError = InvalidArgumentError;\n",
    "const { InvalidArgumentError } = require('./error.js');\n\nclass Argument {\n  /**\n   * Initialize a new command argument with the given name and description.\n   * The default is that the argument is required, and you can explicitly\n   * indicate this with <> around the name. Put [] around the name for an optional argument.\n   *\n   * @param {string} name\n   * @param {string} [description]\n   */\n\n  constructor(name, description) {\n    this.description = description || '';\n    this.variadic = false;\n    this.parseArg = undefined;\n    this.defaultValue = undefined;\n    this.defaultValueDescription = undefined;\n    this.argChoices = undefined;\n\n    switch (name[0]) {\n      case '<': // e.g. <required>\n        this.required = true;\n        this._name = name.slice(1, -1);\n        break;\n      case '[': // e.g. [optional]\n        this.required = false;\n        this._name = name.slice(1, -1);\n        break;\n      default:\n        this.required = true;\n        this._name = name;\n        break;\n    }\n\n    if (this._name.length > 3 && this._name.slice(-3) === '...') {\n      this.variadic = true;\n      this._name = this._name.slice(0, -3);\n    }\n  }\n\n  /**\n   * Return argument name.\n   *\n   * @return {string}\n   */\n\n  name() {\n    return this._name;\n  }\n\n  /**\n   * @package\n   */\n\n  _concatValue(value, previous) {\n    if (previous === this.defaultValue || !Array.isArray(previous)) {\n      return [value];\n    }\n\n    return previous.concat(value);\n  }\n\n  /**\n   * Set the default value, and optionally supply the description to be displayed in the help.\n   *\n   * @param {*} value\n   * @param {string} [description]\n   * @return {Argument}\n   */\n\n  default(value, description) {\n    this.defaultValue = value;\n    this.defaultValueDescription = description;\n    return this;\n  }\n\n  /**\n   * Set the custom handler for processing CLI command arguments into argument values.\n   *\n   * @param {Function} [fn]\n   * @return {Argument}\n   */\n\n  argParser(fn) {\n    this.parseArg = fn;\n    return this;\n  }\n\n  /**\n   * Only allow argument value to be one of choices.\n   *\n   * @param {string[]} values\n   * @return {Argument}\n   */\n\n  choices(values) {\n    this.argChoices = values.slice();\n    this.parseArg = (arg, previous) => {\n      if (!this.argChoices.includes(arg)) {\n        throw new InvalidArgumentError(\n          `Allowed choices are ${this.argChoices.join(', ')}.`,\n        );\n      }\n      if (this.variadic) {\n        return this._concatValue(arg, previous);\n      }\n      return arg;\n    };\n    return this;\n  }\n\n  /**\n   * Make argument required.\n   *\n   * @returns {Argument}\n   */\n  argRequired() {\n    this.required = true;\n    return this;\n  }\n\n  /**\n   * Make argument optional.\n   *\n   * @returns {Argument}\n   */\n  argOptional() {\n    this.required = false;\n    return this;\n  }\n}\n\n/**\n * Takes an argument and returns its human readable equivalent for help usage.\n *\n * @param {Argument} arg\n * @return {string}\n * @private\n */\n\nfunction humanReadableArgName(arg) {\n  const nameOutput = arg.name() + (arg.variadic === true ? '...' : '');\n\n  return arg.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';\n}\n\nexports.Argument = Argument;\nexports.humanReadableArgName = humanReadableArgName;\n",
    "const { humanReadableArgName } = require('./argument.js');\n\n/**\n * TypeScript import types for JSDoc, used by Visual Studio Code IntelliSense and `npm run typescript-checkJS`\n * https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#import-types\n * @typedef { import(\"./argument.js\").Argument } Argument\n * @typedef { import(\"./command.js\").Command } Command\n * @typedef { import(\"./option.js\").Option } Option\n */\n\n// Although this is a class, methods are static in style to allow override using subclass or just functions.\nclass Help {\n  constructor() {\n    this.helpWidth = undefined;\n    this.sortSubcommands = false;\n    this.sortOptions = false;\n    this.showGlobalOptions = false;\n  }\n\n  /**\n   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.\n   *\n   * @param {Command} cmd\n   * @returns {Command[]}\n   */\n\n  visibleCommands(cmd) {\n    const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);\n    const helpCommand = cmd._getHelpCommand();\n    if (helpCommand && !helpCommand._hidden) {\n      visibleCommands.push(helpCommand);\n    }\n    if (this.sortSubcommands) {\n      visibleCommands.sort((a, b) => {\n        // @ts-ignore: because overloaded return type\n        return a.name().localeCompare(b.name());\n      });\n    }\n    return visibleCommands;\n  }\n\n  /**\n   * Compare options for sort.\n   *\n   * @param {Option} a\n   * @param {Option} b\n   * @returns {number}\n   */\n  compareOptions(a, b) {\n    const getSortKey = (option) => {\n      // WYSIWYG for order displayed in help. Short used for comparison if present. No special handling for negated.\n      return option.short\n        ? option.short.replace(/^-/, '')\n        : option.long.replace(/^--/, '');\n    };\n    return getSortKey(a).localeCompare(getSortKey(b));\n  }\n\n  /**\n   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.\n   *\n   * @param {Command} cmd\n   * @returns {Option[]}\n   */\n\n  visibleOptions(cmd) {\n    const visibleOptions = cmd.options.filter((option) => !option.hidden);\n    // Built-in help option.\n    const helpOption = cmd._getHelpOption();\n    if (helpOption && !helpOption.hidden) {\n      // Automatically hide conflicting flags. Bit dubious but a historical behaviour that is convenient for single-command programs.\n      const removeShort = helpOption.short && cmd._findOption(helpOption.short);\n      const removeLong = helpOption.long && cmd._findOption(helpOption.long);\n      if (!removeShort && !removeLong) {\n        visibleOptions.push(helpOption); // no changes needed\n      } else if (helpOption.long && !removeLong) {\n        visibleOptions.push(\n          cmd.createOption(helpOption.long, helpOption.description),\n        );\n      } else if (helpOption.short && !removeShort) {\n        visibleOptions.push(\n          cmd.createOption(helpOption.short, helpOption.description),\n        );\n      }\n    }\n    if (this.sortOptions) {\n      visibleOptions.sort(this.compareOptions);\n    }\n    return visibleOptions;\n  }\n\n  /**\n   * Get an array of the visible global options. (Not including help.)\n   *\n   * @param {Command} cmd\n   * @returns {Option[]}\n   */\n\n  visibleGlobalOptions(cmd) {\n    if (!this.showGlobalOptions) return [];\n\n    const globalOptions = [];\n    for (\n      let ancestorCmd = cmd.parent;\n      ancestorCmd;\n      ancestorCmd = ancestorCmd.parent\n    ) {\n      const visibleOptions = ancestorCmd.options.filter(\n        (option) => !option.hidden,\n      );\n      globalOptions.push(...visibleOptions);\n    }\n    if (this.sortOptions) {\n      globalOptions.sort(this.compareOptions);\n    }\n    return globalOptions;\n  }\n\n  /**\n   * Get an array of the arguments if any have a description.\n   *\n   * @param {Command} cmd\n   * @returns {Argument[]}\n   */\n\n  visibleArguments(cmd) {\n    // Side effect! Apply the legacy descriptions before the arguments are displayed.\n    if (cmd._argsDescription) {\n      cmd.registeredArguments.forEach((argument) => {\n        argument.description =\n          argument.description || cmd._argsDescription[argument.name()] || '';\n      });\n    }\n\n    // If there are any arguments with a description then return all the arguments.\n    if (cmd.registeredArguments.find((argument) => argument.description)) {\n      return cmd.registeredArguments;\n    }\n    return [];\n  }\n\n  /**\n   * Get the command term to show in the list of subcommands.\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  subcommandTerm(cmd) {\n    // Legacy. Ignores custom usage string, and nested commands.\n    const args = cmd.registeredArguments\n      .map((arg) => humanReadableArgName(arg))\n      .join(' ');\n    return (\n      cmd._name +\n      (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +\n      (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option\n      (args ? ' ' + args : '')\n    );\n  }\n\n  /**\n   * Get the option term to show in the list of options.\n   *\n   * @param {Option} option\n   * @returns {string}\n   */\n\n  optionTerm(option) {\n    return option.flags;\n  }\n\n  /**\n   * Get the argument term to show in the list of arguments.\n   *\n   * @param {Argument} argument\n   * @returns {string}\n   */\n\n  argumentTerm(argument) {\n    return argument.name();\n  }\n\n  /**\n   * Get the longest command term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestSubcommandTermLength(cmd, helper) {\n    return helper.visibleCommands(cmd).reduce((max, command) => {\n      return Math.max(max, helper.subcommandTerm(command).length);\n    }, 0);\n  }\n\n  /**\n   * Get the longest option term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestOptionTermLength(cmd, helper) {\n    return helper.visibleOptions(cmd).reduce((max, option) => {\n      return Math.max(max, helper.optionTerm(option).length);\n    }, 0);\n  }\n\n  /**\n   * Get the longest global option term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestGlobalOptionTermLength(cmd, helper) {\n    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {\n      return Math.max(max, helper.optionTerm(option).length);\n    }, 0);\n  }\n\n  /**\n   * Get the longest argument term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestArgumentTermLength(cmd, helper) {\n    return helper.visibleArguments(cmd).reduce((max, argument) => {\n      return Math.max(max, helper.argumentTerm(argument).length);\n    }, 0);\n  }\n\n  /**\n   * Get the command usage to be displayed at the top of the built-in help.\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  commandUsage(cmd) {\n    // Usage\n    let cmdName = cmd._name;\n    if (cmd._aliases[0]) {\n      cmdName = cmdName + '|' + cmd._aliases[0];\n    }\n    let ancestorCmdNames = '';\n    for (\n      let ancestorCmd = cmd.parent;\n      ancestorCmd;\n      ancestorCmd = ancestorCmd.parent\n    ) {\n      ancestorCmdNames = ancestorCmd.name() + ' ' + ancestorCmdNames;\n    }\n    return ancestorCmdNames + cmdName + ' ' + cmd.usage();\n  }\n\n  /**\n   * Get the description for the command.\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  commandDescription(cmd) {\n    // @ts-ignore: because overloaded return type\n    return cmd.description();\n  }\n\n  /**\n   * Get the subcommand summary to show in the list of subcommands.\n   * (Fallback to description for backwards compatibility.)\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  subcommandDescription(cmd) {\n    // @ts-ignore: because overloaded return type\n    return cmd.summary() || cmd.description();\n  }\n\n  /**\n   * Get the option description to show in the list of options.\n   *\n   * @param {Option} option\n   * @return {string}\n   */\n\n  optionDescription(option) {\n    const extraInfo = [];\n\n    if (option.argChoices) {\n      extraInfo.push(\n        // use stringify to match the display of the default value\n        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,\n      );\n    }\n    if (option.defaultValue !== undefined) {\n      // default for boolean and negated more for programmer than end user,\n      // but show true/false for boolean option as may be for hand-rolled env or config processing.\n      const showDefault =\n        option.required ||\n        option.optional ||\n        (option.isBoolean() && typeof option.defaultValue === 'boolean');\n      if (showDefault) {\n        extraInfo.push(\n          `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`,\n        );\n      }\n    }\n    // preset for boolean and negated are more for programmer than end user\n    if (option.presetArg !== undefined && option.optional) {\n      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);\n    }\n    if (option.envVar !== undefined) {\n      extraInfo.push(`env: ${option.envVar}`);\n    }\n    if (extraInfo.length > 0) {\n      return `${option.description} (${extraInfo.join(', ')})`;\n    }\n\n    return option.description;\n  }\n\n  /**\n   * Get the argument description to show in the list of arguments.\n   *\n   * @param {Argument} argument\n   * @return {string}\n   */\n\n  argumentDescription(argument) {\n    const extraInfo = [];\n    if (argument.argChoices) {\n      extraInfo.push(\n        // use stringify to match the display of the default value\n        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,\n      );\n    }\n    if (argument.defaultValue !== undefined) {\n      extraInfo.push(\n        `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`,\n      );\n    }\n    if (extraInfo.length > 0) {\n      const extraDescripton = `(${extraInfo.join(', ')})`;\n      if (argument.description) {\n        return `${argument.description} ${extraDescripton}`;\n      }\n      return extraDescripton;\n    }\n    return argument.description;\n  }\n\n  /**\n   * Generate the built-in help text.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {string}\n   */\n\n  formatHelp(cmd, helper) {\n    const termWidth = helper.padWidth(cmd, helper);\n    const helpWidth = helper.helpWidth || 80;\n    const itemIndentWidth = 2;\n    const itemSeparatorWidth = 2; // between term and description\n    function formatItem(term, description) {\n      if (description) {\n        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;\n        return helper.wrap(\n          fullText,\n          helpWidth - itemIndentWidth,\n          termWidth + itemSeparatorWidth,\n        );\n      }\n      return term;\n    }\n    function formatList(textArray) {\n      return textArray.join('\\n').replace(/^/gm, ' '.repeat(itemIndentWidth));\n    }\n\n    // Usage\n    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];\n\n    // Description\n    const commandDescription = helper.commandDescription(cmd);\n    if (commandDescription.length > 0) {\n      output = output.concat([\n        helper.wrap(commandDescription, helpWidth, 0),\n        '',\n      ]);\n    }\n\n    // Arguments\n    const argumentList = helper.visibleArguments(cmd).map((argument) => {\n      return formatItem(\n        helper.argumentTerm(argument),\n        helper.argumentDescription(argument),\n      );\n    });\n    if (argumentList.length > 0) {\n      output = output.concat(['Arguments:', formatList(argumentList), '']);\n    }\n\n    // Options\n    const optionList = helper.visibleOptions(cmd).map((option) => {\n      return formatItem(\n        helper.optionTerm(option),\n        helper.optionDescription(option),\n      );\n    });\n    if (optionList.length > 0) {\n      output = output.concat(['Options:', formatList(optionList), '']);\n    }\n\n    if (this.showGlobalOptions) {\n      const globalOptionList = helper\n        .visibleGlobalOptions(cmd)\n        .map((option) => {\n          return formatItem(\n            helper.optionTerm(option),\n            helper.optionDescription(option),\n          );\n        });\n      if (globalOptionList.length > 0) {\n        output = output.concat([\n          'Global Options:',\n          formatList(globalOptionList),\n          '',\n        ]);\n      }\n    }\n\n    // Commands\n    const commandList = helper.visibleCommands(cmd).map((cmd) => {\n      return formatItem(\n        helper.subcommandTerm(cmd),\n        helper.subcommandDescription(cmd),\n      );\n    });\n    if (commandList.length > 0) {\n      output = output.concat(['Commands:', formatList(commandList), '']);\n    }\n\n    return output.join('\\n');\n  }\n\n  /**\n   * Calculate the pad width from the maximum term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  padWidth(cmd, helper) {\n    return Math.max(\n      helper.longestOptionTermLength(cmd, helper),\n      helper.longestGlobalOptionTermLength(cmd, helper),\n      helper.longestSubcommandTermLength(cmd, helper),\n      helper.longestArgumentTermLength(cmd, helper),\n    );\n  }\n\n  /**\n   * Wrap the given string to width characters per line, with lines after the first indented.\n   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.\n   *\n   * @param {string} str\n   * @param {number} width\n   * @param {number} indent\n   * @param {number} [minColumnWidth=40]\n   * @return {string}\n   *\n   */\n\n  wrap(str, width, indent, minColumnWidth = 40) {\n    // Full \\s characters, minus the linefeeds.\n    const indents =\n      ' \\\\f\\\\t\\\\v\\u00a0\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff';\n    // Detect manually wrapped and indented strings by searching for line break followed by spaces.\n    const manualIndent = new RegExp(`[\\\\n][${indents}]+`);\n    if (str.match(manualIndent)) return str;\n    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).\n    const columnWidth = width - indent;\n    if (columnWidth < minColumnWidth) return str;\n\n    const leadingStr = str.slice(0, indent);\n    const columnText = str.slice(indent).replace('\\r\\n', '\\n');\n    const indentString = ' '.repeat(indent);\n    const zeroWidthSpace = '\\u200B';\n    const breaks = `\\\\s${zeroWidthSpace}`;\n    // Match line end (so empty lines don't collapse),\n    // or as much text as will fit in column, or excess text up to first break.\n    const regex = new RegExp(\n      `\\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`,\n      'g',\n    );\n    const lines = columnText.match(regex) || [];\n    return (\n      leadingStr +\n      lines\n        .map((line, i) => {\n          if (line === '\\n') return ''; // preserve empty lines\n          return (i > 0 ? indentString : '') + line.trimEnd();\n        })\n        .join('\\n')\n    );\n  }\n}\n\nexports.Help = Help;\n",
    "const { InvalidArgumentError } = require('./error.js');\n\nclass Option {\n  /**\n   * Initialize a new `Option` with the given `flags` and `description`.\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   */\n\n  constructor(flags, description) {\n    this.flags = flags;\n    this.description = description || '';\n\n    this.required = flags.includes('<'); // A value must be supplied when the option is specified.\n    this.optional = flags.includes('['); // A value is optional when the option is specified.\n    // variadic test ignores <value,...> et al which might be used to describe custom splitting of single argument\n    this.variadic = /\\w\\.\\.\\.[>\\]]$/.test(flags); // The option can take multiple values.\n    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.\n    const optionFlags = splitOptionFlags(flags);\n    this.short = optionFlags.shortFlag;\n    this.long = optionFlags.longFlag;\n    this.negate = false;\n    if (this.long) {\n      this.negate = this.long.startsWith('--no-');\n    }\n    this.defaultValue = undefined;\n    this.defaultValueDescription = undefined;\n    this.presetArg = undefined;\n    this.envVar = undefined;\n    this.parseArg = undefined;\n    this.hidden = false;\n    this.argChoices = undefined;\n    this.conflictsWith = [];\n    this.implied = undefined;\n  }\n\n  /**\n   * Set the default value, and optionally supply the description to be displayed in the help.\n   *\n   * @param {*} value\n   * @param {string} [description]\n   * @return {Option}\n   */\n\n  default(value, description) {\n    this.defaultValue = value;\n    this.defaultValueDescription = description;\n    return this;\n  }\n\n  /**\n   * Preset to use when option used without option-argument, especially optional but also boolean and negated.\n   * The custom processing (parseArg) is called.\n   *\n   * @example\n   * new Option('--color').default('GREYSCALE').preset('RGB');\n   * new Option('--donate [amount]').preset('20').argParser(parseFloat);\n   *\n   * @param {*} arg\n   * @return {Option}\n   */\n\n  preset(arg) {\n    this.presetArg = arg;\n    return this;\n  }\n\n  /**\n   * Add option name(s) that conflict with this option.\n   * An error will be displayed if conflicting options are found during parsing.\n   *\n   * @example\n   * new Option('--rgb').conflicts('cmyk');\n   * new Option('--js').conflicts(['ts', 'jsx']);\n   *\n   * @param {(string | string[])} names\n   * @return {Option}\n   */\n\n  conflicts(names) {\n    this.conflictsWith = this.conflictsWith.concat(names);\n    return this;\n  }\n\n  /**\n   * Specify implied option values for when this option is set and the implied options are not.\n   *\n   * The custom processing (parseArg) is not called on the implied values.\n   *\n   * @example\n   * program\n   *   .addOption(new Option('--log', 'write logging information to file'))\n   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));\n   *\n   * @param {object} impliedOptionValues\n   * @return {Option}\n   */\n  implies(impliedOptionValues) {\n    let newImplied = impliedOptionValues;\n    if (typeof impliedOptionValues === 'string') {\n      // string is not documented, but easy mistake and we can do what user probably intended.\n      newImplied = { [impliedOptionValues]: true };\n    }\n    this.implied = Object.assign(this.implied || {}, newImplied);\n    return this;\n  }\n\n  /**\n   * Set environment variable to check for option value.\n   *\n   * An environment variable is only used if when processed the current option value is\n   * undefined, or the source of the current value is 'default' or 'config' or 'env'.\n   *\n   * @param {string} name\n   * @return {Option}\n   */\n\n  env(name) {\n    this.envVar = name;\n    return this;\n  }\n\n  /**\n   * Set the custom handler for processing CLI option arguments into option values.\n   *\n   * @param {Function} [fn]\n   * @return {Option}\n   */\n\n  argParser(fn) {\n    this.parseArg = fn;\n    return this;\n  }\n\n  /**\n   * Whether the option is mandatory and must have a value after parsing.\n   *\n   * @param {boolean} [mandatory=true]\n   * @return {Option}\n   */\n\n  makeOptionMandatory(mandatory = true) {\n    this.mandatory = !!mandatory;\n    return this;\n  }\n\n  /**\n   * Hide option in help.\n   *\n   * @param {boolean} [hide=true]\n   * @return {Option}\n   */\n\n  hideHelp(hide = true) {\n    this.hidden = !!hide;\n    return this;\n  }\n\n  /**\n   * @package\n   */\n\n  _concatValue(value, previous) {\n    if (previous === this.defaultValue || !Array.isArray(previous)) {\n      return [value];\n    }\n\n    return previous.concat(value);\n  }\n\n  /**\n   * Only allow option value to be one of choices.\n   *\n   * @param {string[]} values\n   * @return {Option}\n   */\n\n  choices(values) {\n    this.argChoices = values.slice();\n    this.parseArg = (arg, previous) => {\n      if (!this.argChoices.includes(arg)) {\n        throw new InvalidArgumentError(\n          `Allowed choices are ${this.argChoices.join(', ')}.`,\n        );\n      }\n      if (this.variadic) {\n        return this._concatValue(arg, previous);\n      }\n      return arg;\n    };\n    return this;\n  }\n\n  /**\n   * Return option name.\n   *\n   * @return {string}\n   */\n\n  name() {\n    if (this.long) {\n      return this.long.replace(/^--/, '');\n    }\n    return this.short.replace(/^-/, '');\n  }\n\n  /**\n   * Return option name, in a camelcase format that can be used\n   * as a object attribute key.\n   *\n   * @return {string}\n   */\n\n  attributeName() {\n    return camelcase(this.name().replace(/^no-/, ''));\n  }\n\n  /**\n   * Check if `arg` matches the short or long flag.\n   *\n   * @param {string} arg\n   * @return {boolean}\n   * @package\n   */\n\n  is(arg) {\n    return this.short === arg || this.long === arg;\n  }\n\n  /**\n   * Return whether a boolean option.\n   *\n   * Options are one of boolean, negated, required argument, or optional argument.\n   *\n   * @return {boolean}\n   * @package\n   */\n\n  isBoolean() {\n    return !this.required && !this.optional && !this.negate;\n  }\n}\n\n/**\n * This class is to make it easier to work with dual options, without changing the existing\n * implementation. We support separate dual options for separate positive and negative options,\n * like `--build` and `--no-build`, which share a single option value. This works nicely for some\n * use cases, but is tricky for others where we want separate behaviours despite\n * the single shared option value.\n */\nclass DualOptions {\n  /**\n   * @param {Option[]} options\n   */\n  constructor(options) {\n    this.positiveOptions = new Map();\n    this.negativeOptions = new Map();\n    this.dualOptions = new Set();\n    options.forEach((option) => {\n      if (option.negate) {\n        this.negativeOptions.set(option.attributeName(), option);\n      } else {\n        this.positiveOptions.set(option.attributeName(), option);\n      }\n    });\n    this.negativeOptions.forEach((value, key) => {\n      if (this.positiveOptions.has(key)) {\n        this.dualOptions.add(key);\n      }\n    });\n  }\n\n  /**\n   * Did the value come from the option, and not from possible matching dual option?\n   *\n   * @param {*} value\n   * @param {Option} option\n   * @returns {boolean}\n   */\n  valueFromOption(value, option) {\n    const optionKey = option.attributeName();\n    if (!this.dualOptions.has(optionKey)) return true;\n\n    // Use the value to deduce if (probably) came from the option.\n    const preset = this.negativeOptions.get(optionKey).presetArg;\n    const negativeValue = preset !== undefined ? preset : false;\n    return option.negate === (negativeValue === value);\n  }\n}\n\n/**\n * Convert string from kebab-case to camelCase.\n *\n * @param {string} str\n * @return {string}\n * @private\n */\n\nfunction camelcase(str) {\n  return str.split('-').reduce((str, word) => {\n    return str + word[0].toUpperCase() + word.slice(1);\n  });\n}\n\n/**\n * Split the short and long flag out of something like '-m,--mixed <value>'\n *\n * @private\n */\n\nfunction splitOptionFlags(flags) {\n  let shortFlag;\n  let longFlag;\n  // Use original very loose parsing to maintain backwards compatibility for now,\n  // which allowed for example unintended `-sw, --short-word` [sic].\n  const flagParts = flags.split(/[ |,]+/);\n  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))\n    shortFlag = flagParts.shift();\n  longFlag = flagParts.shift();\n  // Add support for lone short flag without significantly changing parsing!\n  if (!shortFlag && /^-[^-]$/.test(longFlag)) {\n    shortFlag = longFlag;\n    longFlag = undefined;\n  }\n  return { shortFlag, longFlag };\n}\n\nexports.Option = Option;\nexports.DualOptions = DualOptions;\n",
    "const maxDistance = 3;\n\nfunction editDistance(a, b) {\n  // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance\n  // Calculating optimal string alignment distance, no substring is edited more than once.\n  // (Simple implementation.)\n\n  // Quick early exit, return worst case.\n  if (Math.abs(a.length - b.length) > maxDistance)\n    return Math.max(a.length, b.length);\n\n  // distance between prefix substrings of a and b\n  const d = [];\n\n  // pure deletions turn a into empty string\n  for (let i = 0; i <= a.length; i++) {\n    d[i] = [i];\n  }\n  // pure insertions turn empty string into b\n  for (let j = 0; j <= b.length; j++) {\n    d[0][j] = j;\n  }\n\n  // fill matrix\n  for (let j = 1; j <= b.length; j++) {\n    for (let i = 1; i <= a.length; i++) {\n      let cost = 1;\n      if (a[i - 1] === b[j - 1]) {\n        cost = 0;\n      } else {\n        cost = 1;\n      }\n      d[i][j] = Math.min(\n        d[i - 1][j] + 1, // deletion\n        d[i][j - 1] + 1, // insertion\n        d[i - 1][j - 1] + cost, // substitution\n      );\n      // transposition\n      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {\n        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);\n      }\n    }\n  }\n\n  return d[a.length][b.length];\n}\n\n/**\n * Find close matches, restricted to same number of edits.\n *\n * @param {string} word\n * @param {string[]} candidates\n * @returns {string}\n */\n\nfunction suggestSimilar(word, candidates) {\n  if (!candidates || candidates.length === 0) return '';\n  // remove possible duplicates\n  candidates = Array.from(new Set(candidates));\n\n  const searchingOptions = word.startsWith('--');\n  if (searchingOptions) {\n    word = word.slice(2);\n    candidates = candidates.map((candidate) => candidate.slice(2));\n  }\n\n  let similar = [];\n  let bestDistance = maxDistance;\n  const minSimilarity = 0.4;\n  candidates.forEach((candidate) => {\n    if (candidate.length <= 1) return; // no one character guesses\n\n    const distance = editDistance(word, candidate);\n    const length = Math.max(word.length, candidate.length);\n    const similarity = (length - distance) / length;\n    if (similarity > minSimilarity) {\n      if (distance < bestDistance) {\n        // better edit distance, throw away previous worse matches\n        bestDistance = distance;\n        similar = [candidate];\n      } else if (distance === bestDistance) {\n        similar.push(candidate);\n      }\n    }\n  });\n\n  similar.sort((a, b) => a.localeCompare(b));\n  if (searchingOptions) {\n    similar = similar.map((candidate) => `--${candidate}`);\n  }\n\n  if (similar.length > 1) {\n    return `\\n(Did you mean one of ${similar.join(', ')}?)`;\n  }\n  if (similar.length === 1) {\n    return `\\n(Did you mean ${similar[0]}?)`;\n  }\n  return '';\n}\n\nexports.suggestSimilar = suggestSimilar;\n",
    "const EventEmitter = require('node:events').EventEmitter;\nconst childProcess = require('node:child_process');\nconst path = require('node:path');\nconst fs = require('node:fs');\nconst process = require('node:process');\n\nconst { Argument, humanReadableArgName } = require('./argument.js');\nconst { CommanderError } = require('./error.js');\nconst { Help } = require('./help.js');\nconst { Option, DualOptions } = require('./option.js');\nconst { suggestSimilar } = require('./suggestSimilar');\n\nclass Command extends EventEmitter {\n  /**\n   * Initialize a new `Command`.\n   *\n   * @param {string} [name]\n   */\n\n  constructor(name) {\n    super();\n    /** @type {Command[]} */\n    this.commands = [];\n    /** @type {Option[]} */\n    this.options = [];\n    this.parent = null;\n    this._allowUnknownOption = false;\n    this._allowExcessArguments = true;\n    /** @type {Argument[]} */\n    this.registeredArguments = [];\n    this._args = this.registeredArguments; // deprecated old name\n    /** @type {string[]} */\n    this.args = []; // cli args with options removed\n    this.rawArgs = [];\n    this.processedArgs = []; // like .args but after custom processing and collecting variadic\n    this._scriptPath = null;\n    this._name = name || '';\n    this._optionValues = {};\n    this._optionValueSources = {}; // default, env, cli etc\n    this._storeOptionsAsProperties = false;\n    this._actionHandler = null;\n    this._executableHandler = false;\n    this._executableFile = null; // custom name for executable\n    this._executableDir = null; // custom search directory for subcommands\n    this._defaultCommandName = null;\n    this._exitCallback = null;\n    this._aliases = [];\n    this._combineFlagAndOptionalValue = true;\n    this._description = '';\n    this._summary = '';\n    this._argsDescription = undefined; // legacy\n    this._enablePositionalOptions = false;\n    this._passThroughOptions = false;\n    this._lifeCycleHooks = {}; // a hash of arrays\n    /** @type {(boolean | string)} */\n    this._showHelpAfterError = false;\n    this._showSuggestionAfterError = true;\n\n    // see .configureOutput() for docs\n    this._outputConfiguration = {\n      writeOut: (str) => process.stdout.write(str),\n      writeErr: (str) => process.stderr.write(str),\n      getOutHelpWidth: () =>\n        process.stdout.isTTY ? process.stdout.columns : undefined,\n      getErrHelpWidth: () =>\n        process.stderr.isTTY ? process.stderr.columns : undefined,\n      outputError: (str, write) => write(str),\n    };\n\n    this._hidden = false;\n    /** @type {(Option | null | undefined)} */\n    this._helpOption = undefined; // Lazy created on demand. May be null if help option is disabled.\n    this._addImplicitHelpCommand = undefined; // undecided whether true or false yet, not inherited\n    /** @type {Command} */\n    this._helpCommand = undefined; // lazy initialised, inherited\n    this._helpConfiguration = {};\n  }\n\n  /**\n   * Copy settings that are useful to have in common across root command and subcommands.\n   *\n   * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)\n   *\n   * @param {Command} sourceCommand\n   * @return {Command} `this` command for chaining\n   */\n  copyInheritedSettings(sourceCommand) {\n    this._outputConfiguration = sourceCommand._outputConfiguration;\n    this._helpOption = sourceCommand._helpOption;\n    this._helpCommand = sourceCommand._helpCommand;\n    this._helpConfiguration = sourceCommand._helpConfiguration;\n    this._exitCallback = sourceCommand._exitCallback;\n    this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;\n    this._combineFlagAndOptionalValue =\n      sourceCommand._combineFlagAndOptionalValue;\n    this._allowExcessArguments = sourceCommand._allowExcessArguments;\n    this._enablePositionalOptions = sourceCommand._enablePositionalOptions;\n    this._showHelpAfterError = sourceCommand._showHelpAfterError;\n    this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;\n\n    return this;\n  }\n\n  /**\n   * @returns {Command[]}\n   * @private\n   */\n\n  _getCommandAndAncestors() {\n    const result = [];\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    for (let command = this; command; command = command.parent) {\n      result.push(command);\n    }\n    return result;\n  }\n\n  /**\n   * Define a command.\n   *\n   * There are two styles of command: pay attention to where to put the description.\n   *\n   * @example\n   * // Command implemented using action handler (description is supplied separately to `.command`)\n   * program\n   *   .command('clone <source> [destination]')\n   *   .description('clone a repository into a newly created directory')\n   *   .action((source, destination) => {\n   *     console.log('clone command called');\n   *   });\n   *\n   * // Command implemented using separate executable file (description is second parameter to `.command`)\n   * program\n   *   .command('start <service>', 'start named service')\n   *   .command('stop [service]', 'stop named service, or all if no name supplied');\n   *\n   * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`\n   * @param {(object | string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)\n   * @param {object} [execOpts] - configuration options (for executable)\n   * @return {Command} returns new command for action handler, or `this` for executable command\n   */\n\n  command(nameAndArgs, actionOptsOrExecDesc, execOpts) {\n    let desc = actionOptsOrExecDesc;\n    let opts = execOpts;\n    if (typeof desc === 'object' && desc !== null) {\n      opts = desc;\n      desc = null;\n    }\n    opts = opts || {};\n    const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);\n\n    const cmd = this.createCommand(name);\n    if (desc) {\n      cmd.description(desc);\n      cmd._executableHandler = true;\n    }\n    if (opts.isDefault) this._defaultCommandName = cmd._name;\n    cmd._hidden = !!(opts.noHelp || opts.hidden); // noHelp is deprecated old name for hidden\n    cmd._executableFile = opts.executableFile || null; // Custom name for executable file, set missing to null to match constructor\n    if (args) cmd.arguments(args);\n    this._registerCommand(cmd);\n    cmd.parent = this;\n    cmd.copyInheritedSettings(this);\n\n    if (desc) return this;\n    return cmd;\n  }\n\n  /**\n   * Factory routine to create a new unattached command.\n   *\n   * See .command() for creating an attached subcommand, which uses this routine to\n   * create the command. You can override createCommand to customise subcommands.\n   *\n   * @param {string} [name]\n   * @return {Command} new command\n   */\n\n  createCommand(name) {\n    return new Command(name);\n  }\n\n  /**\n   * You can customise the help with a subclass of Help by overriding createHelp,\n   * or by overriding Help properties using configureHelp().\n   *\n   * @return {Help}\n   */\n\n  createHelp() {\n    return Object.assign(new Help(), this.configureHelp());\n  }\n\n  /**\n   * You can customise the help by overriding Help properties using configureHelp(),\n   * or with a subclass of Help by overriding createHelp().\n   *\n   * @param {object} [configuration] - configuration options\n   * @return {(Command | object)} `this` command for chaining, or stored configuration\n   */\n\n  configureHelp(configuration) {\n    if (configuration === undefined) return this._helpConfiguration;\n\n    this._helpConfiguration = configuration;\n    return this;\n  }\n\n  /**\n   * The default output goes to stdout and stderr. You can customise this for special\n   * applications. You can also customise the display of errors by overriding outputError.\n   *\n   * The configuration properties are all functions:\n   *\n   *     // functions to change where being written, stdout and stderr\n   *     writeOut(str)\n   *     writeErr(str)\n   *     // matching functions to specify width for wrapping help\n   *     getOutHelpWidth()\n   *     getErrHelpWidth()\n   *     // functions based on what is being written out\n   *     outputError(str, write) // used for displaying errors, and not used for displaying help\n   *\n   * @param {object} [configuration] - configuration options\n   * @return {(Command | object)} `this` command for chaining, or stored configuration\n   */\n\n  configureOutput(configuration) {\n    if (configuration === undefined) return this._outputConfiguration;\n\n    Object.assign(this._outputConfiguration, configuration);\n    return this;\n  }\n\n  /**\n   * Display the help or a custom message after an error occurs.\n   *\n   * @param {(boolean|string)} [displayHelp]\n   * @return {Command} `this` command for chaining\n   */\n  showHelpAfterError(displayHelp = true) {\n    if (typeof displayHelp !== 'string') displayHelp = !!displayHelp;\n    this._showHelpAfterError = displayHelp;\n    return this;\n  }\n\n  /**\n   * Display suggestion of similar commands for unknown commands, or options for unknown options.\n   *\n   * @param {boolean} [displaySuggestion]\n   * @return {Command} `this` command for chaining\n   */\n  showSuggestionAfterError(displaySuggestion = true) {\n    this._showSuggestionAfterError = !!displaySuggestion;\n    return this;\n  }\n\n  /**\n   * Add a prepared subcommand.\n   *\n   * See .command() for creating an attached subcommand which inherits settings from its parent.\n   *\n   * @param {Command} cmd - new subcommand\n   * @param {object} [opts] - configuration options\n   * @return {Command} `this` command for chaining\n   */\n\n  addCommand(cmd, opts) {\n    if (!cmd._name) {\n      throw new Error(`Command passed to .addCommand() must have a name\n- specify the name in Command constructor or using .name()`);\n    }\n\n    opts = opts || {};\n    if (opts.isDefault) this._defaultCommandName = cmd._name;\n    if (opts.noHelp || opts.hidden) cmd._hidden = true; // modifying passed command due to existing implementation\n\n    this._registerCommand(cmd);\n    cmd.parent = this;\n    cmd._checkForBrokenPassThrough();\n\n    return this;\n  }\n\n  /**\n   * Factory routine to create a new unattached argument.\n   *\n   * See .argument() for creating an attached argument, which uses this routine to\n   * create the argument. You can override createArgument to return a custom argument.\n   *\n   * @param {string} name\n   * @param {string} [description]\n   * @return {Argument} new argument\n   */\n\n  createArgument(name, description) {\n    return new Argument(name, description);\n  }\n\n  /**\n   * Define argument syntax for command.\n   *\n   * The default is that the argument is required, and you can explicitly\n   * indicate this with <> around the name. Put [] around the name for an optional argument.\n   *\n   * @example\n   * program.argument('<input-file>');\n   * program.argument('[output-file]');\n   *\n   * @param {string} name\n   * @param {string} [description]\n   * @param {(Function|*)} [fn] - custom argument processing function\n   * @param {*} [defaultValue]\n   * @return {Command} `this` command for chaining\n   */\n  argument(name, description, fn, defaultValue) {\n    const argument = this.createArgument(name, description);\n    if (typeof fn === 'function') {\n      argument.default(defaultValue).argParser(fn);\n    } else {\n      argument.default(fn);\n    }\n    this.addArgument(argument);\n    return this;\n  }\n\n  /**\n   * Define argument syntax for command, adding multiple at once (without descriptions).\n   *\n   * See also .argument().\n   *\n   * @example\n   * program.arguments('<cmd> [env]');\n   *\n   * @param {string} names\n   * @return {Command} `this` command for chaining\n   */\n\n  arguments(names) {\n    names\n      .trim()\n      .split(/ +/)\n      .forEach((detail) => {\n        this.argument(detail);\n      });\n    return this;\n  }\n\n  /**\n   * Define argument syntax for command, adding a prepared argument.\n   *\n   * @param {Argument} argument\n   * @return {Command} `this` command for chaining\n   */\n  addArgument(argument) {\n    const previousArgument = this.registeredArguments.slice(-1)[0];\n    if (previousArgument && previousArgument.variadic) {\n      throw new Error(\n        `only the last argument can be variadic '${previousArgument.name()}'`,\n      );\n    }\n    if (\n      argument.required &&\n      argument.defaultValue !== undefined &&\n      argument.parseArg === undefined\n    ) {\n      throw new Error(\n        `a default value for a required argument is never used: '${argument.name()}'`,\n      );\n    }\n    this.registeredArguments.push(argument);\n    return this;\n  }\n\n  /**\n   * Customise or override default help command. By default a help command is automatically added if your command has subcommands.\n   *\n   * @example\n   *    program.helpCommand('help [cmd]');\n   *    program.helpCommand('help [cmd]', 'show help');\n   *    program.helpCommand(false); // suppress default help command\n   *    program.helpCommand(true); // add help command even if no subcommands\n   *\n   * @param {string|boolean} enableOrNameAndArgs - enable with custom name and/or arguments, or boolean to override whether added\n   * @param {string} [description] - custom description\n   * @return {Command} `this` command for chaining\n   */\n\n  helpCommand(enableOrNameAndArgs, description) {\n    if (typeof enableOrNameAndArgs === 'boolean') {\n      this._addImplicitHelpCommand = enableOrNameAndArgs;\n      return this;\n    }\n\n    enableOrNameAndArgs = enableOrNameAndArgs ?? 'help [command]';\n    const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);\n    const helpDescription = description ?? 'display help for command';\n\n    const helpCommand = this.createCommand(helpName);\n    helpCommand.helpOption(false);\n    if (helpArgs) helpCommand.arguments(helpArgs);\n    if (helpDescription) helpCommand.description(helpDescription);\n\n    this._addImplicitHelpCommand = true;\n    this._helpCommand = helpCommand;\n\n    return this;\n  }\n\n  /**\n   * Add prepared custom help command.\n   *\n   * @param {(Command|string|boolean)} helpCommand - custom help command, or deprecated enableOrNameAndArgs as for `.helpCommand()`\n   * @param {string} [deprecatedDescription] - deprecated custom description used with custom name only\n   * @return {Command} `this` command for chaining\n   */\n  addHelpCommand(helpCommand, deprecatedDescription) {\n    // If not passed an object, call through to helpCommand for backwards compatibility,\n    // as addHelpCommand was originally used like helpCommand is now.\n    if (typeof helpCommand !== 'object') {\n      this.helpCommand(helpCommand, deprecatedDescription);\n      return this;\n    }\n\n    this._addImplicitHelpCommand = true;\n    this._helpCommand = helpCommand;\n    return this;\n  }\n\n  /**\n   * Lazy create help command.\n   *\n   * @return {(Command|null)}\n   * @package\n   */\n  _getHelpCommand() {\n    const hasImplicitHelpCommand =\n      this._addImplicitHelpCommand ??\n      (this.commands.length &&\n        !this._actionHandler &&\n        !this._findCommand('help'));\n\n    if (hasImplicitHelpCommand) {\n      if (this._helpCommand === undefined) {\n        this.helpCommand(undefined, undefined); // use default name and description\n      }\n      return this._helpCommand;\n    }\n    return null;\n  }\n\n  /**\n   * Add hook for life cycle event.\n   *\n   * @param {string} event\n   * @param {Function} listener\n   * @return {Command} `this` command for chaining\n   */\n\n  hook(event, listener) {\n    const allowedValues = ['preSubcommand', 'preAction', 'postAction'];\n    if (!allowedValues.includes(event)) {\n      throw new Error(`Unexpected value for event passed to hook : '${event}'.\nExpecting one of '${allowedValues.join(\"', '\")}'`);\n    }\n    if (this._lifeCycleHooks[event]) {\n      this._lifeCycleHooks[event].push(listener);\n    } else {\n      this._lifeCycleHooks[event] = [listener];\n    }\n    return this;\n  }\n\n  /**\n   * Register callback to use as replacement for calling process.exit.\n   *\n   * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing\n   * @return {Command} `this` command for chaining\n   */\n\n  exitOverride(fn) {\n    if (fn) {\n      this._exitCallback = fn;\n    } else {\n      this._exitCallback = (err) => {\n        if (err.code !== 'commander.executeSubCommandAsync') {\n          throw err;\n        } else {\n          // Async callback from spawn events, not useful to throw.\n        }\n      };\n    }\n    return this;\n  }\n\n  /**\n   * Call process.exit, and _exitCallback if defined.\n   *\n   * @param {number} exitCode exit code for using with process.exit\n   * @param {string} code an id string representing the error\n   * @param {string} message human-readable description of the error\n   * @return never\n   * @private\n   */\n\n  _exit(exitCode, code, message) {\n    if (this._exitCallback) {\n      this._exitCallback(new CommanderError(exitCode, code, message));\n      // Expecting this line is not reached.\n    }\n    process.exit(exitCode);\n  }\n\n  /**\n   * Register callback `fn` for the command.\n   *\n   * @example\n   * program\n   *   .command('serve')\n   *   .description('start service')\n   *   .action(function() {\n   *      // do work here\n   *   });\n   *\n   * @param {Function} fn\n   * @return {Command} `this` command for chaining\n   */\n\n  action(fn) {\n    const listener = (args) => {\n      // The .action callback takes an extra parameter which is the command or options.\n      const expectedArgsCount = this.registeredArguments.length;\n      const actionArgs = args.slice(0, expectedArgsCount);\n      if (this._storeOptionsAsProperties) {\n        actionArgs[expectedArgsCount] = this; // backwards compatible \"options\"\n      } else {\n        actionArgs[expectedArgsCount] = this.opts();\n      }\n      actionArgs.push(this);\n\n      return fn.apply(this, actionArgs);\n    };\n    this._actionHandler = listener;\n    return this;\n  }\n\n  /**\n   * Factory routine to create a new unattached option.\n   *\n   * See .option() for creating an attached option, which uses this routine to\n   * create the option. You can override createOption to return a custom option.\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   * @return {Option} new option\n   */\n\n  createOption(flags, description) {\n    return new Option(flags, description);\n  }\n\n  /**\n   * Wrap parseArgs to catch 'commander.invalidArgument'.\n   *\n   * @param {(Option | Argument)} target\n   * @param {string} value\n   * @param {*} previous\n   * @param {string} invalidArgumentMessage\n   * @private\n   */\n\n  _callParseArg(target, value, previous, invalidArgumentMessage) {\n    try {\n      return target.parseArg(value, previous);\n    } catch (err) {\n      if (err.code === 'commander.invalidArgument') {\n        const message = `${invalidArgumentMessage} ${err.message}`;\n        this.error(message, { exitCode: err.exitCode, code: err.code });\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Check for option flag conflicts.\n   * Register option if no conflicts found, or throw on conflict.\n   *\n   * @param {Option} option\n   * @private\n   */\n\n  _registerOption(option) {\n    const matchingOption =\n      (option.short && this._findOption(option.short)) ||\n      (option.long && this._findOption(option.long));\n    if (matchingOption) {\n      const matchingFlag =\n        option.long && this._findOption(option.long)\n          ? option.long\n          : option.short;\n      throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'\n-  already used by option '${matchingOption.flags}'`);\n    }\n\n    this.options.push(option);\n  }\n\n  /**\n   * Check for command name and alias conflicts with existing commands.\n   * Register command if no conflicts found, or throw on conflict.\n   *\n   * @param {Command} command\n   * @private\n   */\n\n  _registerCommand(command) {\n    const knownBy = (cmd) => {\n      return [cmd.name()].concat(cmd.aliases());\n    };\n\n    const alreadyUsed = knownBy(command).find((name) =>\n      this._findCommand(name),\n    );\n    if (alreadyUsed) {\n      const existingCmd = knownBy(this._findCommand(alreadyUsed)).join('|');\n      const newCmd = knownBy(command).join('|');\n      throw new Error(\n        `cannot add command '${newCmd}' as already have command '${existingCmd}'`,\n      );\n    }\n\n    this.commands.push(command);\n  }\n\n  /**\n   * Add an option.\n   *\n   * @param {Option} option\n   * @return {Command} `this` command for chaining\n   */\n  addOption(option) {\n    this._registerOption(option);\n\n    const oname = option.name();\n    const name = option.attributeName();\n\n    // store default value\n    if (option.negate) {\n      // --no-foo is special and defaults foo to true, unless a --foo option is already defined\n      const positiveLongFlag = option.long.replace(/^--no-/, '--');\n      if (!this._findOption(positiveLongFlag)) {\n        this.setOptionValueWithSource(\n          name,\n          option.defaultValue === undefined ? true : option.defaultValue,\n          'default',\n        );\n      }\n    } else if (option.defaultValue !== undefined) {\n      this.setOptionValueWithSource(name, option.defaultValue, 'default');\n    }\n\n    // handler for cli and env supplied values\n    const handleOptionValue = (val, invalidValueMessage, valueSource) => {\n      // val is null for optional option used without an optional-argument.\n      // val is undefined for boolean and negated option.\n      if (val == null && option.presetArg !== undefined) {\n        val = option.presetArg;\n      }\n\n      // custom processing\n      const oldValue = this.getOptionValue(name);\n      if (val !== null && option.parseArg) {\n        val = this._callParseArg(option, val, oldValue, invalidValueMessage);\n      } else if (val !== null && option.variadic) {\n        val = option._concatValue(val, oldValue);\n      }\n\n      // Fill-in appropriate missing values. Long winded but easy to follow.\n      if (val == null) {\n        if (option.negate) {\n          val = false;\n        } else if (option.isBoolean() || option.optional) {\n          val = true;\n        } else {\n          val = ''; // not normal, parseArg might have failed or be a mock function for testing\n        }\n      }\n      this.setOptionValueWithSource(name, val, valueSource);\n    };\n\n    this.on('option:' + oname, (val) => {\n      const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;\n      handleOptionValue(val, invalidValueMessage, 'cli');\n    });\n\n    if (option.envVar) {\n      this.on('optionEnv:' + oname, (val) => {\n        const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;\n        handleOptionValue(val, invalidValueMessage, 'env');\n      });\n    }\n\n    return this;\n  }\n\n  /**\n   * Internal implementation shared by .option() and .requiredOption()\n   *\n   * @return {Command} `this` command for chaining\n   * @private\n   */\n  _optionEx(config, flags, description, fn, defaultValue) {\n    if (typeof flags === 'object' && flags instanceof Option) {\n      throw new Error(\n        'To add an Option object use addOption() instead of option() or requiredOption()',\n      );\n    }\n    const option = this.createOption(flags, description);\n    option.makeOptionMandatory(!!config.mandatory);\n    if (typeof fn === 'function') {\n      option.default(defaultValue).argParser(fn);\n    } else if (fn instanceof RegExp) {\n      // deprecated\n      const regex = fn;\n      fn = (val, def) => {\n        const m = regex.exec(val);\n        return m ? m[0] : def;\n      };\n      option.default(defaultValue).argParser(fn);\n    } else {\n      option.default(fn);\n    }\n\n    return this.addOption(option);\n  }\n\n  /**\n   * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.\n   *\n   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required\n   * option-argument is indicated by `<>` and an optional option-argument by `[]`.\n   *\n   * See the README for more details, and see also addOption() and requiredOption().\n   *\n   * @example\n   * program\n   *     .option('-p, --pepper', 'add pepper')\n   *     .option('-p, --pizza-type <TYPE>', 'type of pizza') // required option-argument\n   *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default\n   *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   * @param {(Function|*)} [parseArg] - custom option processing function or default value\n   * @param {*} [defaultValue]\n   * @return {Command} `this` command for chaining\n   */\n\n  option(flags, description, parseArg, defaultValue) {\n    return this._optionEx({}, flags, description, parseArg, defaultValue);\n  }\n\n  /**\n   * Add a required option which must have a value after parsing. This usually means\n   * the option must be specified on the command line. (Otherwise the same as .option().)\n   *\n   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   * @param {(Function|*)} [parseArg] - custom option processing function or default value\n   * @param {*} [defaultValue]\n   * @return {Command} `this` command for chaining\n   */\n\n  requiredOption(flags, description, parseArg, defaultValue) {\n    return this._optionEx(\n      { mandatory: true },\n      flags,\n      description,\n      parseArg,\n      defaultValue,\n    );\n  }\n\n  /**\n   * Alter parsing of short flags with optional values.\n   *\n   * @example\n   * // for `.option('-f,--flag [value]'):\n   * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour\n   * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`\n   *\n   * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag.\n   * @return {Command} `this` command for chaining\n   */\n  combineFlagAndOptionalValue(combine = true) {\n    this._combineFlagAndOptionalValue = !!combine;\n    return this;\n  }\n\n  /**\n   * Allow unknown options on the command line.\n   *\n   * @param {boolean} [allowUnknown] - if `true` or omitted, no error will be thrown for unknown options.\n   * @return {Command} `this` command for chaining\n   */\n  allowUnknownOption(allowUnknown = true) {\n    this._allowUnknownOption = !!allowUnknown;\n    return this;\n  }\n\n  /**\n   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.\n   *\n   * @param {boolean} [allowExcess] - if `true` or omitted, no error will be thrown for excess arguments.\n   * @return {Command} `this` command for chaining\n   */\n  allowExcessArguments(allowExcess = true) {\n    this._allowExcessArguments = !!allowExcess;\n    return this;\n  }\n\n  /**\n   * Enable positional options. Positional means global options are specified before subcommands which lets\n   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.\n   * The default behaviour is non-positional and global options may appear anywhere on the command line.\n   *\n   * @param {boolean} [positional]\n   * @return {Command} `this` command for chaining\n   */\n  enablePositionalOptions(positional = true) {\n    this._enablePositionalOptions = !!positional;\n    return this;\n  }\n\n  /**\n   * Pass through options that come after command-arguments rather than treat them as command-options,\n   * so actual command-options come before command-arguments. Turning this on for a subcommand requires\n   * positional options to have been enabled on the program (parent commands).\n   * The default behaviour is non-positional and options may appear before or after command-arguments.\n   *\n   * @param {boolean} [passThrough] for unknown options.\n   * @return {Command} `this` command for chaining\n   */\n  passThroughOptions(passThrough = true) {\n    this._passThroughOptions = !!passThrough;\n    this._checkForBrokenPassThrough();\n    return this;\n  }\n\n  /**\n   * @private\n   */\n\n  _checkForBrokenPassThrough() {\n    if (\n      this.parent &&\n      this._passThroughOptions &&\n      !this.parent._enablePositionalOptions\n    ) {\n      throw new Error(\n        `passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`,\n      );\n    }\n  }\n\n  /**\n   * Whether to store option values as properties on command object,\n   * or store separately (specify false). In both cases the option values can be accessed using .opts().\n   *\n   * @param {boolean} [storeAsProperties=true]\n   * @return {Command} `this` command for chaining\n   */\n\n  storeOptionsAsProperties(storeAsProperties = true) {\n    if (this.options.length) {\n      throw new Error('call .storeOptionsAsProperties() before adding options');\n    }\n    if (Object.keys(this._optionValues).length) {\n      throw new Error(\n        'call .storeOptionsAsProperties() before setting option values',\n      );\n    }\n    this._storeOptionsAsProperties = !!storeAsProperties;\n    return this;\n  }\n\n  /**\n   * Retrieve option value.\n   *\n   * @param {string} key\n   * @return {object} value\n   */\n\n  getOptionValue(key) {\n    if (this._storeOptionsAsProperties) {\n      return this[key];\n    }\n    return this._optionValues[key];\n  }\n\n  /**\n   * Store option value.\n   *\n   * @param {string} key\n   * @param {object} value\n   * @return {Command} `this` command for chaining\n   */\n\n  setOptionValue(key, value) {\n    return this.setOptionValueWithSource(key, value, undefined);\n  }\n\n  /**\n   * Store option value and where the value came from.\n   *\n   * @param {string} key\n   * @param {object} value\n   * @param {string} source - expected values are default/config/env/cli/implied\n   * @return {Command} `this` command for chaining\n   */\n\n  setOptionValueWithSource(key, value, source) {\n    if (this._storeOptionsAsProperties) {\n      this[key] = value;\n    } else {\n      this._optionValues[key] = value;\n    }\n    this._optionValueSources[key] = source;\n    return this;\n  }\n\n  /**\n   * Get source of option value.\n   * Expected values are default | config | env | cli | implied\n   *\n   * @param {string} key\n   * @return {string}\n   */\n\n  getOptionValueSource(key) {\n    return this._optionValueSources[key];\n  }\n\n  /**\n   * Get source of option value. See also .optsWithGlobals().\n   * Expected values are default | config | env | cli | implied\n   *\n   * @param {string} key\n   * @return {string}\n   */\n\n  getOptionValueSourceWithGlobals(key) {\n    // global overwrites local, like optsWithGlobals\n    let source;\n    this._getCommandAndAncestors().forEach((cmd) => {\n      if (cmd.getOptionValueSource(key) !== undefined) {\n        source = cmd.getOptionValueSource(key);\n      }\n    });\n    return source;\n  }\n\n  /**\n   * Get user arguments from implied or explicit arguments.\n   * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.\n   *\n   * @private\n   */\n\n  _prepareUserArgs(argv, parseOptions) {\n    if (argv !== undefined && !Array.isArray(argv)) {\n      throw new Error('first parameter to parse must be array or undefined');\n    }\n    parseOptions = parseOptions || {};\n\n    // auto-detect argument conventions if nothing supplied\n    if (argv === undefined && parseOptions.from === undefined) {\n      if (process.versions?.electron) {\n        parseOptions.from = 'electron';\n      }\n      // check node specific options for scenarios where user CLI args follow executable without scriptname\n      const execArgv = process.execArgv ?? [];\n      if (\n        execArgv.includes('-e') ||\n        execArgv.includes('--eval') ||\n        execArgv.includes('-p') ||\n        execArgv.includes('--print')\n      ) {\n        parseOptions.from = 'eval'; // internal usage, not documented\n      }\n    }\n\n    // default to using process.argv\n    if (argv === undefined) {\n      argv = process.argv;\n    }\n    this.rawArgs = argv.slice();\n\n    // extract the user args and scriptPath\n    let userArgs;\n    switch (parseOptions.from) {\n      case undefined:\n      case 'node':\n        this._scriptPath = argv[1];\n        userArgs = argv.slice(2);\n        break;\n      case 'electron':\n        // @ts-ignore: because defaultApp is an unknown property\n        if (process.defaultApp) {\n          this._scriptPath = argv[1];\n          userArgs = argv.slice(2);\n        } else {\n          userArgs = argv.slice(1);\n        }\n        break;\n      case 'user':\n        userArgs = argv.slice(0);\n        break;\n      case 'eval':\n        userArgs = argv.slice(1);\n        break;\n      default:\n        throw new Error(\n          `unexpected parse option { from: '${parseOptions.from}' }`,\n        );\n    }\n\n    // Find default name for program from arguments.\n    if (!this._name && this._scriptPath)\n      this.nameFromFilename(this._scriptPath);\n    this._name = this._name || 'program';\n\n    return userArgs;\n  }\n\n  /**\n   * Parse `argv`, setting options and invoking commands when defined.\n   *\n   * Use parseAsync instead of parse if any of your action handlers are async.\n   *\n   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!\n   *\n   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:\n   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that\n   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged\n   * - `'user'`: just user arguments\n   *\n   * @example\n   * program.parse(); // parse process.argv and auto-detect electron and special node flags\n   * program.parse(process.argv); // assume argv[0] is app and argv[1] is script\n   * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]\n   *\n   * @param {string[]} [argv] - optional, defaults to process.argv\n   * @param {object} [parseOptions] - optionally specify style of options with from: node/user/electron\n   * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'\n   * @return {Command} `this` command for chaining\n   */\n\n  parse(argv, parseOptions) {\n    const userArgs = this._prepareUserArgs(argv, parseOptions);\n    this._parseCommand([], userArgs);\n\n    return this;\n  }\n\n  /**\n   * Parse `argv`, setting options and invoking commands when defined.\n   *\n   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!\n   *\n   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:\n   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that\n   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged\n   * - `'user'`: just user arguments\n   *\n   * @example\n   * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags\n   * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script\n   * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]\n   *\n   * @param {string[]} [argv]\n   * @param {object} [parseOptions]\n   * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'\n   * @return {Promise}\n   */\n\n  async parseAsync(argv, parseOptions) {\n    const userArgs = this._prepareUserArgs(argv, parseOptions);\n    await this._parseCommand([], userArgs);\n\n    return this;\n  }\n\n  /**\n   * Execute a sub-command executable.\n   *\n   * @private\n   */\n\n  _executeSubCommand(subcommand, args) {\n    args = args.slice();\n    let launchWithNode = false; // Use node for source targets so do not need to get permissions correct, and on Windows.\n    const sourceExt = ['.js', '.ts', '.tsx', '.mjs', '.cjs'];\n\n    function findFile(baseDir, baseName) {\n      // Look for specified file\n      const localBin = path.resolve(baseDir, baseName);\n      if (fs.existsSync(localBin)) return localBin;\n\n      // Stop looking if candidate already has an expected extension.\n      if (sourceExt.includes(path.extname(baseName))) return undefined;\n\n      // Try all the extensions.\n      const foundExt = sourceExt.find((ext) =>\n        fs.existsSync(`${localBin}${ext}`),\n      );\n      if (foundExt) return `${localBin}${foundExt}`;\n\n      return undefined;\n    }\n\n    // Not checking for help first. Unlikely to have mandatory and executable, and can't robustly test for help flags in external command.\n    this._checkForMissingMandatoryOptions();\n    this._checkForConflictingOptions();\n\n    // executableFile and executableDir might be full path, or just a name\n    let executableFile =\n      subcommand._executableFile || `${this._name}-${subcommand._name}`;\n    let executableDir = this._executableDir || '';\n    if (this._scriptPath) {\n      let resolvedScriptPath; // resolve possible symlink for installed npm binary\n      try {\n        resolvedScriptPath = fs.realpathSync(this._scriptPath);\n      } catch (err) {\n        resolvedScriptPath = this._scriptPath;\n      }\n      executableDir = path.resolve(\n        path.dirname(resolvedScriptPath),\n        executableDir,\n      );\n    }\n\n    // Look for a local file in preference to a command in PATH.\n    if (executableDir) {\n      let localFile = findFile(executableDir, executableFile);\n\n      // Legacy search using prefix of script name instead of command name\n      if (!localFile && !subcommand._executableFile && this._scriptPath) {\n        const legacyName = path.basename(\n          this._scriptPath,\n          path.extname(this._scriptPath),\n        );\n        if (legacyName !== this._name) {\n          localFile = findFile(\n            executableDir,\n            `${legacyName}-${subcommand._name}`,\n          );\n        }\n      }\n      executableFile = localFile || executableFile;\n    }\n\n    launchWithNode = sourceExt.includes(path.extname(executableFile));\n\n    let proc;\n    if (process.platform !== 'win32') {\n      if (launchWithNode) {\n        args.unshift(executableFile);\n        // add executable arguments to spawn\n        args = incrementNodeInspectorPort(process.execArgv).concat(args);\n\n        proc = childProcess.spawn(process.argv[0], args, { stdio: 'inherit' });\n      } else {\n        proc = childProcess.spawn(executableFile, args, { stdio: 'inherit' });\n      }\n    } else {\n      args.unshift(executableFile);\n      // add executable arguments to spawn\n      args = incrementNodeInspectorPort(process.execArgv).concat(args);\n      proc = childProcess.spawn(process.execPath, args, { stdio: 'inherit' });\n    }\n\n    if (!proc.killed) {\n      // testing mainly to avoid leak warnings during unit tests with mocked spawn\n      const signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];\n      signals.forEach((signal) => {\n        process.on(signal, () => {\n          if (proc.killed === false && proc.exitCode === null) {\n            // @ts-ignore because signals not typed to known strings\n            proc.kill(signal);\n          }\n        });\n      });\n    }\n\n    // By default terminate process when spawned process terminates.\n    const exitCallback = this._exitCallback;\n    proc.on('close', (code) => {\n      code = code ?? 1; // code is null if spawned process terminated due to a signal\n      if (!exitCallback) {\n        process.exit(code);\n      } else {\n        exitCallback(\n          new CommanderError(\n            code,\n            'commander.executeSubCommandAsync',\n            '(close)',\n          ),\n        );\n      }\n    });\n    proc.on('error', (err) => {\n      // @ts-ignore: because err.code is an unknown property\n      if (err.code === 'ENOENT') {\n        const executableDirMessage = executableDir\n          ? `searched for local subcommand relative to directory '${executableDir}'`\n          : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';\n        const executableMissing = `'${executableFile}' does not exist\n - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead\n - if the default executable name is not suitable, use the executableFile option to supply a custom name or path\n - ${executableDirMessage}`;\n        throw new Error(executableMissing);\n        // @ts-ignore: because err.code is an unknown property\n      } else if (err.code === 'EACCES') {\n        throw new Error(`'${executableFile}' not executable`);\n      }\n      if (!exitCallback) {\n        process.exit(1);\n      } else {\n        const wrappedError = new CommanderError(\n          1,\n          'commander.executeSubCommandAsync',\n          '(error)',\n        );\n        wrappedError.nestedError = err;\n        exitCallback(wrappedError);\n      }\n    });\n\n    // Store the reference to the child process\n    this.runningCommand = proc;\n  }\n\n  /**\n   * @private\n   */\n\n  _dispatchSubcommand(commandName, operands, unknown) {\n    const subCommand = this._findCommand(commandName);\n    if (!subCommand) this.help({ error: true });\n\n    let promiseChain;\n    promiseChain = this._chainOrCallSubCommandHook(\n      promiseChain,\n      subCommand,\n      'preSubcommand',\n    );\n    promiseChain = this._chainOrCall(promiseChain, () => {\n      if (subCommand._executableHandler) {\n        this._executeSubCommand(subCommand, operands.concat(unknown));\n      } else {\n        return subCommand._parseCommand(operands, unknown);\n      }\n    });\n    return promiseChain;\n  }\n\n  /**\n   * Invoke help directly if possible, or dispatch if necessary.\n   * e.g. help foo\n   *\n   * @private\n   */\n\n  _dispatchHelpCommand(subcommandName) {\n    if (!subcommandName) {\n      this.help();\n    }\n    const subCommand = this._findCommand(subcommandName);\n    if (subCommand && !subCommand._executableHandler) {\n      subCommand.help();\n    }\n\n    // Fallback to parsing the help flag to invoke the help.\n    return this._dispatchSubcommand(\n      subcommandName,\n      [],\n      [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help'],\n    );\n  }\n\n  /**\n   * Check this.args against expected this.registeredArguments.\n   *\n   * @private\n   */\n\n  _checkNumberOfArguments() {\n    // too few\n    this.registeredArguments.forEach((arg, i) => {\n      if (arg.required && this.args[i] == null) {\n        this.missingArgument(arg.name());\n      }\n    });\n    // too many\n    if (\n      this.registeredArguments.length > 0 &&\n      this.registeredArguments[this.registeredArguments.length - 1].variadic\n    ) {\n      return;\n    }\n    if (this.args.length > this.registeredArguments.length) {\n      this._excessArguments(this.args);\n    }\n  }\n\n  /**\n   * Process this.args using this.registeredArguments and save as this.processedArgs!\n   *\n   * @private\n   */\n\n  _processArguments() {\n    const myParseArg = (argument, value, previous) => {\n      // Extra processing for nice error message on parsing failure.\n      let parsedValue = value;\n      if (value !== null && argument.parseArg) {\n        const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;\n        parsedValue = this._callParseArg(\n          argument,\n          value,\n          previous,\n          invalidValueMessage,\n        );\n      }\n      return parsedValue;\n    };\n\n    this._checkNumberOfArguments();\n\n    const processedArgs = [];\n    this.registeredArguments.forEach((declaredArg, index) => {\n      let value = declaredArg.defaultValue;\n      if (declaredArg.variadic) {\n        // Collect together remaining arguments for passing together as an array.\n        if (index < this.args.length) {\n          value = this.args.slice(index);\n          if (declaredArg.parseArg) {\n            value = value.reduce((processed, v) => {\n              return myParseArg(declaredArg, v, processed);\n            }, declaredArg.defaultValue);\n          }\n        } else if (value === undefined) {\n          value = [];\n        }\n      } else if (index < this.args.length) {\n        value = this.args[index];\n        if (declaredArg.parseArg) {\n          value = myParseArg(declaredArg, value, declaredArg.defaultValue);\n        }\n      }\n      processedArgs[index] = value;\n    });\n    this.processedArgs = processedArgs;\n  }\n\n  /**\n   * Once we have a promise we chain, but call synchronously until then.\n   *\n   * @param {(Promise|undefined)} promise\n   * @param {Function} fn\n   * @return {(Promise|undefined)}\n   * @private\n   */\n\n  _chainOrCall(promise, fn) {\n    // thenable\n    if (promise && promise.then && typeof promise.then === 'function') {\n      // already have a promise, chain callback\n      return promise.then(() => fn());\n    }\n    // callback might return a promise\n    return fn();\n  }\n\n  /**\n   *\n   * @param {(Promise|undefined)} promise\n   * @param {string} event\n   * @return {(Promise|undefined)}\n   * @private\n   */\n\n  _chainOrCallHooks(promise, event) {\n    let result = promise;\n    const hooks = [];\n    this._getCommandAndAncestors()\n      .reverse()\n      .filter((cmd) => cmd._lifeCycleHooks[event] !== undefined)\n      .forEach((hookedCommand) => {\n        hookedCommand._lifeCycleHooks[event].forEach((callback) => {\n          hooks.push({ hookedCommand, callback });\n        });\n      });\n    if (event === 'postAction') {\n      hooks.reverse();\n    }\n\n    hooks.forEach((hookDetail) => {\n      result = this._chainOrCall(result, () => {\n        return hookDetail.callback(hookDetail.hookedCommand, this);\n      });\n    });\n    return result;\n  }\n\n  /**\n   *\n   * @param {(Promise|undefined)} promise\n   * @param {Command} subCommand\n   * @param {string} event\n   * @return {(Promise|undefined)}\n   * @private\n   */\n\n  _chainOrCallSubCommandHook(promise, subCommand, event) {\n    let result = promise;\n    if (this._lifeCycleHooks[event] !== undefined) {\n      this._lifeCycleHooks[event].forEach((hook) => {\n        result = this._chainOrCall(result, () => {\n          return hook(this, subCommand);\n        });\n      });\n    }\n    return result;\n  }\n\n  /**\n   * Process arguments in context of this command.\n   * Returns action result, in case it is a promise.\n   *\n   * @private\n   */\n\n  _parseCommand(operands, unknown) {\n    const parsed = this.parseOptions(unknown);\n    this._parseOptionsEnv(); // after cli, so parseArg not called on both cli and env\n    this._parseOptionsImplied();\n    operands = operands.concat(parsed.operands);\n    unknown = parsed.unknown;\n    this.args = operands.concat(unknown);\n\n    if (operands && this._findCommand(operands[0])) {\n      return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);\n    }\n    if (\n      this._getHelpCommand() &&\n      operands[0] === this._getHelpCommand().name()\n    ) {\n      return this._dispatchHelpCommand(operands[1]);\n    }\n    if (this._defaultCommandName) {\n      this._outputHelpIfRequested(unknown); // Run the help for default command from parent rather than passing to default command\n      return this._dispatchSubcommand(\n        this._defaultCommandName,\n        operands,\n        unknown,\n      );\n    }\n    if (\n      this.commands.length &&\n      this.args.length === 0 &&\n      !this._actionHandler &&\n      !this._defaultCommandName\n    ) {\n      // probably missing subcommand and no handler, user needs help (and exit)\n      this.help({ error: true });\n    }\n\n    this._outputHelpIfRequested(parsed.unknown);\n    this._checkForMissingMandatoryOptions();\n    this._checkForConflictingOptions();\n\n    // We do not always call this check to avoid masking a \"better\" error, like unknown command.\n    const checkForUnknownOptions = () => {\n      if (parsed.unknown.length > 0) {\n        this.unknownOption(parsed.unknown[0]);\n      }\n    };\n\n    const commandEvent = `command:${this.name()}`;\n    if (this._actionHandler) {\n      checkForUnknownOptions();\n      this._processArguments();\n\n      let promiseChain;\n      promiseChain = this._chainOrCallHooks(promiseChain, 'preAction');\n      promiseChain = this._chainOrCall(promiseChain, () =>\n        this._actionHandler(this.processedArgs),\n      );\n      if (this.parent) {\n        promiseChain = this._chainOrCall(promiseChain, () => {\n          this.parent.emit(commandEvent, operands, unknown); // legacy\n        });\n      }\n      promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');\n      return promiseChain;\n    }\n    if (this.parent && this.parent.listenerCount(commandEvent)) {\n      checkForUnknownOptions();\n      this._processArguments();\n      this.parent.emit(commandEvent, operands, unknown); // legacy\n    } else if (operands.length) {\n      if (this._findCommand('*')) {\n        // legacy default command\n        return this._dispatchSubcommand('*', operands, unknown);\n      }\n      if (this.listenerCount('command:*')) {\n        // skip option check, emit event for possible misspelling suggestion\n        this.emit('command:*', operands, unknown);\n      } else if (this.commands.length) {\n        this.unknownCommand();\n      } else {\n        checkForUnknownOptions();\n        this._processArguments();\n      }\n    } else if (this.commands.length) {\n      checkForUnknownOptions();\n      // This command has subcommands and nothing hooked up at this level, so display help (and exit).\n      this.help({ error: true });\n    } else {\n      checkForUnknownOptions();\n      this._processArguments();\n      // fall through for caller to handle after calling .parse()\n    }\n  }\n\n  /**\n   * Find matching command.\n   *\n   * @private\n   * @return {Command | undefined}\n   */\n  _findCommand(name) {\n    if (!name) return undefined;\n    return this.commands.find(\n      (cmd) => cmd._name === name || cmd._aliases.includes(name),\n    );\n  }\n\n  /**\n   * Return an option matching `arg` if any.\n   *\n   * @param {string} arg\n   * @return {Option}\n   * @package\n   */\n\n  _findOption(arg) {\n    return this.options.find((option) => option.is(arg));\n  }\n\n  /**\n   * Display an error message if a mandatory option does not have a value.\n   * Called after checking for help flags in leaf subcommand.\n   *\n   * @private\n   */\n\n  _checkForMissingMandatoryOptions() {\n    // Walk up hierarchy so can call in subcommand after checking for displaying help.\n    this._getCommandAndAncestors().forEach((cmd) => {\n      cmd.options.forEach((anOption) => {\n        if (\n          anOption.mandatory &&\n          cmd.getOptionValue(anOption.attributeName()) === undefined\n        ) {\n          cmd.missingMandatoryOptionValue(anOption);\n        }\n      });\n    });\n  }\n\n  /**\n   * Display an error message if conflicting options are used together in this.\n   *\n   * @private\n   */\n  _checkForConflictingLocalOptions() {\n    const definedNonDefaultOptions = this.options.filter((option) => {\n      const optionKey = option.attributeName();\n      if (this.getOptionValue(optionKey) === undefined) {\n        return false;\n      }\n      return this.getOptionValueSource(optionKey) !== 'default';\n    });\n\n    const optionsWithConflicting = definedNonDefaultOptions.filter(\n      (option) => option.conflictsWith.length > 0,\n    );\n\n    optionsWithConflicting.forEach((option) => {\n      const conflictingAndDefined = definedNonDefaultOptions.find((defined) =>\n        option.conflictsWith.includes(defined.attributeName()),\n      );\n      if (conflictingAndDefined) {\n        this._conflictingOption(option, conflictingAndDefined);\n      }\n    });\n  }\n\n  /**\n   * Display an error message if conflicting options are used together.\n   * Called after checking for help flags in leaf subcommand.\n   *\n   * @private\n   */\n  _checkForConflictingOptions() {\n    // Walk up hierarchy so can call in subcommand after checking for displaying help.\n    this._getCommandAndAncestors().forEach((cmd) => {\n      cmd._checkForConflictingLocalOptions();\n    });\n  }\n\n  /**\n   * Parse options from `argv` removing known options,\n   * and return argv split into operands and unknown arguments.\n   *\n   * Examples:\n   *\n   *     argv => operands, unknown\n   *     --known kkk op => [op], []\n   *     op --known kkk => [op], []\n   *     sub --unknown uuu op => [sub], [--unknown uuu op]\n   *     sub -- --unknown uuu op => [sub --unknown uuu op], []\n   *\n   * @param {string[]} argv\n   * @return {{operands: string[], unknown: string[]}}\n   */\n\n  parseOptions(argv) {\n    const operands = []; // operands, not options or values\n    const unknown = []; // first unknown option and remaining unknown args\n    let dest = operands;\n    const args = argv.slice();\n\n    function maybeOption(arg) {\n      return arg.length > 1 && arg[0] === '-';\n    }\n\n    // parse options\n    let activeVariadicOption = null;\n    while (args.length) {\n      const arg = args.shift();\n\n      // literal\n      if (arg === '--') {\n        if (dest === unknown) dest.push(arg);\n        dest.push(...args);\n        break;\n      }\n\n      if (activeVariadicOption && !maybeOption(arg)) {\n        this.emit(`option:${activeVariadicOption.name()}`, arg);\n        continue;\n      }\n      activeVariadicOption = null;\n\n      if (maybeOption(arg)) {\n        const option = this._findOption(arg);\n        // recognised option, call listener to assign value with possible custom processing\n        if (option) {\n          if (option.required) {\n            const value = args.shift();\n            if (value === undefined) this.optionMissingArgument(option);\n            this.emit(`option:${option.name()}`, value);\n          } else if (option.optional) {\n            let value = null;\n            // historical behaviour is optional value is following arg unless an option\n            if (args.length > 0 && !maybeOption(args[0])) {\n              value = args.shift();\n            }\n            this.emit(`option:${option.name()}`, value);\n          } else {\n            // boolean flag\n            this.emit(`option:${option.name()}`);\n          }\n          activeVariadicOption = option.variadic ? option : null;\n          continue;\n        }\n      }\n\n      // Look for combo options following single dash, eat first one if known.\n      if (arg.length > 2 && arg[0] === '-' && arg[1] !== '-') {\n        const option = this._findOption(`-${arg[1]}`);\n        if (option) {\n          if (\n            option.required ||\n            (option.optional && this._combineFlagAndOptionalValue)\n          ) {\n            // option with value following in same argument\n            this.emit(`option:${option.name()}`, arg.slice(2));\n          } else {\n            // boolean option, emit and put back remainder of arg for further processing\n            this.emit(`option:${option.name()}`);\n            args.unshift(`-${arg.slice(2)}`);\n          }\n          continue;\n        }\n      }\n\n      // Look for known long flag with value, like --foo=bar\n      if (/^--[^=]+=/.test(arg)) {\n        const index = arg.indexOf('=');\n        const option = this._findOption(arg.slice(0, index));\n        if (option && (option.required || option.optional)) {\n          this.emit(`option:${option.name()}`, arg.slice(index + 1));\n          continue;\n        }\n      }\n\n      // Not a recognised option by this command.\n      // Might be a command-argument, or subcommand option, or unknown option, or help command or option.\n\n      // An unknown option means further arguments also classified as unknown so can be reprocessed by subcommands.\n      if (maybeOption(arg)) {\n        dest = unknown;\n      }\n\n      // If using positionalOptions, stop processing our options at subcommand.\n      if (\n        (this._enablePositionalOptions || this._passThroughOptions) &&\n        operands.length === 0 &&\n        unknown.length === 0\n      ) {\n        if (this._findCommand(arg)) {\n          operands.push(arg);\n          if (args.length > 0) unknown.push(...args);\n          break;\n        } else if (\n          this._getHelpCommand() &&\n          arg === this._getHelpCommand().name()\n        ) {\n          operands.push(arg);\n          if (args.length > 0) operands.push(...args);\n          break;\n        } else if (this._defaultCommandName) {\n          unknown.push(arg);\n          if (args.length > 0) unknown.push(...args);\n          break;\n        }\n      }\n\n      // If using passThroughOptions, stop processing options at first command-argument.\n      if (this._passThroughOptions) {\n        dest.push(arg);\n        if (args.length > 0) dest.push(...args);\n        break;\n      }\n\n      // add arg\n      dest.push(arg);\n    }\n\n    return { operands, unknown };\n  }\n\n  /**\n   * Return an object containing local option values as key-value pairs.\n   *\n   * @return {object}\n   */\n  opts() {\n    if (this._storeOptionsAsProperties) {\n      // Preserve original behaviour so backwards compatible when still using properties\n      const result = {};\n      const len = this.options.length;\n\n      for (let i = 0; i < len; i++) {\n        const key = this.options[i].attributeName();\n        result[key] =\n          key === this._versionOptionName ? this._version : this[key];\n      }\n      return result;\n    }\n\n    return this._optionValues;\n  }\n\n  /**\n   * Return an object containing merged local and global option values as key-value pairs.\n   *\n   * @return {object}\n   */\n  optsWithGlobals() {\n    // globals overwrite locals\n    return this._getCommandAndAncestors().reduce(\n      (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),\n      {},\n    );\n  }\n\n  /**\n   * Display error message and exit (or call exitOverride).\n   *\n   * @param {string} message\n   * @param {object} [errorOptions]\n   * @param {string} [errorOptions.code] - an id string representing the error\n   * @param {number} [errorOptions.exitCode] - used with process.exit\n   */\n  error(message, errorOptions) {\n    // output handling\n    this._outputConfiguration.outputError(\n      `${message}\\n`,\n      this._outputConfiguration.writeErr,\n    );\n    if (typeof this._showHelpAfterError === 'string') {\n      this._outputConfiguration.writeErr(`${this._showHelpAfterError}\\n`);\n    } else if (this._showHelpAfterError) {\n      this._outputConfiguration.writeErr('\\n');\n      this.outputHelp({ error: true });\n    }\n\n    // exit handling\n    const config = errorOptions || {};\n    const exitCode = config.exitCode || 1;\n    const code = config.code || 'commander.error';\n    this._exit(exitCode, code, message);\n  }\n\n  /**\n   * Apply any option related environment variables, if option does\n   * not have a value from cli or client code.\n   *\n   * @private\n   */\n  _parseOptionsEnv() {\n    this.options.forEach((option) => {\n      if (option.envVar && option.envVar in process.env) {\n        const optionKey = option.attributeName();\n        // Priority check. Do not overwrite cli or options from unknown source (client-code).\n        if (\n          this.getOptionValue(optionKey) === undefined ||\n          ['default', 'config', 'env'].includes(\n            this.getOptionValueSource(optionKey),\n          )\n        ) {\n          if (option.required || option.optional) {\n            // option can take a value\n            // keep very simple, optional always takes value\n            this.emit(`optionEnv:${option.name()}`, process.env[option.envVar]);\n          } else {\n            // boolean\n            // keep very simple, only care that envVar defined and not the value\n            this.emit(`optionEnv:${option.name()}`);\n          }\n        }\n      }\n    });\n  }\n\n  /**\n   * Apply any implied option values, if option is undefined or default value.\n   *\n   * @private\n   */\n  _parseOptionsImplied() {\n    const dualHelper = new DualOptions(this.options);\n    const hasCustomOptionValue = (optionKey) => {\n      return (\n        this.getOptionValue(optionKey) !== undefined &&\n        !['default', 'implied'].includes(this.getOptionValueSource(optionKey))\n      );\n    };\n    this.options\n      .filter(\n        (option) =>\n          option.implied !== undefined &&\n          hasCustomOptionValue(option.attributeName()) &&\n          dualHelper.valueFromOption(\n            this.getOptionValue(option.attributeName()),\n            option,\n          ),\n      )\n      .forEach((option) => {\n        Object.keys(option.implied)\n          .filter((impliedKey) => !hasCustomOptionValue(impliedKey))\n          .forEach((impliedKey) => {\n            this.setOptionValueWithSource(\n              impliedKey,\n              option.implied[impliedKey],\n              'implied',\n            );\n          });\n      });\n  }\n\n  /**\n   * Argument `name` is missing.\n   *\n   * @param {string} name\n   * @private\n   */\n\n  missingArgument(name) {\n    const message = `error: missing required argument '${name}'`;\n    this.error(message, { code: 'commander.missingArgument' });\n  }\n\n  /**\n   * `Option` is missing an argument.\n   *\n   * @param {Option} option\n   * @private\n   */\n\n  optionMissingArgument(option) {\n    const message = `error: option '${option.flags}' argument missing`;\n    this.error(message, { code: 'commander.optionMissingArgument' });\n  }\n\n  /**\n   * `Option` does not have a value, and is a mandatory option.\n   *\n   * @param {Option} option\n   * @private\n   */\n\n  missingMandatoryOptionValue(option) {\n    const message = `error: required option '${option.flags}' not specified`;\n    this.error(message, { code: 'commander.missingMandatoryOptionValue' });\n  }\n\n  /**\n   * `Option` conflicts with another option.\n   *\n   * @param {Option} option\n   * @param {Option} conflictingOption\n   * @private\n   */\n  _conflictingOption(option, conflictingOption) {\n    // The calling code does not know whether a negated option is the source of the\n    // value, so do some work to take an educated guess.\n    const findBestOptionFromValue = (option) => {\n      const optionKey = option.attributeName();\n      const optionValue = this.getOptionValue(optionKey);\n      const negativeOption = this.options.find(\n        (target) => target.negate && optionKey === target.attributeName(),\n      );\n      const positiveOption = this.options.find(\n        (target) => !target.negate && optionKey === target.attributeName(),\n      );\n      if (\n        negativeOption &&\n        ((negativeOption.presetArg === undefined && optionValue === false) ||\n          (negativeOption.presetArg !== undefined &&\n            optionValue === negativeOption.presetArg))\n      ) {\n        return negativeOption;\n      }\n      return positiveOption || option;\n    };\n\n    const getErrorMessage = (option) => {\n      const bestOption = findBestOptionFromValue(option);\n      const optionKey = bestOption.attributeName();\n      const source = this.getOptionValueSource(optionKey);\n      if (source === 'env') {\n        return `environment variable '${bestOption.envVar}'`;\n      }\n      return `option '${bestOption.flags}'`;\n    };\n\n    const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;\n    this.error(message, { code: 'commander.conflictingOption' });\n  }\n\n  /**\n   * Unknown option `flag`.\n   *\n   * @param {string} flag\n   * @private\n   */\n\n  unknownOption(flag) {\n    if (this._allowUnknownOption) return;\n    let suggestion = '';\n\n    if (flag.startsWith('--') && this._showSuggestionAfterError) {\n      // Looping to pick up the global options too\n      let candidateFlags = [];\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      let command = this;\n      do {\n        const moreFlags = command\n          .createHelp()\n          .visibleOptions(command)\n          .filter((option) => option.long)\n          .map((option) => option.long);\n        candidateFlags = candidateFlags.concat(moreFlags);\n        command = command.parent;\n      } while (command && !command._enablePositionalOptions);\n      suggestion = suggestSimilar(flag, candidateFlags);\n    }\n\n    const message = `error: unknown option '${flag}'${suggestion}`;\n    this.error(message, { code: 'commander.unknownOption' });\n  }\n\n  /**\n   * Excess arguments, more than expected.\n   *\n   * @param {string[]} receivedArgs\n   * @private\n   */\n\n  _excessArguments(receivedArgs) {\n    if (this._allowExcessArguments) return;\n\n    const expected = this.registeredArguments.length;\n    const s = expected === 1 ? '' : 's';\n    const forSubcommand = this.parent ? ` for '${this.name()}'` : '';\n    const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;\n    this.error(message, { code: 'commander.excessArguments' });\n  }\n\n  /**\n   * Unknown command.\n   *\n   * @private\n   */\n\n  unknownCommand() {\n    const unknownName = this.args[0];\n    let suggestion = '';\n\n    if (this._showSuggestionAfterError) {\n      const candidateNames = [];\n      this.createHelp()\n        .visibleCommands(this)\n        .forEach((command) => {\n          candidateNames.push(command.name());\n          // just visible alias\n          if (command.alias()) candidateNames.push(command.alias());\n        });\n      suggestion = suggestSimilar(unknownName, candidateNames);\n    }\n\n    const message = `error: unknown command '${unknownName}'${suggestion}`;\n    this.error(message, { code: 'commander.unknownCommand' });\n  }\n\n  /**\n   * Get or set the program version.\n   *\n   * This method auto-registers the \"-V, --version\" option which will print the version number.\n   *\n   * You can optionally supply the flags and description to override the defaults.\n   *\n   * @param {string} [str]\n   * @param {string} [flags]\n   * @param {string} [description]\n   * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments\n   */\n\n  version(str, flags, description) {\n    if (str === undefined) return this._version;\n    this._version = str;\n    flags = flags || '-V, --version';\n    description = description || 'output the version number';\n    const versionOption = this.createOption(flags, description);\n    this._versionOptionName = versionOption.attributeName();\n    this._registerOption(versionOption);\n\n    this.on('option:' + versionOption.name(), () => {\n      this._outputConfiguration.writeOut(`${str}\\n`);\n      this._exit(0, 'commander.version', str);\n    });\n    return this;\n  }\n\n  /**\n   * Set the description.\n   *\n   * @param {string} [str]\n   * @param {object} [argsDescription]\n   * @return {(string|Command)}\n   */\n  description(str, argsDescription) {\n    if (str === undefined && argsDescription === undefined)\n      return this._description;\n    this._description = str;\n    if (argsDescription) {\n      this._argsDescription = argsDescription;\n    }\n    return this;\n  }\n\n  /**\n   * Set the summary. Used when listed as subcommand of parent.\n   *\n   * @param {string} [str]\n   * @return {(string|Command)}\n   */\n  summary(str) {\n    if (str === undefined) return this._summary;\n    this._summary = str;\n    return this;\n  }\n\n  /**\n   * Set an alias for the command.\n   *\n   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.\n   *\n   * @param {string} [alias]\n   * @return {(string|Command)}\n   */\n\n  alias(alias) {\n    if (alias === undefined) return this._aliases[0]; // just return first, for backwards compatibility\n\n    /** @type {Command} */\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let command = this;\n    if (\n      this.commands.length !== 0 &&\n      this.commands[this.commands.length - 1]._executableHandler\n    ) {\n      // assume adding alias for last added executable subcommand, rather than this\n      command = this.commands[this.commands.length - 1];\n    }\n\n    if (alias === command._name)\n      throw new Error(\"Command alias can't be the same as its name\");\n    const matchingCommand = this.parent?._findCommand(alias);\n    if (matchingCommand) {\n      // c.f. _registerCommand\n      const existingCmd = [matchingCommand.name()]\n        .concat(matchingCommand.aliases())\n        .join('|');\n      throw new Error(\n        `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`,\n      );\n    }\n\n    command._aliases.push(alias);\n    return this;\n  }\n\n  /**\n   * Set aliases for the command.\n   *\n   * Only the first alias is shown in the auto-generated help.\n   *\n   * @param {string[]} [aliases]\n   * @return {(string[]|Command)}\n   */\n\n  aliases(aliases) {\n    // Getter for the array of aliases is the main reason for having aliases() in addition to alias().\n    if (aliases === undefined) return this._aliases;\n\n    aliases.forEach((alias) => this.alias(alias));\n    return this;\n  }\n\n  /**\n   * Set / get the command usage `str`.\n   *\n   * @param {string} [str]\n   * @return {(string|Command)}\n   */\n\n  usage(str) {\n    if (str === undefined) {\n      if (this._usage) return this._usage;\n\n      const args = this.registeredArguments.map((arg) => {\n        return humanReadableArgName(arg);\n      });\n      return []\n        .concat(\n          this.options.length || this._helpOption !== null ? '[options]' : [],\n          this.commands.length ? '[command]' : [],\n          this.registeredArguments.length ? args : [],\n        )\n        .join(' ');\n    }\n\n    this._usage = str;\n    return this;\n  }\n\n  /**\n   * Get or set the name of the command.\n   *\n   * @param {string} [str]\n   * @return {(string|Command)}\n   */\n\n  name(str) {\n    if (str === undefined) return this._name;\n    this._name = str;\n    return this;\n  }\n\n  /**\n   * Set the name of the command from script filename, such as process.argv[1],\n   * or require.main.filename, or __filename.\n   *\n   * (Used internally and public although not documented in README.)\n   *\n   * @example\n   * program.nameFromFilename(require.main.filename);\n   *\n   * @param {string} filename\n   * @return {Command}\n   */\n\n  nameFromFilename(filename) {\n    this._name = path.basename(filename, path.extname(filename));\n\n    return this;\n  }\n\n  /**\n   * Get or set the directory for searching for executable subcommands of this command.\n   *\n   * @example\n   * program.executableDir(__dirname);\n   * // or\n   * program.executableDir('subcommands');\n   *\n   * @param {string} [path]\n   * @return {(string|null|Command)}\n   */\n\n  executableDir(path) {\n    if (path === undefined) return this._executableDir;\n    this._executableDir = path;\n    return this;\n  }\n\n  /**\n   * Return program help documentation.\n   *\n   * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout\n   * @return {string}\n   */\n\n  helpInformation(contextOptions) {\n    const helper = this.createHelp();\n    if (helper.helpWidth === undefined) {\n      helper.helpWidth =\n        contextOptions && contextOptions.error\n          ? this._outputConfiguration.getErrHelpWidth()\n          : this._outputConfiguration.getOutHelpWidth();\n    }\n    return helper.formatHelp(this, helper);\n  }\n\n  /**\n   * @private\n   */\n\n  _getHelpContext(contextOptions) {\n    contextOptions = contextOptions || {};\n    const context = { error: !!contextOptions.error };\n    let write;\n    if (context.error) {\n      write = (arg) => this._outputConfiguration.writeErr(arg);\n    } else {\n      write = (arg) => this._outputConfiguration.writeOut(arg);\n    }\n    context.write = contextOptions.write || write;\n    context.command = this;\n    return context;\n  }\n\n  /**\n   * Output help information for this command.\n   *\n   * Outputs built-in help, and custom text added using `.addHelpText()`.\n   *\n   * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout\n   */\n\n  outputHelp(contextOptions) {\n    let deprecatedCallback;\n    if (typeof contextOptions === 'function') {\n      deprecatedCallback = contextOptions;\n      contextOptions = undefined;\n    }\n    const context = this._getHelpContext(contextOptions);\n\n    this._getCommandAndAncestors()\n      .reverse()\n      .forEach((command) => command.emit('beforeAllHelp', context));\n    this.emit('beforeHelp', context);\n\n    let helpInformation = this.helpInformation(context);\n    if (deprecatedCallback) {\n      helpInformation = deprecatedCallback(helpInformation);\n      if (\n        typeof helpInformation !== 'string' &&\n        !Buffer.isBuffer(helpInformation)\n      ) {\n        throw new Error('outputHelp callback must return a string or a Buffer');\n      }\n    }\n    context.write(helpInformation);\n\n    if (this._getHelpOption()?.long) {\n      this.emit(this._getHelpOption().long); // deprecated\n    }\n    this.emit('afterHelp', context);\n    this._getCommandAndAncestors().forEach((command) =>\n      command.emit('afterAllHelp', context),\n    );\n  }\n\n  /**\n   * You can pass in flags and a description to customise the built-in help option.\n   * Pass in false to disable the built-in help option.\n   *\n   * @example\n   * program.helpOption('-?, --help' 'show help'); // customise\n   * program.helpOption(false); // disable\n   *\n   * @param {(string | boolean)} flags\n   * @param {string} [description]\n   * @return {Command} `this` command for chaining\n   */\n\n  helpOption(flags, description) {\n    // Support disabling built-in help option.\n    if (typeof flags === 'boolean') {\n      if (flags) {\n        this._helpOption = this._helpOption ?? undefined; // preserve existing option\n      } else {\n        this._helpOption = null; // disable\n      }\n      return this;\n    }\n\n    // Customise flags and description.\n    flags = flags ?? '-h, --help';\n    description = description ?? 'display help for command';\n    this._helpOption = this.createOption(flags, description);\n\n    return this;\n  }\n\n  /**\n   * Lazy create help option.\n   * Returns null if has been disabled with .helpOption(false).\n   *\n   * @returns {(Option | null)} the help option\n   * @package\n   */\n  _getHelpOption() {\n    // Lazy create help option on demand.\n    if (this._helpOption === undefined) {\n      this.helpOption(undefined, undefined);\n    }\n    return this._helpOption;\n  }\n\n  /**\n   * Supply your own option to use for the built-in help option.\n   * This is an alternative to using helpOption() to customise the flags and description etc.\n   *\n   * @param {Option} option\n   * @return {Command} `this` command for chaining\n   */\n  addHelpOption(option) {\n    this._helpOption = option;\n    return this;\n  }\n\n  /**\n   * Output help information and exit.\n   *\n   * Outputs built-in help, and custom text added using `.addHelpText()`.\n   *\n   * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout\n   */\n\n  help(contextOptions) {\n    this.outputHelp(contextOptions);\n    let exitCode = process.exitCode || 0;\n    if (\n      exitCode === 0 &&\n      contextOptions &&\n      typeof contextOptions !== 'function' &&\n      contextOptions.error\n    ) {\n      exitCode = 1;\n    }\n    // message: do not have all displayed text available so only passing placeholder.\n    this._exit(exitCode, 'commander.help', '(outputHelp)');\n  }\n\n  /**\n   * Add additional text to be displayed with the built-in help.\n   *\n   * Position is 'before' or 'after' to affect just this command,\n   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.\n   *\n   * @param {string} position - before or after built-in help\n   * @param {(string | Function)} text - string to add, or a function returning a string\n   * @return {Command} `this` command for chaining\n   */\n  addHelpText(position, text) {\n    const allowedValues = ['beforeAll', 'before', 'after', 'afterAll'];\n    if (!allowedValues.includes(position)) {\n      throw new Error(`Unexpected value for position to addHelpText.\nExpecting one of '${allowedValues.join(\"', '\")}'`);\n    }\n    const helpEvent = `${position}Help`;\n    this.on(helpEvent, (context) => {\n      let helpStr;\n      if (typeof text === 'function') {\n        helpStr = text({ error: context.error, command: context.command });\n      } else {\n        helpStr = text;\n      }\n      // Ignore falsy value when nothing to output.\n      if (helpStr) {\n        context.write(`${helpStr}\\n`);\n      }\n    });\n    return this;\n  }\n\n  /**\n   * Output help information if help flags specified\n   *\n   * @param {Array} args - array of options to search for help flags\n   * @private\n   */\n\n  _outputHelpIfRequested(args) {\n    const helpOption = this._getHelpOption();\n    const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));\n    if (helpRequested) {\n      this.outputHelp();\n      // (Do not have all displayed text available so only passing placeholder.)\n      this._exit(0, 'commander.helpDisplayed', '(outputHelp)');\n    }\n  }\n}\n\n/**\n * Scan arguments and increment port number for inspect calls (to avoid conflicts when spawning new command).\n *\n * @param {string[]} args - array of arguments from node.execArgv\n * @returns {string[]}\n * @private\n */\n\nfunction incrementNodeInspectorPort(args) {\n  // Testing for these options:\n  //  --inspect[=[host:]port]\n  //  --inspect-brk[=[host:]port]\n  //  --inspect-port=[host:]port\n  return args.map((arg) => {\n    if (!arg.startsWith('--inspect')) {\n      return arg;\n    }\n    let debugOption;\n    let debugHost = '127.0.0.1';\n    let debugPort = '9229';\n    let match;\n    if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {\n      // e.g. --inspect\n      debugOption = match[1];\n    } else if (\n      (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null\n    ) {\n      debugOption = match[1];\n      if (/^\\d+$/.test(match[3])) {\n        // e.g. --inspect=1234\n        debugPort = match[3];\n      } else {\n        // e.g. --inspect=localhost\n        debugHost = match[3];\n      }\n    } else if (\n      (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\\d+)$/)) !== null\n    ) {\n      // e.g. --inspect=localhost:1234\n      debugOption = match[1];\n      debugHost = match[3];\n      debugPort = match[4];\n    }\n\n    if (debugOption && debugPort !== '0') {\n      return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;\n    }\n    return arg;\n  });\n}\n\nexports.Command = Command;\n",
    "const { Argument } = require('./lib/argument.js');\nconst { Command } = require('./lib/command.js');\nconst { CommanderError, InvalidArgumentError } = require('./lib/error.js');\nconst { Help } = require('./lib/help.js');\nconst { Option } = require('./lib/option.js');\n\nexports.program = new Command();\n\nexports.createCommand = (name) => new Command(name);\nexports.createOption = (flags, description) => new Option(flags, description);\nexports.createArgument = (name, description) => new Argument(name, description);\n\n/**\n * Expose classes\n */\n\nexports.Command = Command;\nexports.Option = Option;\nexports.Argument = Argument;\nexports.Help = Help;\n\nexports.CommanderError = CommanderError;\nexports.InvalidArgumentError = InvalidArgumentError;\nexports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated\n",
    "import commander from './index.js';\n\n// wrapper to provide named exports for ESM.\nexport const {\n  program,\n  createCommand,\n  createArgument,\n  createOption,\n  CommanderError,\n  InvalidArgumentError,\n  InvalidOptionArgumentError, // deprecated old name\n  Command,\n  Argument,\n  Option,\n  Help,\n} = commander;\n",
    "import { readdir } from \"node:fs/promises\";\nimport { program } from \"commander\";\nimport { parse } from \"jsonc-parser\";\n\nconst getDirectories = async (path = \".\") =>\n\t(await readdir(path, { withFileTypes: true }))\n\t\t.filter((x) => x.isDirectory())\n\t\t.filter((x) => !x.name.startsWith(\".\"))\n\t\t.filter((x) => !x.name.includes(\"node_modules\"))\n\t\t.map((x) => `${path}/${x.name}`);\n\nconst getDirectoriesDeep = async (path = \".\", level = 0) => {\n\tif (level === 0) return [path];\n\tconst directories = await getDirectories(path);\n\tlet _level = level - 1;\n\twhile (_level > 0) {\n\t\tfor (const directory of directories) {\n\t\t\tconst p = await getDirectories(directory);\n\t\t\tdirectories.push(...p);\n\t\t}\n\t\t_level--;\n\t}\n\tdirectories.push(path);\n\treturn directories;\n};\n\nexport const command = async () => {\n\tlet cwd: string = program.processedArgs[0];\n\tif (typeof cwd !== \"string\") cwd = \".\";\n\tlet recursive: number = program.opts().recursive;\n\tif (typeof recursive !== \"number\") recursive = 0;\n\tif (recursive > 4) {\n\t\tconsole.error(\"👁️ Recursion level is too high\");\n\t\tprocess.exit(1);\n\t}\n\tconst directories = await getDirectoriesDeep(cwd, recursive);\n\tawait Promise.all(directories.map((x) => purify(x)));\n};\n\nconst purify = async (dir: string) => {\n\tconsole.log(`🚀 Managing files in ${dir}`);\n\tawait managePackagelockjson(dir).catch(console.error);\n\tawait manageYarnlock(dir).catch(console.error);\n\tconst packageJsonExists = await managePackagejson(dir).catch(console.error);\n\tconst tsconfigExists = await manageTsconfig(dir).catch(console.error);\n\tawait manageGitignore(dir, packageJsonExists ?? false).catch(console.error);\n\tif (packageJsonExists) {\n\t\tconsole.log(\"🚀 Updating everything!\");\n\t\tawait Bun.$`timeout 20s bun run --cwd=${dir} upgrade`\n\t\t\t.nothrow()\n\t\t\t.catch(console.error);\n\t}\n\tif (tsconfigExists) {\n\t\tconsole.log(\"🚀 Checking and linting!\");\n\t\tawait Promise.all([\n\t\t\tBun.$`timeout 3s bun run --cwd=${dir} check`.nothrow(),\n\t\t\tBun.$`timeout 3s bun run --cwd=${dir} lint`.nothrow(),\n\t\t]).catch(console.error);\n\t}\n\tconsole.log(\"🎉 Done with all files\");\n};\n\nconst manageYarnlock = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/yarn.lock`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tawait Bun.$`rm -f ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst managePackagelockjson = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/package-lock.json`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tawait Bun.$`rm -f ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst manageGitignore = async (\n\tdir: string,\n\tisBunProject: boolean,\n): Promise<boolean> => {\n\tconst filename = `${dir}/.gitignore`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tconst gitignore = await file.text();\n\tconst lines = gitignore\n\t\t.split(\"\\n\")\n\t\t.map((x) => x.trim())\n\t\t.filter(Boolean);\n\tconst isTooLong = lines.length > 10;\n\tif (isTooLong) console.error(`👁️ ${filename} is too long`);\n\tif (isBunProject) {\n\t\tconst hasNodeModules = lines.includes(\"node_modules\");\n\t\tif (!hasNodeModules) {\n\t\t\tlines.push(\"node_modules\");\n\t\t}\n\t}\n\tawait Bun.write(file, lines.join(\"\\n\"));\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst manageTsconfig = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/tsconfig.json`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tconst tsconfig = parse(await file.text());\n\tif (!tsconfig.compilerOptions) return false;\n\tconst expected = {\n\t\tnoUnusedLocals: true,\n\t\tnoUnusedParameters: true,\n\t\tnoUncheckedIndexedAccess: true,\n\t\tnoFallthroughCasesInSwitch: true,\n\t\tnoEmit: true,\n\t\tstrict: true,\n\t\tskipLibCheck: true,\n\t};\n\tfor (const [key, value] of Object.entries(expected)) {\n\t\tif (tsconfig.compilerOptions[key] === value) continue;\n\t\ttsconfig.compilerOptions[key] = value;\n\t}\n\tawait Bun.write(file, JSON.stringify(tsconfig, null, 2));\n\tawait Bun.$`biome check --write --unsafe ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst managePackagejson = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/package.json`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tconst pkgJson = await file.json();\n\tpkgJson.scripts ??= {};\n\tconst hasDependencies = pkgJson.dependencies || pkgJson.devDependencies;\n\tif (!hasDependencies) return false;\n\tconst expected = {\n\t\tupgrade: \"bun update --latest\",\n\t\tcheck:\n\t\t\t\"deno fmt --use-tabs --quiet; oxlint --fix-dangerously --quiet; biome check --write --unsafe .\",\n\t\tlint: \"tsc\",\n\t\tall: \"bun run upgrade; bun run check; bun run lint\",\n\t};\n\tfor (const [key, value] of Object.entries(expected)) {\n\t\tif (\n\t\t\ttypeof pkgJson.scripts[key] === \"string\" &&\n\t\t\tpkgJson.scripts[key].includes(\"bun\") &&\n\t\t\t(pkgJson.scripts[key].includes(\"--filter\") ||\n\t\t\t\tpkgJson.scripts[key].includes(\"--cwd\"))\n\t\t) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (pkgJson.scripts[key] === value) continue;\n\t\tpkgJson.scripts[key] = value;\n\t}\n\tpkgJson.prettier = undefined;\n\tawait Bun.write(file, JSON.stringify(pkgJson, null, 2));\n\tawait Bun.$`biome check --write --unsafe ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n",
    "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport function createScanner(text, ignoreTrivia = false) {\n    const len = text.length;\n    let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;\n    function scanHexDigits(count, exact) {\n        let digits = 0;\n        let value = 0;\n        while (digits < count || !exact) {\n            let ch = text.charCodeAt(pos);\n            if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {\n                value = value * 16 + ch - 48 /* CharacterCodes._0 */;\n            }\n            else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {\n                value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;\n            }\n            else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {\n                value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;\n            }\n            else {\n                break;\n            }\n            pos++;\n            digits++;\n        }\n        if (digits < count) {\n            value = -1;\n        }\n        return value;\n    }\n    function setPosition(newPosition) {\n        pos = newPosition;\n        value = '';\n        tokenOffset = 0;\n        token = 16 /* SyntaxKind.Unknown */;\n        scanError = 0 /* ScanError.None */;\n    }\n    function scanNumber() {\n        let start = pos;\n        if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {\n            pos++;\n        }\n        else {\n            pos++;\n            while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n            }\n        }\n        if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {\n            pos++;\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n            }\n            else {\n                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;\n                return text.substring(start, pos);\n            }\n        }\n        let end = pos;\n        if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {\n            pos++;\n            if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {\n                pos++;\n            }\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n                end = pos;\n            }\n            else {\n                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;\n            }\n        }\n        return text.substring(start, end);\n    }\n    function scanString() {\n        let result = '', start = pos;\n        while (true) {\n            if (pos >= len) {\n                result += text.substring(start, pos);\n                scanError = 2 /* ScanError.UnexpectedEndOfString */;\n                break;\n            }\n            const ch = text.charCodeAt(pos);\n            if (ch === 34 /* CharacterCodes.doubleQuote */) {\n                result += text.substring(start, pos);\n                pos++;\n                break;\n            }\n            if (ch === 92 /* CharacterCodes.backslash */) {\n                result += text.substring(start, pos);\n                pos++;\n                if (pos >= len) {\n                    scanError = 2 /* ScanError.UnexpectedEndOfString */;\n                    break;\n                }\n                const ch2 = text.charCodeAt(pos++);\n                switch (ch2) {\n                    case 34 /* CharacterCodes.doubleQuote */:\n                        result += '\\\"';\n                        break;\n                    case 92 /* CharacterCodes.backslash */:\n                        result += '\\\\';\n                        break;\n                    case 47 /* CharacterCodes.slash */:\n                        result += '/';\n                        break;\n                    case 98 /* CharacterCodes.b */:\n                        result += '\\b';\n                        break;\n                    case 102 /* CharacterCodes.f */:\n                        result += '\\f';\n                        break;\n                    case 110 /* CharacterCodes.n */:\n                        result += '\\n';\n                        break;\n                    case 114 /* CharacterCodes.r */:\n                        result += '\\r';\n                        break;\n                    case 116 /* CharacterCodes.t */:\n                        result += '\\t';\n                        break;\n                    case 117 /* CharacterCodes.u */:\n                        const ch3 = scanHexDigits(4, true);\n                        if (ch3 >= 0) {\n                            result += String.fromCharCode(ch3);\n                        }\n                        else {\n                            scanError = 4 /* ScanError.InvalidUnicode */;\n                        }\n                        break;\n                    default:\n                        scanError = 5 /* ScanError.InvalidEscapeCharacter */;\n                }\n                start = pos;\n                continue;\n            }\n            if (ch >= 0 && ch <= 0x1f) {\n                if (isLineBreak(ch)) {\n                    result += text.substring(start, pos);\n                    scanError = 2 /* ScanError.UnexpectedEndOfString */;\n                    break;\n                }\n                else {\n                    scanError = 6 /* ScanError.InvalidCharacter */;\n                    // mark as error but continue with string\n                }\n            }\n            pos++;\n        }\n        return result;\n    }\n    function scanNext() {\n        value = '';\n        scanError = 0 /* ScanError.None */;\n        tokenOffset = pos;\n        lineStartOffset = lineNumber;\n        prevTokenLineStartOffset = tokenLineStartOffset;\n        if (pos >= len) {\n            // at the end\n            tokenOffset = len;\n            return token = 17 /* SyntaxKind.EOF */;\n        }\n        let code = text.charCodeAt(pos);\n        // trivia: whitespace\n        if (isWhiteSpace(code)) {\n            do {\n                pos++;\n                value += String.fromCharCode(code);\n                code = text.charCodeAt(pos);\n            } while (isWhiteSpace(code));\n            return token = 15 /* SyntaxKind.Trivia */;\n        }\n        // trivia: newlines\n        if (isLineBreak(code)) {\n            pos++;\n            value += String.fromCharCode(code);\n            if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {\n                pos++;\n                value += '\\n';\n            }\n            lineNumber++;\n            tokenLineStartOffset = pos;\n            return token = 14 /* SyntaxKind.LineBreakTrivia */;\n        }\n        switch (code) {\n            // tokens: []{}:,\n            case 123 /* CharacterCodes.openBrace */:\n                pos++;\n                return token = 1 /* SyntaxKind.OpenBraceToken */;\n            case 125 /* CharacterCodes.closeBrace */:\n                pos++;\n                return token = 2 /* SyntaxKind.CloseBraceToken */;\n            case 91 /* CharacterCodes.openBracket */:\n                pos++;\n                return token = 3 /* SyntaxKind.OpenBracketToken */;\n            case 93 /* CharacterCodes.closeBracket */:\n                pos++;\n                return token = 4 /* SyntaxKind.CloseBracketToken */;\n            case 58 /* CharacterCodes.colon */:\n                pos++;\n                return token = 6 /* SyntaxKind.ColonToken */;\n            case 44 /* CharacterCodes.comma */:\n                pos++;\n                return token = 5 /* SyntaxKind.CommaToken */;\n            // strings\n            case 34 /* CharacterCodes.doubleQuote */:\n                pos++;\n                value = scanString();\n                return token = 10 /* SyntaxKind.StringLiteral */;\n            // comments\n            case 47 /* CharacterCodes.slash */:\n                const start = pos - 1;\n                // Single-line comment\n                if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {\n                    pos += 2;\n                    while (pos < len) {\n                        if (isLineBreak(text.charCodeAt(pos))) {\n                            break;\n                        }\n                        pos++;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 12 /* SyntaxKind.LineCommentTrivia */;\n                }\n                // Multi-line comment\n                if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {\n                    pos += 2;\n                    const safeLength = len - 1; // For lookahead.\n                    let commentClosed = false;\n                    while (pos < safeLength) {\n                        const ch = text.charCodeAt(pos);\n                        if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {\n                            pos += 2;\n                            commentClosed = true;\n                            break;\n                        }\n                        pos++;\n                        if (isLineBreak(ch)) {\n                            if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {\n                                pos++;\n                            }\n                            lineNumber++;\n                            tokenLineStartOffset = pos;\n                        }\n                    }\n                    if (!commentClosed) {\n                        pos++;\n                        scanError = 1 /* ScanError.UnexpectedEndOfComment */;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 13 /* SyntaxKind.BlockCommentTrivia */;\n                }\n                // just a single slash\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* SyntaxKind.Unknown */;\n            // numbers\n            case 45 /* CharacterCodes.minus */:\n                value += String.fromCharCode(code);\n                pos++;\n                if (pos === len || !isDigit(text.charCodeAt(pos))) {\n                    return token = 16 /* SyntaxKind.Unknown */;\n                }\n            // found a minus, followed by a number so\n            // we fall through to proceed with scanning\n            // numbers\n            case 48 /* CharacterCodes._0 */:\n            case 49 /* CharacterCodes._1 */:\n            case 50 /* CharacterCodes._2 */:\n            case 51 /* CharacterCodes._3 */:\n            case 52 /* CharacterCodes._4 */:\n            case 53 /* CharacterCodes._5 */:\n            case 54 /* CharacterCodes._6 */:\n            case 55 /* CharacterCodes._7 */:\n            case 56 /* CharacterCodes._8 */:\n            case 57 /* CharacterCodes._9 */:\n                value += scanNumber();\n                return token = 11 /* SyntaxKind.NumericLiteral */;\n            // literals and unknown symbols\n            default:\n                // is a literal? Read the full word.\n                while (pos < len && isUnknownContentCharacter(code)) {\n                    pos++;\n                    code = text.charCodeAt(pos);\n                }\n                if (tokenOffset !== pos) {\n                    value = text.substring(tokenOffset, pos);\n                    // keywords: true, false, null\n                    switch (value) {\n                        case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;\n                        case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;\n                        case 'null': return token = 7 /* SyntaxKind.NullKeyword */;\n                    }\n                    return token = 16 /* SyntaxKind.Unknown */;\n                }\n                // some\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* SyntaxKind.Unknown */;\n        }\n    }\n    function isUnknownContentCharacter(code) {\n        if (isWhiteSpace(code) || isLineBreak(code)) {\n            return false;\n        }\n        switch (code) {\n            case 125 /* CharacterCodes.closeBrace */:\n            case 93 /* CharacterCodes.closeBracket */:\n            case 123 /* CharacterCodes.openBrace */:\n            case 91 /* CharacterCodes.openBracket */:\n            case 34 /* CharacterCodes.doubleQuote */:\n            case 58 /* CharacterCodes.colon */:\n            case 44 /* CharacterCodes.comma */:\n            case 47 /* CharacterCodes.slash */:\n                return false;\n        }\n        return true;\n    }\n    function scanNextNonTrivia() {\n        let result;\n        do {\n            result = scanNext();\n        } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);\n        return result;\n    }\n    return {\n        setPosition: setPosition,\n        getPosition: () => pos,\n        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,\n        getToken: () => token,\n        getTokenValue: () => value,\n        getTokenOffset: () => tokenOffset,\n        getTokenLength: () => pos - tokenOffset,\n        getTokenStartLine: () => lineStartOffset,\n        getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,\n        getTokenError: () => scanError,\n    };\n}\nfunction isWhiteSpace(ch) {\n    return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;\n}\nfunction isLineBreak(ch) {\n    return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;\n}\nfunction isDigit(ch) {\n    return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;\n}\nvar CharacterCodes;\n(function (CharacterCodes) {\n    CharacterCodes[CharacterCodes[\"lineFeed\"] = 10] = \"lineFeed\";\n    CharacterCodes[CharacterCodes[\"carriageReturn\"] = 13] = \"carriageReturn\";\n    CharacterCodes[CharacterCodes[\"space\"] = 32] = \"space\";\n    CharacterCodes[CharacterCodes[\"_0\"] = 48] = \"_0\";\n    CharacterCodes[CharacterCodes[\"_1\"] = 49] = \"_1\";\n    CharacterCodes[CharacterCodes[\"_2\"] = 50] = \"_2\";\n    CharacterCodes[CharacterCodes[\"_3\"] = 51] = \"_3\";\n    CharacterCodes[CharacterCodes[\"_4\"] = 52] = \"_4\";\n    CharacterCodes[CharacterCodes[\"_5\"] = 53] = \"_5\";\n    CharacterCodes[CharacterCodes[\"_6\"] = 54] = \"_6\";\n    CharacterCodes[CharacterCodes[\"_7\"] = 55] = \"_7\";\n    CharacterCodes[CharacterCodes[\"_8\"] = 56] = \"_8\";\n    CharacterCodes[CharacterCodes[\"_9\"] = 57] = \"_9\";\n    CharacterCodes[CharacterCodes[\"a\"] = 97] = \"a\";\n    CharacterCodes[CharacterCodes[\"b\"] = 98] = \"b\";\n    CharacterCodes[CharacterCodes[\"c\"] = 99] = \"c\";\n    CharacterCodes[CharacterCodes[\"d\"] = 100] = \"d\";\n    CharacterCodes[CharacterCodes[\"e\"] = 101] = \"e\";\n    CharacterCodes[CharacterCodes[\"f\"] = 102] = \"f\";\n    CharacterCodes[CharacterCodes[\"g\"] = 103] = \"g\";\n    CharacterCodes[CharacterCodes[\"h\"] = 104] = \"h\";\n    CharacterCodes[CharacterCodes[\"i\"] = 105] = \"i\";\n    CharacterCodes[CharacterCodes[\"j\"] = 106] = \"j\";\n    CharacterCodes[CharacterCodes[\"k\"] = 107] = \"k\";\n    CharacterCodes[CharacterCodes[\"l\"] = 108] = \"l\";\n    CharacterCodes[CharacterCodes[\"m\"] = 109] = \"m\";\n    CharacterCodes[CharacterCodes[\"n\"] = 110] = \"n\";\n    CharacterCodes[CharacterCodes[\"o\"] = 111] = \"o\";\n    CharacterCodes[CharacterCodes[\"p\"] = 112] = \"p\";\n    CharacterCodes[CharacterCodes[\"q\"] = 113] = \"q\";\n    CharacterCodes[CharacterCodes[\"r\"] = 114] = \"r\";\n    CharacterCodes[CharacterCodes[\"s\"] = 115] = \"s\";\n    CharacterCodes[CharacterCodes[\"t\"] = 116] = \"t\";\n    CharacterCodes[CharacterCodes[\"u\"] = 117] = \"u\";\n    CharacterCodes[CharacterCodes[\"v\"] = 118] = \"v\";\n    CharacterCodes[CharacterCodes[\"w\"] = 119] = \"w\";\n    CharacterCodes[CharacterCodes[\"x\"] = 120] = \"x\";\n    CharacterCodes[CharacterCodes[\"y\"] = 121] = \"y\";\n    CharacterCodes[CharacterCodes[\"z\"] = 122] = \"z\";\n    CharacterCodes[CharacterCodes[\"A\"] = 65] = \"A\";\n    CharacterCodes[CharacterCodes[\"B\"] = 66] = \"B\";\n    CharacterCodes[CharacterCodes[\"C\"] = 67] = \"C\";\n    CharacterCodes[CharacterCodes[\"D\"] = 68] = \"D\";\n    CharacterCodes[CharacterCodes[\"E\"] = 69] = \"E\";\n    CharacterCodes[CharacterCodes[\"F\"] = 70] = \"F\";\n    CharacterCodes[CharacterCodes[\"G\"] = 71] = \"G\";\n    CharacterCodes[CharacterCodes[\"H\"] = 72] = \"H\";\n    CharacterCodes[CharacterCodes[\"I\"] = 73] = \"I\";\n    CharacterCodes[CharacterCodes[\"J\"] = 74] = \"J\";\n    CharacterCodes[CharacterCodes[\"K\"] = 75] = \"K\";\n    CharacterCodes[CharacterCodes[\"L\"] = 76] = \"L\";\n    CharacterCodes[CharacterCodes[\"M\"] = 77] = \"M\";\n    CharacterCodes[CharacterCodes[\"N\"] = 78] = \"N\";\n    CharacterCodes[CharacterCodes[\"O\"] = 79] = \"O\";\n    CharacterCodes[CharacterCodes[\"P\"] = 80] = \"P\";\n    CharacterCodes[CharacterCodes[\"Q\"] = 81] = \"Q\";\n    CharacterCodes[CharacterCodes[\"R\"] = 82] = \"R\";\n    CharacterCodes[CharacterCodes[\"S\"] = 83] = \"S\";\n    CharacterCodes[CharacterCodes[\"T\"] = 84] = \"T\";\n    CharacterCodes[CharacterCodes[\"U\"] = 85] = \"U\";\n    CharacterCodes[CharacterCodes[\"V\"] = 86] = \"V\";\n    CharacterCodes[CharacterCodes[\"W\"] = 87] = \"W\";\n    CharacterCodes[CharacterCodes[\"X\"] = 88] = \"X\";\n    CharacterCodes[CharacterCodes[\"Y\"] = 89] = \"Y\";\n    CharacterCodes[CharacterCodes[\"Z\"] = 90] = \"Z\";\n    CharacterCodes[CharacterCodes[\"asterisk\"] = 42] = \"asterisk\";\n    CharacterCodes[CharacterCodes[\"backslash\"] = 92] = \"backslash\";\n    CharacterCodes[CharacterCodes[\"closeBrace\"] = 125] = \"closeBrace\";\n    CharacterCodes[CharacterCodes[\"closeBracket\"] = 93] = \"closeBracket\";\n    CharacterCodes[CharacterCodes[\"colon\"] = 58] = \"colon\";\n    CharacterCodes[CharacterCodes[\"comma\"] = 44] = \"comma\";\n    CharacterCodes[CharacterCodes[\"dot\"] = 46] = \"dot\";\n    CharacterCodes[CharacterCodes[\"doubleQuote\"] = 34] = \"doubleQuote\";\n    CharacterCodes[CharacterCodes[\"minus\"] = 45] = \"minus\";\n    CharacterCodes[CharacterCodes[\"openBrace\"] = 123] = \"openBrace\";\n    CharacterCodes[CharacterCodes[\"openBracket\"] = 91] = \"openBracket\";\n    CharacterCodes[CharacterCodes[\"plus\"] = 43] = \"plus\";\n    CharacterCodes[CharacterCodes[\"slash\"] = 47] = \"slash\";\n    CharacterCodes[CharacterCodes[\"formFeed\"] = 12] = \"formFeed\";\n    CharacterCodes[CharacterCodes[\"tab\"] = 9] = \"tab\";\n})(CharacterCodes || (CharacterCodes = {}));\n",
    "export const cachedSpaces = new Array(20).fill(0).map((_, index) => {\n    return ' '.repeat(index);\n});\nconst maxCachedValues = 200;\nexport const cachedBreakLinesWithSpaces = {\n    ' ': {\n        '\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\n' + ' '.repeat(index);\n        }),\n        '\\r': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r' + ' '.repeat(index);\n        }),\n        '\\r\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r\\n' + ' '.repeat(index);\n        }),\n    },\n    '\\t': {\n        '\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\n' + '\\t'.repeat(index);\n        }),\n        '\\r': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r' + '\\t'.repeat(index);\n        }),\n        '\\r\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r\\n' + '\\t'.repeat(index);\n        }),\n    }\n};\nexport const supportedEols = ['\\n', '\\r', '\\r\\n'];\n",
    "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport { createScanner } from './scanner';\nvar ParseOptions;\n(function (ParseOptions) {\n    ParseOptions.DEFAULT = {\n        allowTrailingComma: false\n    };\n})(ParseOptions || (ParseOptions = {}));\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport function getLocation(text, position) {\n    const segments = []; // strings or numbers\n    const earlyReturnException = new Object();\n    let previousNode = undefined;\n    const previousNodeInst = {\n        value: {},\n        offset: 0,\n        length: 0,\n        type: 'object',\n        parent: undefined\n    };\n    let isAtPropertyKey = false;\n    function setPreviousNode(value, offset, length, type) {\n        previousNodeInst.value = value;\n        previousNodeInst.offset = offset;\n        previousNodeInst.length = length;\n        previousNodeInst.type = type;\n        previousNodeInst.colonOffset = undefined;\n        previousNode = previousNodeInst;\n    }\n    try {\n        visit(text, {\n            onObjectBegin: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                isAtPropertyKey = position > offset;\n                segments.push(''); // push a placeholder (will be replaced)\n            },\n            onObjectProperty: (name, offset, length) => {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(name, offset, length, 'property');\n                segments[segments.length - 1] = name;\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onObjectEnd: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.pop();\n            },\n            onArrayBegin: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.push(0);\n            },\n            onArrayEnd: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.pop();\n            },\n            onLiteralValue: (value, offset, length) => {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(value, offset, length, getNodeType(value));\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onSeparator: (sep, offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                if (sep === ':' && previousNode && previousNode.type === 'property') {\n                    previousNode.colonOffset = offset;\n                    isAtPropertyKey = false;\n                    previousNode = undefined;\n                }\n                else if (sep === ',') {\n                    const last = segments[segments.length - 1];\n                    if (typeof last === 'number') {\n                        segments[segments.length - 1] = last + 1;\n                    }\n                    else {\n                        isAtPropertyKey = true;\n                        segments[segments.length - 1] = '';\n                    }\n                    previousNode = undefined;\n                }\n            }\n        });\n    }\n    catch (e) {\n        if (e !== earlyReturnException) {\n            throw e;\n        }\n    }\n    return {\n        path: segments,\n        previousNode,\n        isAtPropertyKey,\n        matches: (pattern) => {\n            let k = 0;\n            for (let i = 0; k < pattern.length && i < segments.length; i++) {\n                if (pattern[k] === segments[i] || pattern[k] === '*') {\n                    k++;\n                }\n                else if (pattern[k] !== '**') {\n                    return false;\n                }\n            }\n            return k === pattern.length;\n        }\n    };\n}\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore always check the errors list to find out if the input was valid.\n */\nexport function parse(text, errors = [], options = ParseOptions.DEFAULT) {\n    let currentProperty = null;\n    let currentParent = [];\n    const previousParents = [];\n    function onValue(value) {\n        if (Array.isArray(currentParent)) {\n            currentParent.push(value);\n        }\n        else if (currentProperty !== null) {\n            currentParent[currentProperty] = value;\n        }\n    }\n    const visitor = {\n        onObjectBegin: () => {\n            const object = {};\n            onValue(object);\n            previousParents.push(currentParent);\n            currentParent = object;\n            currentProperty = null;\n        },\n        onObjectProperty: (name) => {\n            currentProperty = name;\n        },\n        onObjectEnd: () => {\n            currentParent = previousParents.pop();\n        },\n        onArrayBegin: () => {\n            const array = [];\n            onValue(array);\n            previousParents.push(currentParent);\n            currentParent = array;\n            currentProperty = null;\n        },\n        onArrayEnd: () => {\n            currentParent = previousParents.pop();\n        },\n        onLiteralValue: onValue,\n        onError: (error, offset, length) => {\n            errors.push({ error, offset, length });\n        }\n    };\n    visit(text, visitor, options);\n    return currentParent[0];\n}\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {\n    let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root\n    function ensurePropertyComplete(endOffset) {\n        if (currentParent.type === 'property') {\n            currentParent.length = endOffset - currentParent.offset;\n            currentParent = currentParent.parent;\n        }\n    }\n    function onValue(valueNode) {\n        currentParent.children.push(valueNode);\n        return valueNode;\n    }\n    const visitor = {\n        onObjectBegin: (offset) => {\n            currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });\n        },\n        onObjectProperty: (name, offset, length) => {\n            currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });\n            currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });\n        },\n        onObjectEnd: (offset, length) => {\n            ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onArrayBegin: (offset, length) => {\n            currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });\n        },\n        onArrayEnd: (offset, length) => {\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onLiteralValue: (value, offset, length) => {\n            onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });\n            ensurePropertyComplete(offset + length);\n        },\n        onSeparator: (sep, offset, length) => {\n            if (currentParent.type === 'property') {\n                if (sep === ':') {\n                    currentParent.colonOffset = offset;\n                }\n                else if (sep === ',') {\n                    ensurePropertyComplete(offset);\n                }\n            }\n        },\n        onError: (error, offset, length) => {\n            errors.push({ error, offset, length });\n        }\n    };\n    visit(text, visitor, options);\n    const result = currentParent.children[0];\n    if (result) {\n        delete result.parent;\n    }\n    return result;\n}\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport function findNodeAtLocation(root, path) {\n    if (!root) {\n        return undefined;\n    }\n    let node = root;\n    for (let segment of path) {\n        if (typeof segment === 'string') {\n            if (node.type !== 'object' || !Array.isArray(node.children)) {\n                return undefined;\n            }\n            let found = false;\n            for (const propertyNode of node.children) {\n                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {\n                    node = propertyNode.children[1];\n                    found = true;\n                    break;\n                }\n            }\n            if (!found) {\n                return undefined;\n            }\n        }\n        else {\n            const index = segment;\n            if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {\n                return undefined;\n            }\n            node = node.children[index];\n        }\n    }\n    return node;\n}\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport function getNodePath(node) {\n    if (!node.parent || !node.parent.children) {\n        return [];\n    }\n    const path = getNodePath(node.parent);\n    if (node.parent.type === 'property') {\n        const key = node.parent.children[0].value;\n        path.push(key);\n    }\n    else if (node.parent.type === 'array') {\n        const index = node.parent.children.indexOf(node);\n        if (index !== -1) {\n            path.push(index);\n        }\n    }\n    return path;\n}\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport function getNodeValue(node) {\n    switch (node.type) {\n        case 'array':\n            return node.children.map(getNodeValue);\n        case 'object':\n            const obj = Object.create(null);\n            for (let prop of node.children) {\n                const valueNode = prop.children[1];\n                if (valueNode) {\n                    obj[prop.children[0].value] = getNodeValue(valueNode);\n                }\n            }\n            return obj;\n        case 'null':\n        case 'string':\n        case 'number':\n        case 'boolean':\n            return node.value;\n        default:\n            return undefined;\n    }\n}\nexport function contains(node, offset, includeRightBound = false) {\n    return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));\n}\n/**\n * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport function findNodeAtOffset(node, offset, includeRightBound = false) {\n    if (contains(node, offset, includeRightBound)) {\n        const children = node.children;\n        if (Array.isArray(children)) {\n            for (let i = 0; i < children.length && children[i].offset <= offset; i++) {\n                const item = findNodeAtOffset(children[i], offset, includeRightBound);\n                if (item) {\n                    return item;\n                }\n            }\n        }\n        return node;\n    }\n    return undefined;\n}\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport function visit(text, visitor, options = ParseOptions.DEFAULT) {\n    const _scanner = createScanner(text, false);\n    // Important: Only pass copies of this to visitor functions to prevent accidental modification, and\n    // to not affect visitor functions which stored a reference to a previous JSONPath\n    const _jsonPath = [];\n    // Depth of onXXXBegin() callbacks suppressed. onXXXEnd() decrements this if it isn't 0 already.\n    // Callbacks are only called when this value is 0.\n    let suppressedCallbacks = 0;\n    function toNoArgVisit(visitFunction) {\n        return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;\n    }\n    function toOneArgVisit(visitFunction) {\n        return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;\n    }\n    function toOneArgVisitWithPath(visitFunction) {\n        return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;\n    }\n    function toBeginVisit(visitFunction) {\n        return visitFunction ?\n            () => {\n                if (suppressedCallbacks > 0) {\n                    suppressedCallbacks++;\n                }\n                else {\n                    let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());\n                    if (cbReturn === false) {\n                        suppressedCallbacks = 1;\n                    }\n                }\n            }\n            : () => true;\n    }\n    function toEndVisit(visitFunction) {\n        return visitFunction ?\n            () => {\n                if (suppressedCallbacks > 0) {\n                    suppressedCallbacks--;\n                }\n                if (suppressedCallbacks === 0) {\n                    visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());\n                }\n            }\n            : () => true;\n    }\n    const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);\n    const disallowComments = options && options.disallowComments;\n    const allowTrailingComma = options && options.allowTrailingComma;\n    function scanNext() {\n        while (true) {\n            const token = _scanner.scan();\n            switch (_scanner.getTokenError()) {\n                case 4 /* ScanError.InvalidUnicode */:\n                    handleError(14 /* ParseErrorCode.InvalidUnicode */);\n                    break;\n                case 5 /* ScanError.InvalidEscapeCharacter */:\n                    handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);\n                    break;\n                case 3 /* ScanError.UnexpectedEndOfNumber */:\n                    handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);\n                    break;\n                case 1 /* ScanError.UnexpectedEndOfComment */:\n                    if (!disallowComments) {\n                        handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);\n                    }\n                    break;\n                case 2 /* ScanError.UnexpectedEndOfString */:\n                    handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);\n                    break;\n                case 6 /* ScanError.InvalidCharacter */:\n                    handleError(16 /* ParseErrorCode.InvalidCharacter */);\n                    break;\n            }\n            switch (token) {\n                case 12 /* SyntaxKind.LineCommentTrivia */:\n                case 13 /* SyntaxKind.BlockCommentTrivia */:\n                    if (disallowComments) {\n                        handleError(10 /* ParseErrorCode.InvalidCommentToken */);\n                    }\n                    else {\n                        onComment();\n                    }\n                    break;\n                case 16 /* SyntaxKind.Unknown */:\n                    handleError(1 /* ParseErrorCode.InvalidSymbol */);\n                    break;\n                case 15 /* SyntaxKind.Trivia */:\n                case 14 /* SyntaxKind.LineBreakTrivia */:\n                    break;\n                default:\n                    return token;\n            }\n        }\n    }\n    function handleError(error, skipUntilAfter = [], skipUntil = []) {\n        onError(error);\n        if (skipUntilAfter.length + skipUntil.length > 0) {\n            let token = _scanner.getToken();\n            while (token !== 17 /* SyntaxKind.EOF */) {\n                if (skipUntilAfter.indexOf(token) !== -1) {\n                    scanNext();\n                    break;\n                }\n                else if (skipUntil.indexOf(token) !== -1) {\n                    break;\n                }\n                token = scanNext();\n            }\n        }\n    }\n    function parseString(isValue) {\n        const value = _scanner.getTokenValue();\n        if (isValue) {\n            onLiteralValue(value);\n        }\n        else {\n            onObjectProperty(value);\n            // add property name afterwards\n            _jsonPath.push(value);\n        }\n        scanNext();\n        return true;\n    }\n    function parseLiteral() {\n        switch (_scanner.getToken()) {\n            case 11 /* SyntaxKind.NumericLiteral */:\n                const tokenValue = _scanner.getTokenValue();\n                let value = Number(tokenValue);\n                if (isNaN(value)) {\n                    handleError(2 /* ParseErrorCode.InvalidNumberFormat */);\n                    value = 0;\n                }\n                onLiteralValue(value);\n                break;\n            case 7 /* SyntaxKind.NullKeyword */:\n                onLiteralValue(null);\n                break;\n            case 8 /* SyntaxKind.TrueKeyword */:\n                onLiteralValue(true);\n                break;\n            case 9 /* SyntaxKind.FalseKeyword */:\n                onLiteralValue(false);\n                break;\n            default:\n                return false;\n        }\n        scanNext();\n        return true;\n    }\n    function parseProperty() {\n        if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {\n            handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n            return false;\n        }\n        parseString(false);\n        if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {\n            onSeparator(':');\n            scanNext(); // consume colon\n            if (!parseValue()) {\n                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n            }\n        }\n        else {\n            handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n        }\n        _jsonPath.pop(); // remove processed property name\n        return true;\n    }\n    function parseObject() {\n        onObjectBegin();\n        scanNext(); // consume open brace\n        let needsComma = false;\n        while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {\n            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);\n            }\n            if (!parseProperty()) {\n                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onObjectEnd();\n        if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {\n            handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);\n        }\n        else {\n            scanNext(); // consume close brace\n        }\n        return true;\n    }\n    function parseArray() {\n        onArrayBegin();\n        scanNext(); // consume open bracket\n        let isFirstElement = true;\n        let needsComma = false;\n        while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {\n            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);\n            }\n            if (isFirstElement) {\n                _jsonPath.push(0);\n                isFirstElement = false;\n            }\n            else {\n                _jsonPath[_jsonPath.length - 1]++;\n            }\n            if (!parseValue()) {\n                handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onArrayEnd();\n        if (!isFirstElement) {\n            _jsonPath.pop(); // remove array index\n        }\n        if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {\n            handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);\n        }\n        else {\n            scanNext(); // consume close bracket\n        }\n        return true;\n    }\n    function parseValue() {\n        switch (_scanner.getToken()) {\n            case 3 /* SyntaxKind.OpenBracketToken */:\n                return parseArray();\n            case 1 /* SyntaxKind.OpenBraceToken */:\n                return parseObject();\n            case 10 /* SyntaxKind.StringLiteral */:\n                return parseString(true);\n            default:\n                return parseLiteral();\n        }\n    }\n    scanNext();\n    if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {\n        if (options.allowEmptyContent) {\n            return true;\n        }\n        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n        return false;\n    }\n    if (!parseValue()) {\n        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n        return false;\n    }\n    if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {\n        handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);\n    }\n    return true;\n}\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport function stripComments(text, replaceCh) {\n    let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;\n    do {\n        pos = _scanner.getPosition();\n        kind = _scanner.scan();\n        switch (kind) {\n            case 12 /* SyntaxKind.LineCommentTrivia */:\n            case 13 /* SyntaxKind.BlockCommentTrivia */:\n            case 17 /* SyntaxKind.EOF */:\n                if (offset !== pos) {\n                    parts.push(text.substring(offset, pos));\n                }\n                if (replaceCh !== undefined) {\n                    parts.push(_scanner.getTokenValue().replace(/[^\\r\\n]/g, replaceCh));\n                }\n                offset = _scanner.getPosition();\n                break;\n        }\n    } while (kind !== 17 /* SyntaxKind.EOF */);\n    return parts.join('');\n}\nexport function getNodeType(value) {\n    switch (typeof value) {\n        case 'boolean': return 'boolean';\n        case 'number': return 'number';\n        case 'string': return 'string';\n        case 'object': {\n            if (!value) {\n                return 'null';\n            }\n            else if (Array.isArray(value)) {\n                return 'array';\n            }\n            return 'object';\n        }\n        default: return 'null';\n    }\n}\n",
    "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport * as formatter from './impl/format';\nimport * as edit from './impl/edit';\nimport * as scanner from './impl/scanner';\nimport * as parser from './impl/parser';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport const createScanner = scanner.createScanner;\nexport var ScanError;\n(function (ScanError) {\n    ScanError[ScanError[\"None\"] = 0] = \"None\";\n    ScanError[ScanError[\"UnexpectedEndOfComment\"] = 1] = \"UnexpectedEndOfComment\";\n    ScanError[ScanError[\"UnexpectedEndOfString\"] = 2] = \"UnexpectedEndOfString\";\n    ScanError[ScanError[\"UnexpectedEndOfNumber\"] = 3] = \"UnexpectedEndOfNumber\";\n    ScanError[ScanError[\"InvalidUnicode\"] = 4] = \"InvalidUnicode\";\n    ScanError[ScanError[\"InvalidEscapeCharacter\"] = 5] = \"InvalidEscapeCharacter\";\n    ScanError[ScanError[\"InvalidCharacter\"] = 6] = \"InvalidCharacter\";\n})(ScanError || (ScanError = {}));\nexport var SyntaxKind;\n(function (SyntaxKind) {\n    SyntaxKind[SyntaxKind[\"OpenBraceToken\"] = 1] = \"OpenBraceToken\";\n    SyntaxKind[SyntaxKind[\"CloseBraceToken\"] = 2] = \"CloseBraceToken\";\n    SyntaxKind[SyntaxKind[\"OpenBracketToken\"] = 3] = \"OpenBracketToken\";\n    SyntaxKind[SyntaxKind[\"CloseBracketToken\"] = 4] = \"CloseBracketToken\";\n    SyntaxKind[SyntaxKind[\"CommaToken\"] = 5] = \"CommaToken\";\n    SyntaxKind[SyntaxKind[\"ColonToken\"] = 6] = \"ColonToken\";\n    SyntaxKind[SyntaxKind[\"NullKeyword\"] = 7] = \"NullKeyword\";\n    SyntaxKind[SyntaxKind[\"TrueKeyword\"] = 8] = \"TrueKeyword\";\n    SyntaxKind[SyntaxKind[\"FalseKeyword\"] = 9] = \"FalseKeyword\";\n    SyntaxKind[SyntaxKind[\"StringLiteral\"] = 10] = \"StringLiteral\";\n    SyntaxKind[SyntaxKind[\"NumericLiteral\"] = 11] = \"NumericLiteral\";\n    SyntaxKind[SyntaxKind[\"LineCommentTrivia\"] = 12] = \"LineCommentTrivia\";\n    SyntaxKind[SyntaxKind[\"BlockCommentTrivia\"] = 13] = \"BlockCommentTrivia\";\n    SyntaxKind[SyntaxKind[\"LineBreakTrivia\"] = 14] = \"LineBreakTrivia\";\n    SyntaxKind[SyntaxKind[\"Trivia\"] = 15] = \"Trivia\";\n    SyntaxKind[SyntaxKind[\"Unknown\"] = 16] = \"Unknown\";\n    SyntaxKind[SyntaxKind[\"EOF\"] = 17] = \"EOF\";\n})(SyntaxKind || (SyntaxKind = {}));\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport const getLocation = parser.getLocation;\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore, always check the errors list to find out if the input was valid.\n */\nexport const parse = parser.parse;\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport const parseTree = parser.parseTree;\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport const findNodeAtLocation = parser.findNodeAtLocation;\n/**\n * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport const findNodeAtOffset = parser.findNodeAtOffset;\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport const getNodePath = parser.getNodePath;\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport const getNodeValue = parser.getNodeValue;\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport const visit = parser.visit;\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport const stripComments = parser.stripComments;\nexport var ParseErrorCode;\n(function (ParseErrorCode) {\n    ParseErrorCode[ParseErrorCode[\"InvalidSymbol\"] = 1] = \"InvalidSymbol\";\n    ParseErrorCode[ParseErrorCode[\"InvalidNumberFormat\"] = 2] = \"InvalidNumberFormat\";\n    ParseErrorCode[ParseErrorCode[\"PropertyNameExpected\"] = 3] = \"PropertyNameExpected\";\n    ParseErrorCode[ParseErrorCode[\"ValueExpected\"] = 4] = \"ValueExpected\";\n    ParseErrorCode[ParseErrorCode[\"ColonExpected\"] = 5] = \"ColonExpected\";\n    ParseErrorCode[ParseErrorCode[\"CommaExpected\"] = 6] = \"CommaExpected\";\n    ParseErrorCode[ParseErrorCode[\"CloseBraceExpected\"] = 7] = \"CloseBraceExpected\";\n    ParseErrorCode[ParseErrorCode[\"CloseBracketExpected\"] = 8] = \"CloseBracketExpected\";\n    ParseErrorCode[ParseErrorCode[\"EndOfFileExpected\"] = 9] = \"EndOfFileExpected\";\n    ParseErrorCode[ParseErrorCode[\"InvalidCommentToken\"] = 10] = \"InvalidCommentToken\";\n    ParseErrorCode[ParseErrorCode[\"UnexpectedEndOfComment\"] = 11] = \"UnexpectedEndOfComment\";\n    ParseErrorCode[ParseErrorCode[\"UnexpectedEndOfString\"] = 12] = \"UnexpectedEndOfString\";\n    ParseErrorCode[ParseErrorCode[\"UnexpectedEndOfNumber\"] = 13] = \"UnexpectedEndOfNumber\";\n    ParseErrorCode[ParseErrorCode[\"InvalidUnicode\"] = 14] = \"InvalidUnicode\";\n    ParseErrorCode[ParseErrorCode[\"InvalidEscapeCharacter\"] = 15] = \"InvalidEscapeCharacter\";\n    ParseErrorCode[ParseErrorCode[\"InvalidCharacter\"] = 16] = \"InvalidCharacter\";\n})(ParseErrorCode || (ParseErrorCode = {}));\nexport function printParseErrorCode(code) {\n    switch (code) {\n        case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol';\n        case 2 /* ParseErrorCode.InvalidNumberFormat */: return 'InvalidNumberFormat';\n        case 3 /* ParseErrorCode.PropertyNameExpected */: return 'PropertyNameExpected';\n        case 4 /* ParseErrorCode.ValueExpected */: return 'ValueExpected';\n        case 5 /* ParseErrorCode.ColonExpected */: return 'ColonExpected';\n        case 6 /* ParseErrorCode.CommaExpected */: return 'CommaExpected';\n        case 7 /* ParseErrorCode.CloseBraceExpected */: return 'CloseBraceExpected';\n        case 8 /* ParseErrorCode.CloseBracketExpected */: return 'CloseBracketExpected';\n        case 9 /* ParseErrorCode.EndOfFileExpected */: return 'EndOfFileExpected';\n        case 10 /* ParseErrorCode.InvalidCommentToken */: return 'InvalidCommentToken';\n        case 11 /* ParseErrorCode.UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';\n        case 12 /* ParseErrorCode.UnexpectedEndOfString */: return 'UnexpectedEndOfString';\n        case 13 /* ParseErrorCode.UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';\n        case 14 /* ParseErrorCode.InvalidUnicode */: return 'InvalidUnicode';\n        case 15 /* ParseErrorCode.InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';\n        case 16 /* ParseErrorCode.InvalidCharacter */: return 'InvalidCharacter';\n    }\n    return '<unknown ParseErrorCode>';\n}\n/**\n * Computes the edit operations needed to format a JSON document.\n *\n * @param documentText The input text\n * @param range The range to format or `undefined` to format the full content\n * @param options The formatting options\n * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.\n * To apply the edit operations to the input, use {@linkcode applyEdits}.\n */\nexport function format(documentText, range, options) {\n    return formatter.format(documentText, range, options);\n}\n/**\n * Computes the edit operations needed to modify a value in the JSON document.\n *\n * @param documentText The input text\n * @param path The path of the value to change. The path represents either to the document root, a property or an array item.\n * If the path points to an non-existing property or item, it will be created.\n * @param value The new value for the specified property or item. If the value is undefined,\n * the property or item will be removed.\n * @param options Options\n * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.\n * To apply the edit operations to the input, use {@linkcode applyEdits}.\n */\nexport function modify(text, path, value, options) {\n    return edit.setProperty(text, path, value, options);\n}\n/**\n * Applies edits to an input string.\n * @param text The input text\n * @param edits Edit operations following the format described in {@linkcode EditResult}.\n * @returns The text with the applied edits.\n * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.\n */\nexport function applyEdits(text, edits) {\n    let sortedEdits = edits.slice(0).sort((a, b) => {\n        const diff = a.offset - b.offset;\n        if (diff === 0) {\n            return a.length - b.length;\n        }\n        return diff;\n    });\n    let lastModifiedOffset = text.length;\n    for (let i = sortedEdits.length - 1; i >= 0; i--) {\n        let e = sortedEdits[i];\n        if (e.offset + e.length <= lastModifiedOffset) {\n            text = edit.applyEdit(text, e);\n        }\n        else {\n            throw new Error('Overlapping edit');\n        }\n        lastModifiedOffset = e.offset;\n    }\n    return text;\n}\n",
    "import { $ } from \"bun\";\nimport { canSudo, isRoot } from \"./helpers\";\nimport { pkgs } from \"./pkgs\";\n\nBun.env.PATH = [\n\tBun.env.PATH ?? \"\",\n\t\"/home/linuxbrew/.linuxbrew/bin\",\n\t\"/home/linuxbrew/.linuxbrew/sbin\",\n\t\"$BUN_INSTALL/bin\",\n\t\"$HOME/go/bin\",\n\t\"$HOME/.arkade/bin\",\n\t\"${KREW_ROOT:-$HOME/.krew}/bin\",\n\t\"$HOME/.cargo/bin\",\n\t\"$HOME/.dotnet\",\n\t\"$HOME/.dotnet/tools\",\n\t\"$HOME/.go/bin\",\n\t\"$HOME/.local/bin\",\n\t\"$HOME/bin\",\n\t\"/snap/bin\",\n\t\"/usr/local/sbin\",\n\t\"/usr/sbin\",\n\t\"/sbin\",\n].join(\":\");\n\nconst doctorRoot = async () => {\n\tif (!(await isRoot())) console.log(\"✅ You are not root\");\n\telse throw new Error(\"❌ You are root\");\n};\n\nconst doctorSudo = async () => {\n\tif (await canSudo()) console.log(\"✅ You can sudo\");\n\telse throw new Error(\"❌ You cannot sudo\");\n};\n\nconst doctorPkgs = async () => {\n\tconst result = await Promise.all(\n\t\tpkgs.map(async (pkg) => ({\n\t\t\tname: pkg.name,\n\t\t\texists: await pkg.check(),\n\t\t\tinstall: pkg.install,\n\t\t})),\n\t).then((x) => x.filter((y) => !y.exists));\n\tif (!result.length) {\n\t\tconsole.log(\"✅ All packages are installed\");\n\t} else {\n\t\tconsole.log(\"❌ Some packages are not installed\");\n\t\tconsole.table(result);\n\t\tfor (const r of result) {\n\t\t\tconsole.log(`🕒 Installing ${r.name}`);\n\t\t\tawait r\n\t\t\t\t.install()\n\t\t\t\t.then(() => console.log(`✅ Installed ${r.name}`))\n\t\t\t\t.catch(() => console.log(`❌ Failed to install ${r.name}`));\n\t\t}\n\t}\n};\n\nconst doctorGitconfig = async () => {\n\tconst expected = `[user]\n        email = charles63500@gmail.com\n        name = chneau\n[url \"ssh://git@github.com/\"]\n        insteadOf = https://github.com/\n[merge]\n        ff = false\n[pull]\n        ff = true\n        rebase = true\n[core]\n        whitespace = blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol\n[fetch]\n        prune = true\n`;\n\tconst gitconfig = await Bun.file(`${Bun.env.HOME}/.gitconfig`)\n\t\t.text()\n\t\t.catch(() => \"\");\n\tif (gitconfig === expected) {\n\t\tconsole.log(\"✅ Git config is set\");\n\t} else {\n\t\tconsole.log(\"❌ Git config is not set\");\n\t\tconsole.log(\"🕒 Setting git config\");\n\t\tawait Bun.write(`${Bun.env.HOME}/.gitconfig`, expected);\n\t\tconsole.log(\"✅ Git config is set\");\n\t}\n};\n\nconst doctorDotfiles = async () => {\n\tconst baseFiles = \"https://raw.githubusercontent.com/chneau/dotfiles/HEAD/\";\n\tconst expected = await Promise.all(\n\t\t[\".bashrc\", \".zshrc\", \".aliases\", \".profile\"].map(async (x) => ({\n\t\t\tname: x,\n\t\t\tcontent: await fetch(`${baseFiles}${x}`).then((x) => x.text()),\n\t\t\tisPresent: await Bun.file(`${Bun.env.HOME}/${x}`).exists(),\n\t\t})),\n\t);\n\tif (expected.every((x) => x.isPresent)) {\n\t\tconsole.log(\"✅ Dotfiles are installed\");\n\t} else {\n\t\tconsole.log(\"❌ Dotfiles are not installed\");\n\t\tconsole.log(\"🕒 Installing dotfiles\");\n\t\tawait Promise.all(\n\t\t\texpected.map(async (x) => {\n\t\t\t\tconsole.log(`🕒 Installing ${x.name}`);\n\t\t\t\tawait Bun.write(`${Bun.env.HOME}/${x.name}`, x.content);\n\t\t\t\tconsole.log(`✅ Installed ${x.name}`);\n\t\t\t}),\n\t\t);\n\t\tconsole.log(\"✅ Dotfiles are installed\");\n\t}\n};\n\nconst doctorDocker = async () => {\n\tif (!(await $`which docker`.nothrow().text()).includes(\"not found\")) {\n\t\tconsole.log(\"✅ Docker is installed\");\n\t} else {\n\t\tconsole.log(\"❌ Docker is not installed\");\n\t\tconsole.log(\"🕒 Installing Docker\");\n\t\tawait $`curl -sSL get.docker.com | sh`;\n\t\tconsole.log(\"✅ Docker is installed\");\n\t}\n};\n\nconst doctorUserGroups = async () => {\n\tconst groups = await $`groups`.text();\n\tif (groups.includes(\"docker\")) {\n\t\tconsole.log(\"✅ User is in docker groups\");\n\t} else {\n\t\tconsole.log(\"❌ User is not in docker groups\");\n\t\tconsole.log(\"🕒 Adding user to docker groups\");\n\t\tawait $`sudo usermod -aG docker $USER`.catch(() => {});\n\t\tconsole.log(\"✅ User is in docker groups\");\n\t}\n};\n\nconst doctorSsh = async () => {\n\tconst sshDir = `${Bun.env.HOME}/.ssh/id_rsa`;\n\tif (await Bun.file(sshDir).exists()) {\n\t\tconsole.log(\"✅ SSH key is set\");\n\t} else {\n\t\tconsole.log(\"❌ SSH key is not set\");\n\t\tconsole.log(\n\t\t\t'⚡ Please execute this command:\\n\\nssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -P \"\"',\n\t\t);\n\t\tthrow new Error(\"❌ SSH key is not set\");\n\t}\n};\n\nconst doctorGithub = async () => {\n\tif (\n\t\tawait $`ssh -o \"StrictHostKeyChecking no\" git@github.com 2>&1`\n\t\t\t.nothrow()\n\t\t\t.text()\n\t\t\t.then((x) => x.includes(\"successfully authenticated\"))\n\t) {\n\t\tconsole.log(\"✅ SSH key is set on GitHub\");\n\t} else {\n\t\tconsole.log(\"❌ SSH key is not set on GitHub\");\n\t\tconsole.log(\"🕒 Adding SSH key to GitHub\");\n\t\tawait $`cat ~/.ssh/id_rsa.pub`;\n\t\tconsole.log(\n\t\t\t\"⚡ Go to https://github.com/settings/ssh/new and past the text above\",\n\t\t);\n\t}\n};\n\nconst doctorZsh = async () => {\n\tconst etcShells = await Bun.file(\"/etc/shells\")\n\t\t.text()\n\t\t.then((x) => x.split(\"\\n\"));\n\tconst whichZsh = await $`which zsh`.nothrow().text();\n\tif (etcShells.includes(whichZsh)) {\n\t\tconsole.log(\"✅ Zsh is set as a valid shell\");\n\t} else {\n\t\tconsole.log(\"❌ Zsh is not set as a valid shell\");\n\t\tconsole.log(\"🕒 Adding Zsh to /etc/shells\");\n\t\tawait $`echo ${whichZsh} | sudo tee -a /etc/shells`;\n\t\tconsole.log(\"✅ Zsh is set as a valid shell\");\n\t}\n\tconst etcPasswdOfUSer = await $`cat /etc/passwd | grep \"^$USER:\"`.text();\n\tif (etcPasswdOfUSer.includes(whichZsh)) {\n\t\tconsole.log(\"✅ Zsh is set as your shell\");\n\t} else {\n\t\tconsole.log(\"❌ Zsh is not set as your shell\");\n\t\tconsole.log(\"🕒 Setting Zsh as your shell\");\n\t\tawait $`sudo chsh -s ${whichZsh} $USER`;\n\t\tconsole.log(\"✅ Zsh is set as your shell\");\n\t}\n};\n\nexport const commandDoctor = async () => {\n\tawait Promise.all([doctorRoot(), doctorSudo()]);\n\tawait Promise.all([\n\t\tdoctorDotfiles(),\n\t\tdoctorPkgs().then(() =>\n\t\t\tPromise.all([\n\t\t\t\tdoctorGitconfig().then(doctorSsh).then(doctorGithub),\n\t\t\t\tdoctorZsh(),\n\t\t\t\tdoctorDocker().then(doctorUserGroups),\n\t\t\t]),\n\t\t),\n\t]);\n};\n",
    "import { $ } from \"bun\";\n\nexport const commandExists = async (cmd: string) =>\n\t(await $`which ${cmd}`.text().catch(() => \"\")).trim() !== \"\";\n\nexport const isRoot = async () => {\n\tconst id = (await $`id -u`.text()).trim();\n\treturn id === \"0\";\n};\n\nexport const canSudo = async () => {\n\tconst text = (await $`sudo echo 0`.text().catch(() => \"\")).trim();\n\treturn text === \"0\";\n};\n\nexport const getCurrentVersion = async () =>\n\tawait Bun.file(`${import.meta.dir}/package.json`)\n\t\t.json()\n\t\t.then((x) => x.version as string)\n\t\t.catch(() => \"UNKNOWN\");\n",
    "import { $ } from \"bun\";\nimport { commandExists } from \"./helpers\";\n\ntype Pkg = {\n\tname: string;\n\tcheck: () => Promise<boolean>;\n\tinstall: () => Promise<unknown>;\n};\n\nconst aptIt = (name: string) => ({\n\tname,\n\tcheck: async () => commandExists(name),\n\tinstall: async () => await $`sudo apt install -y ${name}`,\n});\n\nconst aptPkgs: Pkg[] = [\n\taptIt(\"git\"),\n\taptIt(\"curl\"),\n\taptIt(\"wget\"),\n\taptIt(\"unzip\"),\n\taptIt(\"bash\"),\n];\n\nconst brewIt = (name: string) => ({\n\tname,\n\tcheck: async () => commandExists(name),\n\tinstall: async () => await $`brew install ${name}`,\n});\n\nconst brewPkgs: Pkg[] = [\n\tbrewIt(\"aichat\"),\n\tbrewIt(\"bpytop\"),\n\tbrewIt(\"docker-compose\"),\n\tbrewIt(\"go\"),\n\tbrewIt(\"helm\"),\n\tbrewIt(\"hyperfine\"),\n\tbrewIt(\"kubecolor\"),\n\tbrewIt(\"kubectx\"),\n\t{\n\t\t...brewIt(\"kubernetes-cli\"),\n\t\tcheck: async () => commandExists(\"kubectl\"),\n\t},\n\tbrewIt(\"lazygit\"),\n\tbrewIt(\"node\"),\n\tbrewIt(\"pipx\"),\n\tbrewIt(\"zsh\"),\n];\n\nconst bunIt = (name: string) => ({\n\tname,\n\tcheck: async () => commandExists(name),\n\tinstall: async () => await $`bun install --force --global ${name}`,\n});\n\nconst bunPkgs: Pkg[] = [\n\t{\n\t\t...bunIt(\"biome\"),\n\t\tinstall: async () => await $`bun install --force --global @biomejs/biome`,\n\t},\n\tbunIt(\"http-server\"),\n\tbunIt(\"live-server\"),\n\t{\n\t\t...bunIt(\"fkill\"),\n\t\tinstall: async () => await $`bun install --force --global fkill-cli`,\n\t},\n\tbunIt(\"ungit\"),\n\tbunIt(\"npm-check\"),\n\tbunIt(\"tsx\"),\n\tbunIt(\"npm-check-updates\"),\n\tbunIt(\"nodemon\"),\n\tbunIt(\"prettier\"),\n\tbunIt(\"typesync\"),\n\tbunIt(\"depcheck\"),\n\tbunIt(\"oxlint\"),\n\tbunIt(\"concurrently\"),\n\tbunIt(\"ts-unused-exports\"),\n];\nexport const pkgs: Pkg[] = [\n\t...aptPkgs,\n\t{\n\t\tname: \"brew\",\n\t\tcheck: async () => commandExists(\"brew\"),\n\t\tinstall: async () =>\n\t\t\tawait $`HOME=/tmp CI=1 bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"`,\n\t},\n\t{\n\t\tname: \"deno\",\n\t\tcheck: async () => commandExists(\"deno\"),\n\t\tinstall: async () => await $`curl -fsSL https://deno.land/install.sh | sh`,\n\t},\n\t...brewPkgs,\n\t...bunPkgs,\n];\n",
    "import { $ } from \"bun\";\n\nexport const commandFmt = async () =>\n\tvoid (await Promise.all([\n\t\t$`deno fmt --use-tabs --quiet; oxlint --fix-dangerously --quiet; biome check --write --unsafe .`.nothrow(),\n\t\t$`go fmt ./...`.nothrow(),\n\t\t$`dotnet csharpier .`.nothrow(),\n\t]));\n",
    "import { $ } from \"bun\";\nimport { canSudo, commandExists, isRoot } from \"./helpers\";\n\nconst updateDotfiles = async () => {\n\tconst initScript = await fetch(\n\t\t\"https://raw.githubusercontent.com/chneau/dotfiles/master/bootstrap.sh\",\n\t).then((x) => x.text());\n\tawait $`echo ${initScript} | sh`;\n};\n\nconst updateBun = async () => {\n\tconst bunPkgs = [\n\t\t\"@biomejs/biome\",\n\t\t\"http-server\",\n\t\t\"live-server\",\n\t\t\"fkill-cli\",\n\t\t\"ungit\",\n\t\t\"npm-check\",\n\t\t\"tsx\",\n\t\t\"npm-check-updates\",\n\t\t\"nodemon\",\n\t\t\"prettier\",\n\t\t\"typesync\",\n\t\t\"depcheck\",\n\t\t\"concurrently\",\n\t\t\"ts-unused-exports\",\n\t];\n\tawait $`bun upgrade`;\n\tawait $`bun install --force --global ${{ raw: bunPkgs.join(\" \") }}`;\n\tawait $`bun update --latest --force --global`;\n};\n\nconst updateApt = async () => {\n\tconst essentialPkgs = [\"git\", \"curl\", \"wget\", \"unzip\", \"zsh\", \"bash\"];\n\tawait $`sudo apt install -y ${{ raw: essentialPkgs.join(\" \") }}`;\n\tawait $`sudo apt update -y`;\n\tawait $`sudo apt upgrade -y`;\n\tawait $`sudo apt autoremove -y`;\n\tawait $`sudo apt autoclean -y`;\n};\n\nconst updateBrew = async () => {\n\tif (!(await commandExists(\"brew\"))) {\n\t\tawait $`CI=1 bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"`;\n\t}\n\tconst essentialPkgs = [\n\t\t\"bpytop\",\n\t\t\"dive\",\n\t\t\"dldash/core/docker-color-output\",\n\t\t\"docker-compose\",\n\t\t\"go\",\n\t\t\"helm\",\n\t\t\"hyperfine\",\n\t\t\"kubecolor\",\n\t\t\"kubectx\",\n\t\t\"kubernetes-cli\",\n\t\t\"lazygit\",\n\t\t\"node\",\n\t\t\"pipx\",\n\t\t\"zsh\",\n\t];\n\tconst brew =\n\t\t(await $`which brew`.text().catch(() => \"\")).trim() ||\n\t\t\"/home/linuxbrew/.linuxbrew/bin/brew\";\n\tawait $`${brew} install ${{ raw: essentialPkgs.join(\" \") }}`;\n\tawait $`${brew} update`;\n\tawait $`${brew} upgrade`;\n\tawait $`${brew} cleanup`;\n};\n\nexport const commandSystem = async () => {\n\tif (await isRoot()) throw new Error(\"You cannot run this command as root\");\n\tif (!(await canSudo())) throw new Error(\"You cannot sudo\");\n\tawait updateDotfiles();\n\tawait updateApt();\n\tawait updateBun();\n\tawait updateBrew();\n\tconsole.log(\"System updated\");\n};\n",
    "import { $ } from \"bun\";\nimport { fetchLatestVersion } from \"./fetchLatestVersion\";\nimport { getCurrentVersion } from \"./helpers\";\n\nexport const commandUpdate = async () => {\n\tconst latestVersion = await fetchLatestVersion();\n\tconst currentVersion = await getCurrentVersion();\n\tif (latestVersion === currentVersion) {\n\t\tconsole.log(\n\t\t\t`✅ You are already using the latest version ${currentVersion}`,\n\t\t);\n\t\treturn;\n\t}\n\tconsole.log(`🕒 You are using version ${currentVersion}`);\n\twhile (true) {\n\t\tconsole.log(`🕒 Updating to version ${latestVersion}`);\n\t\tconst installed = await $`bun i -fg @chneau/x@${latestVersion}`\n\t\t\t.quiet()\n\t\t\t.then(() => true)\n\t\t\t.catch(() => false);\n\t\tif (installed) break;\n\t\tawait Bun.sleep(1000);\n\t}\n\tconsole.log(`✅ Updated to version ${latestVersion}`);\n};\n",
    "export const fetchLatestVersion = async () =>\n\tawait fetch(\"https://registry.npmjs.org/@chneau/x/latest\")\n\t\t.then((x) => x.json().then((x) => x.version as string))\n\t\t.catch(() => \"UNKNOWN\");\n",
    "#!/usr/bin/env bun\nimport { program } from \"commander\";\nimport { command } from \"./command\";\nimport { commandDoctor } from \"./commandDoctor\";\nimport { commandFmt } from \"./commandFmt\";\nimport { commandSystem } from \"./commandSystem\";\nimport { commandUpdate } from \"./commandUpdate\";\nimport { getCurrentVersion } from \"./helpers\";\n\nconst version = await getCurrentVersion();\n\nprogram.name(\"x\").description(\"chneau's utility CLI\").version(version);\n\nprogram\n\t.option(\"-r, --recursive [number]\", \"Recursion level\", Number.parseFloat)\n\t.argument(\"[dir]\", \"Directory to manage\", \".\")\n\t.action(command);\n\nprogram.command(\"fmt\").description(\"Format all files\").action(commandFmt);\n\nprogram\n\t.command(\"update\")\n\t.description(\"Update x to the latest version\")\n\t.action(commandUpdate);\n\nprogram\n\t.command(\"system\")\n\t.description(\"Update/install the system packages\")\n\t.action(commandSystem);\n\nprogram\n\t.command(\"doctor\")\n\t.description(\"Check the system for issues\")\n\t.action(commandDoctor);\n\nprogram.parse();\n"
  ],
  "mappings": "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",
  "debugId": "91DA86CCC903618064756E2164756E21",
  "names": []
}
+//# debugId=863DA44C78FD2ABC64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["node_modules/commander/lib/error.js", "node_modules/commander/lib/argument.js", "node_modules/commander/lib/help.js", "node_modules/commander/lib/option.js", "node_modules/commander/lib/suggestSimilar.js", "node_modules/commander/lib/command.js", "node_modules/commander/index.js", "node_modules/eventemitter3/index.js", "node_modules/commander/esm.mjs", "command.ts", "node_modules/jsonc-parser/lib/esm/impl/scanner.js", "node_modules/jsonc-parser/lib/esm/impl/string-intern.js", "node_modules/jsonc-parser/lib/esm/impl/parser.js", "node_modules/jsonc-parser/lib/esm/main.js", "node_modules/eventemitter3/index.mjs", "node_modules/p-timeout/index.js", "node_modules/p-queue/dist/lower-bound.js", "node_modules/p-queue/dist/priority-queue.js", "node_modules/p-queue/dist/index.js", "commandDoctor.ts", "helpers.ts", "pkgs.ts", "commandFmt.ts", "commandSystem.ts", "commandUpdate.ts", "fetchLatestVersion.ts", "index.ts"],
  "sourcesContent": [
    "/**\n * CommanderError class\n */\nclass CommanderError extends Error {\n  /**\n   * Constructs the CommanderError class\n   * @param {number} exitCode suggested exit code which could be used with process.exit\n   * @param {string} code an id string representing the error\n   * @param {string} message human-readable description of the error\n   */\n  constructor(exitCode, code, message) {\n    super(message);\n    // properly capture stack trace in Node.js\n    Error.captureStackTrace(this, this.constructor);\n    this.name = this.constructor.name;\n    this.code = code;\n    this.exitCode = exitCode;\n    this.nestedError = undefined;\n  }\n}\n\n/**\n * InvalidArgumentError class\n */\nclass InvalidArgumentError extends CommanderError {\n  /**\n   * Constructs the InvalidArgumentError class\n   * @param {string} [message] explanation of why argument is invalid\n   */\n  constructor(message) {\n    super(1, 'commander.invalidArgument', message);\n    // properly capture stack trace in Node.js\n    Error.captureStackTrace(this, this.constructor);\n    this.name = this.constructor.name;\n  }\n}\n\nexports.CommanderError = CommanderError;\nexports.InvalidArgumentError = InvalidArgumentError;\n",
    "const { InvalidArgumentError } = require('./error.js');\n\nclass Argument {\n  /**\n   * Initialize a new command argument with the given name and description.\n   * The default is that the argument is required, and you can explicitly\n   * indicate this with <> around the name. Put [] around the name for an optional argument.\n   *\n   * @param {string} name\n   * @param {string} [description]\n   */\n\n  constructor(name, description) {\n    this.description = description || '';\n    this.variadic = false;\n    this.parseArg = undefined;\n    this.defaultValue = undefined;\n    this.defaultValueDescription = undefined;\n    this.argChoices = undefined;\n\n    switch (name[0]) {\n      case '<': // e.g. <required>\n        this.required = true;\n        this._name = name.slice(1, -1);\n        break;\n      case '[': // e.g. [optional]\n        this.required = false;\n        this._name = name.slice(1, -1);\n        break;\n      default:\n        this.required = true;\n        this._name = name;\n        break;\n    }\n\n    if (this._name.length > 3 && this._name.slice(-3) === '...') {\n      this.variadic = true;\n      this._name = this._name.slice(0, -3);\n    }\n  }\n\n  /**\n   * Return argument name.\n   *\n   * @return {string}\n   */\n\n  name() {\n    return this._name;\n  }\n\n  /**\n   * @package\n   */\n\n  _concatValue(value, previous) {\n    if (previous === this.defaultValue || !Array.isArray(previous)) {\n      return [value];\n    }\n\n    return previous.concat(value);\n  }\n\n  /**\n   * Set the default value, and optionally supply the description to be displayed in the help.\n   *\n   * @param {*} value\n   * @param {string} [description]\n   * @return {Argument}\n   */\n\n  default(value, description) {\n    this.defaultValue = value;\n    this.defaultValueDescription = description;\n    return this;\n  }\n\n  /**\n   * Set the custom handler for processing CLI command arguments into argument values.\n   *\n   * @param {Function} [fn]\n   * @return {Argument}\n   */\n\n  argParser(fn) {\n    this.parseArg = fn;\n    return this;\n  }\n\n  /**\n   * Only allow argument value to be one of choices.\n   *\n   * @param {string[]} values\n   * @return {Argument}\n   */\n\n  choices(values) {\n    this.argChoices = values.slice();\n    this.parseArg = (arg, previous) => {\n      if (!this.argChoices.includes(arg)) {\n        throw new InvalidArgumentError(\n          `Allowed choices are ${this.argChoices.join(', ')}.`,\n        );\n      }\n      if (this.variadic) {\n        return this._concatValue(arg, previous);\n      }\n      return arg;\n    };\n    return this;\n  }\n\n  /**\n   * Make argument required.\n   *\n   * @returns {Argument}\n   */\n  argRequired() {\n    this.required = true;\n    return this;\n  }\n\n  /**\n   * Make argument optional.\n   *\n   * @returns {Argument}\n   */\n  argOptional() {\n    this.required = false;\n    return this;\n  }\n}\n\n/**\n * Takes an argument and returns its human readable equivalent for help usage.\n *\n * @param {Argument} arg\n * @return {string}\n * @private\n */\n\nfunction humanReadableArgName(arg) {\n  const nameOutput = arg.name() + (arg.variadic === true ? '...' : '');\n\n  return arg.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';\n}\n\nexports.Argument = Argument;\nexports.humanReadableArgName = humanReadableArgName;\n",
    "const { humanReadableArgName } = require('./argument.js');\n\n/**\n * TypeScript import types for JSDoc, used by Visual Studio Code IntelliSense and `npm run typescript-checkJS`\n * https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#import-types\n * @typedef { import(\"./argument.js\").Argument } Argument\n * @typedef { import(\"./command.js\").Command } Command\n * @typedef { import(\"./option.js\").Option } Option\n */\n\n// Although this is a class, methods are static in style to allow override using subclass or just functions.\nclass Help {\n  constructor() {\n    this.helpWidth = undefined;\n    this.sortSubcommands = false;\n    this.sortOptions = false;\n    this.showGlobalOptions = false;\n  }\n\n  /**\n   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.\n   *\n   * @param {Command} cmd\n   * @returns {Command[]}\n   */\n\n  visibleCommands(cmd) {\n    const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);\n    const helpCommand = cmd._getHelpCommand();\n    if (helpCommand && !helpCommand._hidden) {\n      visibleCommands.push(helpCommand);\n    }\n    if (this.sortSubcommands) {\n      visibleCommands.sort((a, b) => {\n        // @ts-ignore: because overloaded return type\n        return a.name().localeCompare(b.name());\n      });\n    }\n    return visibleCommands;\n  }\n\n  /**\n   * Compare options for sort.\n   *\n   * @param {Option} a\n   * @param {Option} b\n   * @returns {number}\n   */\n  compareOptions(a, b) {\n    const getSortKey = (option) => {\n      // WYSIWYG for order displayed in help. Short used for comparison if present. No special handling for negated.\n      return option.short\n        ? option.short.replace(/^-/, '')\n        : option.long.replace(/^--/, '');\n    };\n    return getSortKey(a).localeCompare(getSortKey(b));\n  }\n\n  /**\n   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.\n   *\n   * @param {Command} cmd\n   * @returns {Option[]}\n   */\n\n  visibleOptions(cmd) {\n    const visibleOptions = cmd.options.filter((option) => !option.hidden);\n    // Built-in help option.\n    const helpOption = cmd._getHelpOption();\n    if (helpOption && !helpOption.hidden) {\n      // Automatically hide conflicting flags. Bit dubious but a historical behaviour that is convenient for single-command programs.\n      const removeShort = helpOption.short && cmd._findOption(helpOption.short);\n      const removeLong = helpOption.long && cmd._findOption(helpOption.long);\n      if (!removeShort && !removeLong) {\n        visibleOptions.push(helpOption); // no changes needed\n      } else if (helpOption.long && !removeLong) {\n        visibleOptions.push(\n          cmd.createOption(helpOption.long, helpOption.description),\n        );\n      } else if (helpOption.short && !removeShort) {\n        visibleOptions.push(\n          cmd.createOption(helpOption.short, helpOption.description),\n        );\n      }\n    }\n    if (this.sortOptions) {\n      visibleOptions.sort(this.compareOptions);\n    }\n    return visibleOptions;\n  }\n\n  /**\n   * Get an array of the visible global options. (Not including help.)\n   *\n   * @param {Command} cmd\n   * @returns {Option[]}\n   */\n\n  visibleGlobalOptions(cmd) {\n    if (!this.showGlobalOptions) return [];\n\n    const globalOptions = [];\n    for (\n      let ancestorCmd = cmd.parent;\n      ancestorCmd;\n      ancestorCmd = ancestorCmd.parent\n    ) {\n      const visibleOptions = ancestorCmd.options.filter(\n        (option) => !option.hidden,\n      );\n      globalOptions.push(...visibleOptions);\n    }\n    if (this.sortOptions) {\n      globalOptions.sort(this.compareOptions);\n    }\n    return globalOptions;\n  }\n\n  /**\n   * Get an array of the arguments if any have a description.\n   *\n   * @param {Command} cmd\n   * @returns {Argument[]}\n   */\n\n  visibleArguments(cmd) {\n    // Side effect! Apply the legacy descriptions before the arguments are displayed.\n    if (cmd._argsDescription) {\n      cmd.registeredArguments.forEach((argument) => {\n        argument.description =\n          argument.description || cmd._argsDescription[argument.name()] || '';\n      });\n    }\n\n    // If there are any arguments with a description then return all the arguments.\n    if (cmd.registeredArguments.find((argument) => argument.description)) {\n      return cmd.registeredArguments;\n    }\n    return [];\n  }\n\n  /**\n   * Get the command term to show in the list of subcommands.\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  subcommandTerm(cmd) {\n    // Legacy. Ignores custom usage string, and nested commands.\n    const args = cmd.registeredArguments\n      .map((arg) => humanReadableArgName(arg))\n      .join(' ');\n    return (\n      cmd._name +\n      (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +\n      (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option\n      (args ? ' ' + args : '')\n    );\n  }\n\n  /**\n   * Get the option term to show in the list of options.\n   *\n   * @param {Option} option\n   * @returns {string}\n   */\n\n  optionTerm(option) {\n    return option.flags;\n  }\n\n  /**\n   * Get the argument term to show in the list of arguments.\n   *\n   * @param {Argument} argument\n   * @returns {string}\n   */\n\n  argumentTerm(argument) {\n    return argument.name();\n  }\n\n  /**\n   * Get the longest command term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestSubcommandTermLength(cmd, helper) {\n    return helper.visibleCommands(cmd).reduce((max, command) => {\n      return Math.max(max, helper.subcommandTerm(command).length);\n    }, 0);\n  }\n\n  /**\n   * Get the longest option term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestOptionTermLength(cmd, helper) {\n    return helper.visibleOptions(cmd).reduce((max, option) => {\n      return Math.max(max, helper.optionTerm(option).length);\n    }, 0);\n  }\n\n  /**\n   * Get the longest global option term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestGlobalOptionTermLength(cmd, helper) {\n    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {\n      return Math.max(max, helper.optionTerm(option).length);\n    }, 0);\n  }\n\n  /**\n   * Get the longest argument term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  longestArgumentTermLength(cmd, helper) {\n    return helper.visibleArguments(cmd).reduce((max, argument) => {\n      return Math.max(max, helper.argumentTerm(argument).length);\n    }, 0);\n  }\n\n  /**\n   * Get the command usage to be displayed at the top of the built-in help.\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  commandUsage(cmd) {\n    // Usage\n    let cmdName = cmd._name;\n    if (cmd._aliases[0]) {\n      cmdName = cmdName + '|' + cmd._aliases[0];\n    }\n    let ancestorCmdNames = '';\n    for (\n      let ancestorCmd = cmd.parent;\n      ancestorCmd;\n      ancestorCmd = ancestorCmd.parent\n    ) {\n      ancestorCmdNames = ancestorCmd.name() + ' ' + ancestorCmdNames;\n    }\n    return ancestorCmdNames + cmdName + ' ' + cmd.usage();\n  }\n\n  /**\n   * Get the description for the command.\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  commandDescription(cmd) {\n    // @ts-ignore: because overloaded return type\n    return cmd.description();\n  }\n\n  /**\n   * Get the subcommand summary to show in the list of subcommands.\n   * (Fallback to description for backwards compatibility.)\n   *\n   * @param {Command} cmd\n   * @returns {string}\n   */\n\n  subcommandDescription(cmd) {\n    // @ts-ignore: because overloaded return type\n    return cmd.summary() || cmd.description();\n  }\n\n  /**\n   * Get the option description to show in the list of options.\n   *\n   * @param {Option} option\n   * @return {string}\n   */\n\n  optionDescription(option) {\n    const extraInfo = [];\n\n    if (option.argChoices) {\n      extraInfo.push(\n        // use stringify to match the display of the default value\n        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,\n      );\n    }\n    if (option.defaultValue !== undefined) {\n      // default for boolean and negated more for programmer than end user,\n      // but show true/false for boolean option as may be for hand-rolled env or config processing.\n      const showDefault =\n        option.required ||\n        option.optional ||\n        (option.isBoolean() && typeof option.defaultValue === 'boolean');\n      if (showDefault) {\n        extraInfo.push(\n          `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`,\n        );\n      }\n    }\n    // preset for boolean and negated are more for programmer than end user\n    if (option.presetArg !== undefined && option.optional) {\n      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);\n    }\n    if (option.envVar !== undefined) {\n      extraInfo.push(`env: ${option.envVar}`);\n    }\n    if (extraInfo.length > 0) {\n      return `${option.description} (${extraInfo.join(', ')})`;\n    }\n\n    return option.description;\n  }\n\n  /**\n   * Get the argument description to show in the list of arguments.\n   *\n   * @param {Argument} argument\n   * @return {string}\n   */\n\n  argumentDescription(argument) {\n    const extraInfo = [];\n    if (argument.argChoices) {\n      extraInfo.push(\n        // use stringify to match the display of the default value\n        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,\n      );\n    }\n    if (argument.defaultValue !== undefined) {\n      extraInfo.push(\n        `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`,\n      );\n    }\n    if (extraInfo.length > 0) {\n      const extraDescripton = `(${extraInfo.join(', ')})`;\n      if (argument.description) {\n        return `${argument.description} ${extraDescripton}`;\n      }\n      return extraDescripton;\n    }\n    return argument.description;\n  }\n\n  /**\n   * Generate the built-in help text.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {string}\n   */\n\n  formatHelp(cmd, helper) {\n    const termWidth = helper.padWidth(cmd, helper);\n    const helpWidth = helper.helpWidth || 80;\n    const itemIndentWidth = 2;\n    const itemSeparatorWidth = 2; // between term and description\n    function formatItem(term, description) {\n      if (description) {\n        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;\n        return helper.wrap(\n          fullText,\n          helpWidth - itemIndentWidth,\n          termWidth + itemSeparatorWidth,\n        );\n      }\n      return term;\n    }\n    function formatList(textArray) {\n      return textArray.join('\\n').replace(/^/gm, ' '.repeat(itemIndentWidth));\n    }\n\n    // Usage\n    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];\n\n    // Description\n    const commandDescription = helper.commandDescription(cmd);\n    if (commandDescription.length > 0) {\n      output = output.concat([\n        helper.wrap(commandDescription, helpWidth, 0),\n        '',\n      ]);\n    }\n\n    // Arguments\n    const argumentList = helper.visibleArguments(cmd).map((argument) => {\n      return formatItem(\n        helper.argumentTerm(argument),\n        helper.argumentDescription(argument),\n      );\n    });\n    if (argumentList.length > 0) {\n      output = output.concat(['Arguments:', formatList(argumentList), '']);\n    }\n\n    // Options\n    const optionList = helper.visibleOptions(cmd).map((option) => {\n      return formatItem(\n        helper.optionTerm(option),\n        helper.optionDescription(option),\n      );\n    });\n    if (optionList.length > 0) {\n      output = output.concat(['Options:', formatList(optionList), '']);\n    }\n\n    if (this.showGlobalOptions) {\n      const globalOptionList = helper\n        .visibleGlobalOptions(cmd)\n        .map((option) => {\n          return formatItem(\n            helper.optionTerm(option),\n            helper.optionDescription(option),\n          );\n        });\n      if (globalOptionList.length > 0) {\n        output = output.concat([\n          'Global Options:',\n          formatList(globalOptionList),\n          '',\n        ]);\n      }\n    }\n\n    // Commands\n    const commandList = helper.visibleCommands(cmd).map((cmd) => {\n      return formatItem(\n        helper.subcommandTerm(cmd),\n        helper.subcommandDescription(cmd),\n      );\n    });\n    if (commandList.length > 0) {\n      output = output.concat(['Commands:', formatList(commandList), '']);\n    }\n\n    return output.join('\\n');\n  }\n\n  /**\n   * Calculate the pad width from the maximum term length.\n   *\n   * @param {Command} cmd\n   * @param {Help} helper\n   * @returns {number}\n   */\n\n  padWidth(cmd, helper) {\n    return Math.max(\n      helper.longestOptionTermLength(cmd, helper),\n      helper.longestGlobalOptionTermLength(cmd, helper),\n      helper.longestSubcommandTermLength(cmd, helper),\n      helper.longestArgumentTermLength(cmd, helper),\n    );\n  }\n\n  /**\n   * Wrap the given string to width characters per line, with lines after the first indented.\n   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.\n   *\n   * @param {string} str\n   * @param {number} width\n   * @param {number} indent\n   * @param {number} [minColumnWidth=40]\n   * @return {string}\n   *\n   */\n\n  wrap(str, width, indent, minColumnWidth = 40) {\n    // Full \\s characters, minus the linefeeds.\n    const indents =\n      ' \\\\f\\\\t\\\\v\\u00a0\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff';\n    // Detect manually wrapped and indented strings by searching for line break followed by spaces.\n    const manualIndent = new RegExp(`[\\\\n][${indents}]+`);\n    if (str.match(manualIndent)) return str;\n    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).\n    const columnWidth = width - indent;\n    if (columnWidth < minColumnWidth) return str;\n\n    const leadingStr = str.slice(0, indent);\n    const columnText = str.slice(indent).replace('\\r\\n', '\\n');\n    const indentString = ' '.repeat(indent);\n    const zeroWidthSpace = '\\u200B';\n    const breaks = `\\\\s${zeroWidthSpace}`;\n    // Match line end (so empty lines don't collapse),\n    // or as much text as will fit in column, or excess text up to first break.\n    const regex = new RegExp(\n      `\\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`,\n      'g',\n    );\n    const lines = columnText.match(regex) || [];\n    return (\n      leadingStr +\n      lines\n        .map((line, i) => {\n          if (line === '\\n') return ''; // preserve empty lines\n          return (i > 0 ? indentString : '') + line.trimEnd();\n        })\n        .join('\\n')\n    );\n  }\n}\n\nexports.Help = Help;\n",
    "const { InvalidArgumentError } = require('./error.js');\n\nclass Option {\n  /**\n   * Initialize a new `Option` with the given `flags` and `description`.\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   */\n\n  constructor(flags, description) {\n    this.flags = flags;\n    this.description = description || '';\n\n    this.required = flags.includes('<'); // A value must be supplied when the option is specified.\n    this.optional = flags.includes('['); // A value is optional when the option is specified.\n    // variadic test ignores <value,...> et al which might be used to describe custom splitting of single argument\n    this.variadic = /\\w\\.\\.\\.[>\\]]$/.test(flags); // The option can take multiple values.\n    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.\n    const optionFlags = splitOptionFlags(flags);\n    this.short = optionFlags.shortFlag;\n    this.long = optionFlags.longFlag;\n    this.negate = false;\n    if (this.long) {\n      this.negate = this.long.startsWith('--no-');\n    }\n    this.defaultValue = undefined;\n    this.defaultValueDescription = undefined;\n    this.presetArg = undefined;\n    this.envVar = undefined;\n    this.parseArg = undefined;\n    this.hidden = false;\n    this.argChoices = undefined;\n    this.conflictsWith = [];\n    this.implied = undefined;\n  }\n\n  /**\n   * Set the default value, and optionally supply the description to be displayed in the help.\n   *\n   * @param {*} value\n   * @param {string} [description]\n   * @return {Option}\n   */\n\n  default(value, description) {\n    this.defaultValue = value;\n    this.defaultValueDescription = description;\n    return this;\n  }\n\n  /**\n   * Preset to use when option used without option-argument, especially optional but also boolean and negated.\n   * The custom processing (parseArg) is called.\n   *\n   * @example\n   * new Option('--color').default('GREYSCALE').preset('RGB');\n   * new Option('--donate [amount]').preset('20').argParser(parseFloat);\n   *\n   * @param {*} arg\n   * @return {Option}\n   */\n\n  preset(arg) {\n    this.presetArg = arg;\n    return this;\n  }\n\n  /**\n   * Add option name(s) that conflict with this option.\n   * An error will be displayed if conflicting options are found during parsing.\n   *\n   * @example\n   * new Option('--rgb').conflicts('cmyk');\n   * new Option('--js').conflicts(['ts', 'jsx']);\n   *\n   * @param {(string | string[])} names\n   * @return {Option}\n   */\n\n  conflicts(names) {\n    this.conflictsWith = this.conflictsWith.concat(names);\n    return this;\n  }\n\n  /**\n   * Specify implied option values for when this option is set and the implied options are not.\n   *\n   * The custom processing (parseArg) is not called on the implied values.\n   *\n   * @example\n   * program\n   *   .addOption(new Option('--log', 'write logging information to file'))\n   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));\n   *\n   * @param {object} impliedOptionValues\n   * @return {Option}\n   */\n  implies(impliedOptionValues) {\n    let newImplied = impliedOptionValues;\n    if (typeof impliedOptionValues === 'string') {\n      // string is not documented, but easy mistake and we can do what user probably intended.\n      newImplied = { [impliedOptionValues]: true };\n    }\n    this.implied = Object.assign(this.implied || {}, newImplied);\n    return this;\n  }\n\n  /**\n   * Set environment variable to check for option value.\n   *\n   * An environment variable is only used if when processed the current option value is\n   * undefined, or the source of the current value is 'default' or 'config' or 'env'.\n   *\n   * @param {string} name\n   * @return {Option}\n   */\n\n  env(name) {\n    this.envVar = name;\n    return this;\n  }\n\n  /**\n   * Set the custom handler for processing CLI option arguments into option values.\n   *\n   * @param {Function} [fn]\n   * @return {Option}\n   */\n\n  argParser(fn) {\n    this.parseArg = fn;\n    return this;\n  }\n\n  /**\n   * Whether the option is mandatory and must have a value after parsing.\n   *\n   * @param {boolean} [mandatory=true]\n   * @return {Option}\n   */\n\n  makeOptionMandatory(mandatory = true) {\n    this.mandatory = !!mandatory;\n    return this;\n  }\n\n  /**\n   * Hide option in help.\n   *\n   * @param {boolean} [hide=true]\n   * @return {Option}\n   */\n\n  hideHelp(hide = true) {\n    this.hidden = !!hide;\n    return this;\n  }\n\n  /**\n   * @package\n   */\n\n  _concatValue(value, previous) {\n    if (previous === this.defaultValue || !Array.isArray(previous)) {\n      return [value];\n    }\n\n    return previous.concat(value);\n  }\n\n  /**\n   * Only allow option value to be one of choices.\n   *\n   * @param {string[]} values\n   * @return {Option}\n   */\n\n  choices(values) {\n    this.argChoices = values.slice();\n    this.parseArg = (arg, previous) => {\n      if (!this.argChoices.includes(arg)) {\n        throw new InvalidArgumentError(\n          `Allowed choices are ${this.argChoices.join(', ')}.`,\n        );\n      }\n      if (this.variadic) {\n        return this._concatValue(arg, previous);\n      }\n      return arg;\n    };\n    return this;\n  }\n\n  /**\n   * Return option name.\n   *\n   * @return {string}\n   */\n\n  name() {\n    if (this.long) {\n      return this.long.replace(/^--/, '');\n    }\n    return this.short.replace(/^-/, '');\n  }\n\n  /**\n   * Return option name, in a camelcase format that can be used\n   * as a object attribute key.\n   *\n   * @return {string}\n   */\n\n  attributeName() {\n    return camelcase(this.name().replace(/^no-/, ''));\n  }\n\n  /**\n   * Check if `arg` matches the short or long flag.\n   *\n   * @param {string} arg\n   * @return {boolean}\n   * @package\n   */\n\n  is(arg) {\n    return this.short === arg || this.long === arg;\n  }\n\n  /**\n   * Return whether a boolean option.\n   *\n   * Options are one of boolean, negated, required argument, or optional argument.\n   *\n   * @return {boolean}\n   * @package\n   */\n\n  isBoolean() {\n    return !this.required && !this.optional && !this.negate;\n  }\n}\n\n/**\n * This class is to make it easier to work with dual options, without changing the existing\n * implementation. We support separate dual options for separate positive and negative options,\n * like `--build` and `--no-build`, which share a single option value. This works nicely for some\n * use cases, but is tricky for others where we want separate behaviours despite\n * the single shared option value.\n */\nclass DualOptions {\n  /**\n   * @param {Option[]} options\n   */\n  constructor(options) {\n    this.positiveOptions = new Map();\n    this.negativeOptions = new Map();\n    this.dualOptions = new Set();\n    options.forEach((option) => {\n      if (option.negate) {\n        this.negativeOptions.set(option.attributeName(), option);\n      } else {\n        this.positiveOptions.set(option.attributeName(), option);\n      }\n    });\n    this.negativeOptions.forEach((value, key) => {\n      if (this.positiveOptions.has(key)) {\n        this.dualOptions.add(key);\n      }\n    });\n  }\n\n  /**\n   * Did the value come from the option, and not from possible matching dual option?\n   *\n   * @param {*} value\n   * @param {Option} option\n   * @returns {boolean}\n   */\n  valueFromOption(value, option) {\n    const optionKey = option.attributeName();\n    if (!this.dualOptions.has(optionKey)) return true;\n\n    // Use the value to deduce if (probably) came from the option.\n    const preset = this.negativeOptions.get(optionKey).presetArg;\n    const negativeValue = preset !== undefined ? preset : false;\n    return option.negate === (negativeValue === value);\n  }\n}\n\n/**\n * Convert string from kebab-case to camelCase.\n *\n * @param {string} str\n * @return {string}\n * @private\n */\n\nfunction camelcase(str) {\n  return str.split('-').reduce((str, word) => {\n    return str + word[0].toUpperCase() + word.slice(1);\n  });\n}\n\n/**\n * Split the short and long flag out of something like '-m,--mixed <value>'\n *\n * @private\n */\n\nfunction splitOptionFlags(flags) {\n  let shortFlag;\n  let longFlag;\n  // Use original very loose parsing to maintain backwards compatibility for now,\n  // which allowed for example unintended `-sw, --short-word` [sic].\n  const flagParts = flags.split(/[ |,]+/);\n  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))\n    shortFlag = flagParts.shift();\n  longFlag = flagParts.shift();\n  // Add support for lone short flag without significantly changing parsing!\n  if (!shortFlag && /^-[^-]$/.test(longFlag)) {\n    shortFlag = longFlag;\n    longFlag = undefined;\n  }\n  return { shortFlag, longFlag };\n}\n\nexports.Option = Option;\nexports.DualOptions = DualOptions;\n",
    "const maxDistance = 3;\n\nfunction editDistance(a, b) {\n  // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance\n  // Calculating optimal string alignment distance, no substring is edited more than once.\n  // (Simple implementation.)\n\n  // Quick early exit, return worst case.\n  if (Math.abs(a.length - b.length) > maxDistance)\n    return Math.max(a.length, b.length);\n\n  // distance between prefix substrings of a and b\n  const d = [];\n\n  // pure deletions turn a into empty string\n  for (let i = 0; i <= a.length; i++) {\n    d[i] = [i];\n  }\n  // pure insertions turn empty string into b\n  for (let j = 0; j <= b.length; j++) {\n    d[0][j] = j;\n  }\n\n  // fill matrix\n  for (let j = 1; j <= b.length; j++) {\n    for (let i = 1; i <= a.length; i++) {\n      let cost = 1;\n      if (a[i - 1] === b[j - 1]) {\n        cost = 0;\n      } else {\n        cost = 1;\n      }\n      d[i][j] = Math.min(\n        d[i - 1][j] + 1, // deletion\n        d[i][j - 1] + 1, // insertion\n        d[i - 1][j - 1] + cost, // substitution\n      );\n      // transposition\n      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {\n        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);\n      }\n    }\n  }\n\n  return d[a.length][b.length];\n}\n\n/**\n * Find close matches, restricted to same number of edits.\n *\n * @param {string} word\n * @param {string[]} candidates\n * @returns {string}\n */\n\nfunction suggestSimilar(word, candidates) {\n  if (!candidates || candidates.length === 0) return '';\n  // remove possible duplicates\n  candidates = Array.from(new Set(candidates));\n\n  const searchingOptions = word.startsWith('--');\n  if (searchingOptions) {\n    word = word.slice(2);\n    candidates = candidates.map((candidate) => candidate.slice(2));\n  }\n\n  let similar = [];\n  let bestDistance = maxDistance;\n  const minSimilarity = 0.4;\n  candidates.forEach((candidate) => {\n    if (candidate.length <= 1) return; // no one character guesses\n\n    const distance = editDistance(word, candidate);\n    const length = Math.max(word.length, candidate.length);\n    const similarity = (length - distance) / length;\n    if (similarity > minSimilarity) {\n      if (distance < bestDistance) {\n        // better edit distance, throw away previous worse matches\n        bestDistance = distance;\n        similar = [candidate];\n      } else if (distance === bestDistance) {\n        similar.push(candidate);\n      }\n    }\n  });\n\n  similar.sort((a, b) => a.localeCompare(b));\n  if (searchingOptions) {\n    similar = similar.map((candidate) => `--${candidate}`);\n  }\n\n  if (similar.length > 1) {\n    return `\\n(Did you mean one of ${similar.join(', ')}?)`;\n  }\n  if (similar.length === 1) {\n    return `\\n(Did you mean ${similar[0]}?)`;\n  }\n  return '';\n}\n\nexports.suggestSimilar = suggestSimilar;\n",
    "const EventEmitter = require('node:events').EventEmitter;\nconst childProcess = require('node:child_process');\nconst path = require('node:path');\nconst fs = require('node:fs');\nconst process = require('node:process');\n\nconst { Argument, humanReadableArgName } = require('./argument.js');\nconst { CommanderError } = require('./error.js');\nconst { Help } = require('./help.js');\nconst { Option, DualOptions } = require('./option.js');\nconst { suggestSimilar } = require('./suggestSimilar');\n\nclass Command extends EventEmitter {\n  /**\n   * Initialize a new `Command`.\n   *\n   * @param {string} [name]\n   */\n\n  constructor(name) {\n    super();\n    /** @type {Command[]} */\n    this.commands = [];\n    /** @type {Option[]} */\n    this.options = [];\n    this.parent = null;\n    this._allowUnknownOption = false;\n    this._allowExcessArguments = true;\n    /** @type {Argument[]} */\n    this.registeredArguments = [];\n    this._args = this.registeredArguments; // deprecated old name\n    /** @type {string[]} */\n    this.args = []; // cli args with options removed\n    this.rawArgs = [];\n    this.processedArgs = []; // like .args but after custom processing and collecting variadic\n    this._scriptPath = null;\n    this._name = name || '';\n    this._optionValues = {};\n    this._optionValueSources = {}; // default, env, cli etc\n    this._storeOptionsAsProperties = false;\n    this._actionHandler = null;\n    this._executableHandler = false;\n    this._executableFile = null; // custom name for executable\n    this._executableDir = null; // custom search directory for subcommands\n    this._defaultCommandName = null;\n    this._exitCallback = null;\n    this._aliases = [];\n    this._combineFlagAndOptionalValue = true;\n    this._description = '';\n    this._summary = '';\n    this._argsDescription = undefined; // legacy\n    this._enablePositionalOptions = false;\n    this._passThroughOptions = false;\n    this._lifeCycleHooks = {}; // a hash of arrays\n    /** @type {(boolean | string)} */\n    this._showHelpAfterError = false;\n    this._showSuggestionAfterError = true;\n\n    // see .configureOutput() for docs\n    this._outputConfiguration = {\n      writeOut: (str) => process.stdout.write(str),\n      writeErr: (str) => process.stderr.write(str),\n      getOutHelpWidth: () =>\n        process.stdout.isTTY ? process.stdout.columns : undefined,\n      getErrHelpWidth: () =>\n        process.stderr.isTTY ? process.stderr.columns : undefined,\n      outputError: (str, write) => write(str),\n    };\n\n    this._hidden = false;\n    /** @type {(Option | null | undefined)} */\n    this._helpOption = undefined; // Lazy created on demand. May be null if help option is disabled.\n    this._addImplicitHelpCommand = undefined; // undecided whether true or false yet, not inherited\n    /** @type {Command} */\n    this._helpCommand = undefined; // lazy initialised, inherited\n    this._helpConfiguration = {};\n  }\n\n  /**\n   * Copy settings that are useful to have in common across root command and subcommands.\n   *\n   * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)\n   *\n   * @param {Command} sourceCommand\n   * @return {Command} `this` command for chaining\n   */\n  copyInheritedSettings(sourceCommand) {\n    this._outputConfiguration = sourceCommand._outputConfiguration;\n    this._helpOption = sourceCommand._helpOption;\n    this._helpCommand = sourceCommand._helpCommand;\n    this._helpConfiguration = sourceCommand._helpConfiguration;\n    this._exitCallback = sourceCommand._exitCallback;\n    this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;\n    this._combineFlagAndOptionalValue =\n      sourceCommand._combineFlagAndOptionalValue;\n    this._allowExcessArguments = sourceCommand._allowExcessArguments;\n    this._enablePositionalOptions = sourceCommand._enablePositionalOptions;\n    this._showHelpAfterError = sourceCommand._showHelpAfterError;\n    this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;\n\n    return this;\n  }\n\n  /**\n   * @returns {Command[]}\n   * @private\n   */\n\n  _getCommandAndAncestors() {\n    const result = [];\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    for (let command = this; command; command = command.parent) {\n      result.push(command);\n    }\n    return result;\n  }\n\n  /**\n   * Define a command.\n   *\n   * There are two styles of command: pay attention to where to put the description.\n   *\n   * @example\n   * // Command implemented using action handler (description is supplied separately to `.command`)\n   * program\n   *   .command('clone <source> [destination]')\n   *   .description('clone a repository into a newly created directory')\n   *   .action((source, destination) => {\n   *     console.log('clone command called');\n   *   });\n   *\n   * // Command implemented using separate executable file (description is second parameter to `.command`)\n   * program\n   *   .command('start <service>', 'start named service')\n   *   .command('stop [service]', 'stop named service, or all if no name supplied');\n   *\n   * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`\n   * @param {(object | string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)\n   * @param {object} [execOpts] - configuration options (for executable)\n   * @return {Command} returns new command for action handler, or `this` for executable command\n   */\n\n  command(nameAndArgs, actionOptsOrExecDesc, execOpts) {\n    let desc = actionOptsOrExecDesc;\n    let opts = execOpts;\n    if (typeof desc === 'object' && desc !== null) {\n      opts = desc;\n      desc = null;\n    }\n    opts = opts || {};\n    const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);\n\n    const cmd = this.createCommand(name);\n    if (desc) {\n      cmd.description(desc);\n      cmd._executableHandler = true;\n    }\n    if (opts.isDefault) this._defaultCommandName = cmd._name;\n    cmd._hidden = !!(opts.noHelp || opts.hidden); // noHelp is deprecated old name for hidden\n    cmd._executableFile = opts.executableFile || null; // Custom name for executable file, set missing to null to match constructor\n    if (args) cmd.arguments(args);\n    this._registerCommand(cmd);\n    cmd.parent = this;\n    cmd.copyInheritedSettings(this);\n\n    if (desc) return this;\n    return cmd;\n  }\n\n  /**\n   * Factory routine to create a new unattached command.\n   *\n   * See .command() for creating an attached subcommand, which uses this routine to\n   * create the command. You can override createCommand to customise subcommands.\n   *\n   * @param {string} [name]\n   * @return {Command} new command\n   */\n\n  createCommand(name) {\n    return new Command(name);\n  }\n\n  /**\n   * You can customise the help with a subclass of Help by overriding createHelp,\n   * or by overriding Help properties using configureHelp().\n   *\n   * @return {Help}\n   */\n\n  createHelp() {\n    return Object.assign(new Help(), this.configureHelp());\n  }\n\n  /**\n   * You can customise the help by overriding Help properties using configureHelp(),\n   * or with a subclass of Help by overriding createHelp().\n   *\n   * @param {object} [configuration] - configuration options\n   * @return {(Command | object)} `this` command for chaining, or stored configuration\n   */\n\n  configureHelp(configuration) {\n    if (configuration === undefined) return this._helpConfiguration;\n\n    this._helpConfiguration = configuration;\n    return this;\n  }\n\n  /**\n   * The default output goes to stdout and stderr. You can customise this for special\n   * applications. You can also customise the display of errors by overriding outputError.\n   *\n   * The configuration properties are all functions:\n   *\n   *     // functions to change where being written, stdout and stderr\n   *     writeOut(str)\n   *     writeErr(str)\n   *     // matching functions to specify width for wrapping help\n   *     getOutHelpWidth()\n   *     getErrHelpWidth()\n   *     // functions based on what is being written out\n   *     outputError(str, write) // used for displaying errors, and not used for displaying help\n   *\n   * @param {object} [configuration] - configuration options\n   * @return {(Command | object)} `this` command for chaining, or stored configuration\n   */\n\n  configureOutput(configuration) {\n    if (configuration === undefined) return this._outputConfiguration;\n\n    Object.assign(this._outputConfiguration, configuration);\n    return this;\n  }\n\n  /**\n   * Display the help or a custom message after an error occurs.\n   *\n   * @param {(boolean|string)} [displayHelp]\n   * @return {Command} `this` command for chaining\n   */\n  showHelpAfterError(displayHelp = true) {\n    if (typeof displayHelp !== 'string') displayHelp = !!displayHelp;\n    this._showHelpAfterError = displayHelp;\n    return this;\n  }\n\n  /**\n   * Display suggestion of similar commands for unknown commands, or options for unknown options.\n   *\n   * @param {boolean} [displaySuggestion]\n   * @return {Command} `this` command for chaining\n   */\n  showSuggestionAfterError(displaySuggestion = true) {\n    this._showSuggestionAfterError = !!displaySuggestion;\n    return this;\n  }\n\n  /**\n   * Add a prepared subcommand.\n   *\n   * See .command() for creating an attached subcommand which inherits settings from its parent.\n   *\n   * @param {Command} cmd - new subcommand\n   * @param {object} [opts] - configuration options\n   * @return {Command} `this` command for chaining\n   */\n\n  addCommand(cmd, opts) {\n    if (!cmd._name) {\n      throw new Error(`Command passed to .addCommand() must have a name\n- specify the name in Command constructor or using .name()`);\n    }\n\n    opts = opts || {};\n    if (opts.isDefault) this._defaultCommandName = cmd._name;\n    if (opts.noHelp || opts.hidden) cmd._hidden = true; // modifying passed command due to existing implementation\n\n    this._registerCommand(cmd);\n    cmd.parent = this;\n    cmd._checkForBrokenPassThrough();\n\n    return this;\n  }\n\n  /**\n   * Factory routine to create a new unattached argument.\n   *\n   * See .argument() for creating an attached argument, which uses this routine to\n   * create the argument. You can override createArgument to return a custom argument.\n   *\n   * @param {string} name\n   * @param {string} [description]\n   * @return {Argument} new argument\n   */\n\n  createArgument(name, description) {\n    return new Argument(name, description);\n  }\n\n  /**\n   * Define argument syntax for command.\n   *\n   * The default is that the argument is required, and you can explicitly\n   * indicate this with <> around the name. Put [] around the name for an optional argument.\n   *\n   * @example\n   * program.argument('<input-file>');\n   * program.argument('[output-file]');\n   *\n   * @param {string} name\n   * @param {string} [description]\n   * @param {(Function|*)} [fn] - custom argument processing function\n   * @param {*} [defaultValue]\n   * @return {Command} `this` command for chaining\n   */\n  argument(name, description, fn, defaultValue) {\n    const argument = this.createArgument(name, description);\n    if (typeof fn === 'function') {\n      argument.default(defaultValue).argParser(fn);\n    } else {\n      argument.default(fn);\n    }\n    this.addArgument(argument);\n    return this;\n  }\n\n  /**\n   * Define argument syntax for command, adding multiple at once (without descriptions).\n   *\n   * See also .argument().\n   *\n   * @example\n   * program.arguments('<cmd> [env]');\n   *\n   * @param {string} names\n   * @return {Command} `this` command for chaining\n   */\n\n  arguments(names) {\n    names\n      .trim()\n      .split(/ +/)\n      .forEach((detail) => {\n        this.argument(detail);\n      });\n    return this;\n  }\n\n  /**\n   * Define argument syntax for command, adding a prepared argument.\n   *\n   * @param {Argument} argument\n   * @return {Command} `this` command for chaining\n   */\n  addArgument(argument) {\n    const previousArgument = this.registeredArguments.slice(-1)[0];\n    if (previousArgument && previousArgument.variadic) {\n      throw new Error(\n        `only the last argument can be variadic '${previousArgument.name()}'`,\n      );\n    }\n    if (\n      argument.required &&\n      argument.defaultValue !== undefined &&\n      argument.parseArg === undefined\n    ) {\n      throw new Error(\n        `a default value for a required argument is never used: '${argument.name()}'`,\n      );\n    }\n    this.registeredArguments.push(argument);\n    return this;\n  }\n\n  /**\n   * Customise or override default help command. By default a help command is automatically added if your command has subcommands.\n   *\n   * @example\n   *    program.helpCommand('help [cmd]');\n   *    program.helpCommand('help [cmd]', 'show help');\n   *    program.helpCommand(false); // suppress default help command\n   *    program.helpCommand(true); // add help command even if no subcommands\n   *\n   * @param {string|boolean} enableOrNameAndArgs - enable with custom name and/or arguments, or boolean to override whether added\n   * @param {string} [description] - custom description\n   * @return {Command} `this` command for chaining\n   */\n\n  helpCommand(enableOrNameAndArgs, description) {\n    if (typeof enableOrNameAndArgs === 'boolean') {\n      this._addImplicitHelpCommand = enableOrNameAndArgs;\n      return this;\n    }\n\n    enableOrNameAndArgs = enableOrNameAndArgs ?? 'help [command]';\n    const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);\n    const helpDescription = description ?? 'display help for command';\n\n    const helpCommand = this.createCommand(helpName);\n    helpCommand.helpOption(false);\n    if (helpArgs) helpCommand.arguments(helpArgs);\n    if (helpDescription) helpCommand.description(helpDescription);\n\n    this._addImplicitHelpCommand = true;\n    this._helpCommand = helpCommand;\n\n    return this;\n  }\n\n  /**\n   * Add prepared custom help command.\n   *\n   * @param {(Command|string|boolean)} helpCommand - custom help command, or deprecated enableOrNameAndArgs as for `.helpCommand()`\n   * @param {string} [deprecatedDescription] - deprecated custom description used with custom name only\n   * @return {Command} `this` command for chaining\n   */\n  addHelpCommand(helpCommand, deprecatedDescription) {\n    // If not passed an object, call through to helpCommand for backwards compatibility,\n    // as addHelpCommand was originally used like helpCommand is now.\n    if (typeof helpCommand !== 'object') {\n      this.helpCommand(helpCommand, deprecatedDescription);\n      return this;\n    }\n\n    this._addImplicitHelpCommand = true;\n    this._helpCommand = helpCommand;\n    return this;\n  }\n\n  /**\n   * Lazy create help command.\n   *\n   * @return {(Command|null)}\n   * @package\n   */\n  _getHelpCommand() {\n    const hasImplicitHelpCommand =\n      this._addImplicitHelpCommand ??\n      (this.commands.length &&\n        !this._actionHandler &&\n        !this._findCommand('help'));\n\n    if (hasImplicitHelpCommand) {\n      if (this._helpCommand === undefined) {\n        this.helpCommand(undefined, undefined); // use default name and description\n      }\n      return this._helpCommand;\n    }\n    return null;\n  }\n\n  /**\n   * Add hook for life cycle event.\n   *\n   * @param {string} event\n   * @param {Function} listener\n   * @return {Command} `this` command for chaining\n   */\n\n  hook(event, listener) {\n    const allowedValues = ['preSubcommand', 'preAction', 'postAction'];\n    if (!allowedValues.includes(event)) {\n      throw new Error(`Unexpected value for event passed to hook : '${event}'.\nExpecting one of '${allowedValues.join(\"', '\")}'`);\n    }\n    if (this._lifeCycleHooks[event]) {\n      this._lifeCycleHooks[event].push(listener);\n    } else {\n      this._lifeCycleHooks[event] = [listener];\n    }\n    return this;\n  }\n\n  /**\n   * Register callback to use as replacement for calling process.exit.\n   *\n   * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing\n   * @return {Command} `this` command for chaining\n   */\n\n  exitOverride(fn) {\n    if (fn) {\n      this._exitCallback = fn;\n    } else {\n      this._exitCallback = (err) => {\n        if (err.code !== 'commander.executeSubCommandAsync') {\n          throw err;\n        } else {\n          // Async callback from spawn events, not useful to throw.\n        }\n      };\n    }\n    return this;\n  }\n\n  /**\n   * Call process.exit, and _exitCallback if defined.\n   *\n   * @param {number} exitCode exit code for using with process.exit\n   * @param {string} code an id string representing the error\n   * @param {string} message human-readable description of the error\n   * @return never\n   * @private\n   */\n\n  _exit(exitCode, code, message) {\n    if (this._exitCallback) {\n      this._exitCallback(new CommanderError(exitCode, code, message));\n      // Expecting this line is not reached.\n    }\n    process.exit(exitCode);\n  }\n\n  /**\n   * Register callback `fn` for the command.\n   *\n   * @example\n   * program\n   *   .command('serve')\n   *   .description('start service')\n   *   .action(function() {\n   *      // do work here\n   *   });\n   *\n   * @param {Function} fn\n   * @return {Command} `this` command for chaining\n   */\n\n  action(fn) {\n    const listener = (args) => {\n      // The .action callback takes an extra parameter which is the command or options.\n      const expectedArgsCount = this.registeredArguments.length;\n      const actionArgs = args.slice(0, expectedArgsCount);\n      if (this._storeOptionsAsProperties) {\n        actionArgs[expectedArgsCount] = this; // backwards compatible \"options\"\n      } else {\n        actionArgs[expectedArgsCount] = this.opts();\n      }\n      actionArgs.push(this);\n\n      return fn.apply(this, actionArgs);\n    };\n    this._actionHandler = listener;\n    return this;\n  }\n\n  /**\n   * Factory routine to create a new unattached option.\n   *\n   * See .option() for creating an attached option, which uses this routine to\n   * create the option. You can override createOption to return a custom option.\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   * @return {Option} new option\n   */\n\n  createOption(flags, description) {\n    return new Option(flags, description);\n  }\n\n  /**\n   * Wrap parseArgs to catch 'commander.invalidArgument'.\n   *\n   * @param {(Option | Argument)} target\n   * @param {string} value\n   * @param {*} previous\n   * @param {string} invalidArgumentMessage\n   * @private\n   */\n\n  _callParseArg(target, value, previous, invalidArgumentMessage) {\n    try {\n      return target.parseArg(value, previous);\n    } catch (err) {\n      if (err.code === 'commander.invalidArgument') {\n        const message = `${invalidArgumentMessage} ${err.message}`;\n        this.error(message, { exitCode: err.exitCode, code: err.code });\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Check for option flag conflicts.\n   * Register option if no conflicts found, or throw on conflict.\n   *\n   * @param {Option} option\n   * @private\n   */\n\n  _registerOption(option) {\n    const matchingOption =\n      (option.short && this._findOption(option.short)) ||\n      (option.long && this._findOption(option.long));\n    if (matchingOption) {\n      const matchingFlag =\n        option.long && this._findOption(option.long)\n          ? option.long\n          : option.short;\n      throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'\n-  already used by option '${matchingOption.flags}'`);\n    }\n\n    this.options.push(option);\n  }\n\n  /**\n   * Check for command name and alias conflicts with existing commands.\n   * Register command if no conflicts found, or throw on conflict.\n   *\n   * @param {Command} command\n   * @private\n   */\n\n  _registerCommand(command) {\n    const knownBy = (cmd) => {\n      return [cmd.name()].concat(cmd.aliases());\n    };\n\n    const alreadyUsed = knownBy(command).find((name) =>\n      this._findCommand(name),\n    );\n    if (alreadyUsed) {\n      const existingCmd = knownBy(this._findCommand(alreadyUsed)).join('|');\n      const newCmd = knownBy(command).join('|');\n      throw new Error(\n        `cannot add command '${newCmd}' as already have command '${existingCmd}'`,\n      );\n    }\n\n    this.commands.push(command);\n  }\n\n  /**\n   * Add an option.\n   *\n   * @param {Option} option\n   * @return {Command} `this` command for chaining\n   */\n  addOption(option) {\n    this._registerOption(option);\n\n    const oname = option.name();\n    const name = option.attributeName();\n\n    // store default value\n    if (option.negate) {\n      // --no-foo is special and defaults foo to true, unless a --foo option is already defined\n      const positiveLongFlag = option.long.replace(/^--no-/, '--');\n      if (!this._findOption(positiveLongFlag)) {\n        this.setOptionValueWithSource(\n          name,\n          option.defaultValue === undefined ? true : option.defaultValue,\n          'default',\n        );\n      }\n    } else if (option.defaultValue !== undefined) {\n      this.setOptionValueWithSource(name, option.defaultValue, 'default');\n    }\n\n    // handler for cli and env supplied values\n    const handleOptionValue = (val, invalidValueMessage, valueSource) => {\n      // val is null for optional option used without an optional-argument.\n      // val is undefined for boolean and negated option.\n      if (val == null && option.presetArg !== undefined) {\n        val = option.presetArg;\n      }\n\n      // custom processing\n      const oldValue = this.getOptionValue(name);\n      if (val !== null && option.parseArg) {\n        val = this._callParseArg(option, val, oldValue, invalidValueMessage);\n      } else if (val !== null && option.variadic) {\n        val = option._concatValue(val, oldValue);\n      }\n\n      // Fill-in appropriate missing values. Long winded but easy to follow.\n      if (val == null) {\n        if (option.negate) {\n          val = false;\n        } else if (option.isBoolean() || option.optional) {\n          val = true;\n        } else {\n          val = ''; // not normal, parseArg might have failed or be a mock function for testing\n        }\n      }\n      this.setOptionValueWithSource(name, val, valueSource);\n    };\n\n    this.on('option:' + oname, (val) => {\n      const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;\n      handleOptionValue(val, invalidValueMessage, 'cli');\n    });\n\n    if (option.envVar) {\n      this.on('optionEnv:' + oname, (val) => {\n        const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;\n        handleOptionValue(val, invalidValueMessage, 'env');\n      });\n    }\n\n    return this;\n  }\n\n  /**\n   * Internal implementation shared by .option() and .requiredOption()\n   *\n   * @return {Command} `this` command for chaining\n   * @private\n   */\n  _optionEx(config, flags, description, fn, defaultValue) {\n    if (typeof flags === 'object' && flags instanceof Option) {\n      throw new Error(\n        'To add an Option object use addOption() instead of option() or requiredOption()',\n      );\n    }\n    const option = this.createOption(flags, description);\n    option.makeOptionMandatory(!!config.mandatory);\n    if (typeof fn === 'function') {\n      option.default(defaultValue).argParser(fn);\n    } else if (fn instanceof RegExp) {\n      // deprecated\n      const regex = fn;\n      fn = (val, def) => {\n        const m = regex.exec(val);\n        return m ? m[0] : def;\n      };\n      option.default(defaultValue).argParser(fn);\n    } else {\n      option.default(fn);\n    }\n\n    return this.addOption(option);\n  }\n\n  /**\n   * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.\n   *\n   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required\n   * option-argument is indicated by `<>` and an optional option-argument by `[]`.\n   *\n   * See the README for more details, and see also addOption() and requiredOption().\n   *\n   * @example\n   * program\n   *     .option('-p, --pepper', 'add pepper')\n   *     .option('-p, --pizza-type <TYPE>', 'type of pizza') // required option-argument\n   *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default\n   *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   * @param {(Function|*)} [parseArg] - custom option processing function or default value\n   * @param {*} [defaultValue]\n   * @return {Command} `this` command for chaining\n   */\n\n  option(flags, description, parseArg, defaultValue) {\n    return this._optionEx({}, flags, description, parseArg, defaultValue);\n  }\n\n  /**\n   * Add a required option which must have a value after parsing. This usually means\n   * the option must be specified on the command line. (Otherwise the same as .option().)\n   *\n   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.\n   *\n   * @param {string} flags\n   * @param {string} [description]\n   * @param {(Function|*)} [parseArg] - custom option processing function or default value\n   * @param {*} [defaultValue]\n   * @return {Command} `this` command for chaining\n   */\n\n  requiredOption(flags, description, parseArg, defaultValue) {\n    return this._optionEx(\n      { mandatory: true },\n      flags,\n      description,\n      parseArg,\n      defaultValue,\n    );\n  }\n\n  /**\n   * Alter parsing of short flags with optional values.\n   *\n   * @example\n   * // for `.option('-f,--flag [value]'):\n   * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour\n   * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`\n   *\n   * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag.\n   * @return {Command} `this` command for chaining\n   */\n  combineFlagAndOptionalValue(combine = true) {\n    this._combineFlagAndOptionalValue = !!combine;\n    return this;\n  }\n\n  /**\n   * Allow unknown options on the command line.\n   *\n   * @param {boolean} [allowUnknown] - if `true` or omitted, no error will be thrown for unknown options.\n   * @return {Command} `this` command for chaining\n   */\n  allowUnknownOption(allowUnknown = true) {\n    this._allowUnknownOption = !!allowUnknown;\n    return this;\n  }\n\n  /**\n   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.\n   *\n   * @param {boolean} [allowExcess] - if `true` or omitted, no error will be thrown for excess arguments.\n   * @return {Command} `this` command for chaining\n   */\n  allowExcessArguments(allowExcess = true) {\n    this._allowExcessArguments = !!allowExcess;\n    return this;\n  }\n\n  /**\n   * Enable positional options. Positional means global options are specified before subcommands which lets\n   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.\n   * The default behaviour is non-positional and global options may appear anywhere on the command line.\n   *\n   * @param {boolean} [positional]\n   * @return {Command} `this` command for chaining\n   */\n  enablePositionalOptions(positional = true) {\n    this._enablePositionalOptions = !!positional;\n    return this;\n  }\n\n  /**\n   * Pass through options that come after command-arguments rather than treat them as command-options,\n   * so actual command-options come before command-arguments. Turning this on for a subcommand requires\n   * positional options to have been enabled on the program (parent commands).\n   * The default behaviour is non-positional and options may appear before or after command-arguments.\n   *\n   * @param {boolean} [passThrough] for unknown options.\n   * @return {Command} `this` command for chaining\n   */\n  passThroughOptions(passThrough = true) {\n    this._passThroughOptions = !!passThrough;\n    this._checkForBrokenPassThrough();\n    return this;\n  }\n\n  /**\n   * @private\n   */\n\n  _checkForBrokenPassThrough() {\n    if (\n      this.parent &&\n      this._passThroughOptions &&\n      !this.parent._enablePositionalOptions\n    ) {\n      throw new Error(\n        `passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`,\n      );\n    }\n  }\n\n  /**\n   * Whether to store option values as properties on command object,\n   * or store separately (specify false). In both cases the option values can be accessed using .opts().\n   *\n   * @param {boolean} [storeAsProperties=true]\n   * @return {Command} `this` command for chaining\n   */\n\n  storeOptionsAsProperties(storeAsProperties = true) {\n    if (this.options.length) {\n      throw new Error('call .storeOptionsAsProperties() before adding options');\n    }\n    if (Object.keys(this._optionValues).length) {\n      throw new Error(\n        'call .storeOptionsAsProperties() before setting option values',\n      );\n    }\n    this._storeOptionsAsProperties = !!storeAsProperties;\n    return this;\n  }\n\n  /**\n   * Retrieve option value.\n   *\n   * @param {string} key\n   * @return {object} value\n   */\n\n  getOptionValue(key) {\n    if (this._storeOptionsAsProperties) {\n      return this[key];\n    }\n    return this._optionValues[key];\n  }\n\n  /**\n   * Store option value.\n   *\n   * @param {string} key\n   * @param {object} value\n   * @return {Command} `this` command for chaining\n   */\n\n  setOptionValue(key, value) {\n    return this.setOptionValueWithSource(key, value, undefined);\n  }\n\n  /**\n   * Store option value and where the value came from.\n   *\n   * @param {string} key\n   * @param {object} value\n   * @param {string} source - expected values are default/config/env/cli/implied\n   * @return {Command} `this` command for chaining\n   */\n\n  setOptionValueWithSource(key, value, source) {\n    if (this._storeOptionsAsProperties) {\n      this[key] = value;\n    } else {\n      this._optionValues[key] = value;\n    }\n    this._optionValueSources[key] = source;\n    return this;\n  }\n\n  /**\n   * Get source of option value.\n   * Expected values are default | config | env | cli | implied\n   *\n   * @param {string} key\n   * @return {string}\n   */\n\n  getOptionValueSource(key) {\n    return this._optionValueSources[key];\n  }\n\n  /**\n   * Get source of option value. See also .optsWithGlobals().\n   * Expected values are default | config | env | cli | implied\n   *\n   * @param {string} key\n   * @return {string}\n   */\n\n  getOptionValueSourceWithGlobals(key) {\n    // global overwrites local, like optsWithGlobals\n    let source;\n    this._getCommandAndAncestors().forEach((cmd) => {\n      if (cmd.getOptionValueSource(key) !== undefined) {\n        source = cmd.getOptionValueSource(key);\n      }\n    });\n    return source;\n  }\n\n  /**\n   * Get user arguments from implied or explicit arguments.\n   * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.\n   *\n   * @private\n   */\n\n  _prepareUserArgs(argv, parseOptions) {\n    if (argv !== undefined && !Array.isArray(argv)) {\n      throw new Error('first parameter to parse must be array or undefined');\n    }\n    parseOptions = parseOptions || {};\n\n    // auto-detect argument conventions if nothing supplied\n    if (argv === undefined && parseOptions.from === undefined) {\n      if (process.versions?.electron) {\n        parseOptions.from = 'electron';\n      }\n      // check node specific options for scenarios where user CLI args follow executable without scriptname\n      const execArgv = process.execArgv ?? [];\n      if (\n        execArgv.includes('-e') ||\n        execArgv.includes('--eval') ||\n        execArgv.includes('-p') ||\n        execArgv.includes('--print')\n      ) {\n        parseOptions.from = 'eval'; // internal usage, not documented\n      }\n    }\n\n    // default to using process.argv\n    if (argv === undefined) {\n      argv = process.argv;\n    }\n    this.rawArgs = argv.slice();\n\n    // extract the user args and scriptPath\n    let userArgs;\n    switch (parseOptions.from) {\n      case undefined:\n      case 'node':\n        this._scriptPath = argv[1];\n        userArgs = argv.slice(2);\n        break;\n      case 'electron':\n        // @ts-ignore: because defaultApp is an unknown property\n        if (process.defaultApp) {\n          this._scriptPath = argv[1];\n          userArgs = argv.slice(2);\n        } else {\n          userArgs = argv.slice(1);\n        }\n        break;\n      case 'user':\n        userArgs = argv.slice(0);\n        break;\n      case 'eval':\n        userArgs = argv.slice(1);\n        break;\n      default:\n        throw new Error(\n          `unexpected parse option { from: '${parseOptions.from}' }`,\n        );\n    }\n\n    // Find default name for program from arguments.\n    if (!this._name && this._scriptPath)\n      this.nameFromFilename(this._scriptPath);\n    this._name = this._name || 'program';\n\n    return userArgs;\n  }\n\n  /**\n   * Parse `argv`, setting options and invoking commands when defined.\n   *\n   * Use parseAsync instead of parse if any of your action handlers are async.\n   *\n   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!\n   *\n   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:\n   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that\n   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged\n   * - `'user'`: just user arguments\n   *\n   * @example\n   * program.parse(); // parse process.argv and auto-detect electron and special node flags\n   * program.parse(process.argv); // assume argv[0] is app and argv[1] is script\n   * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]\n   *\n   * @param {string[]} [argv] - optional, defaults to process.argv\n   * @param {object} [parseOptions] - optionally specify style of options with from: node/user/electron\n   * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'\n   * @return {Command} `this` command for chaining\n   */\n\n  parse(argv, parseOptions) {\n    const userArgs = this._prepareUserArgs(argv, parseOptions);\n    this._parseCommand([], userArgs);\n\n    return this;\n  }\n\n  /**\n   * Parse `argv`, setting options and invoking commands when defined.\n   *\n   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!\n   *\n   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:\n   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that\n   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged\n   * - `'user'`: just user arguments\n   *\n   * @example\n   * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags\n   * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script\n   * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]\n   *\n   * @param {string[]} [argv]\n   * @param {object} [parseOptions]\n   * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'\n   * @return {Promise}\n   */\n\n  async parseAsync(argv, parseOptions) {\n    const userArgs = this._prepareUserArgs(argv, parseOptions);\n    await this._parseCommand([], userArgs);\n\n    return this;\n  }\n\n  /**\n   * Execute a sub-command executable.\n   *\n   * @private\n   */\n\n  _executeSubCommand(subcommand, args) {\n    args = args.slice();\n    let launchWithNode = false; // Use node for source targets so do not need to get permissions correct, and on Windows.\n    const sourceExt = ['.js', '.ts', '.tsx', '.mjs', '.cjs'];\n\n    function findFile(baseDir, baseName) {\n      // Look for specified file\n      const localBin = path.resolve(baseDir, baseName);\n      if (fs.existsSync(localBin)) return localBin;\n\n      // Stop looking if candidate already has an expected extension.\n      if (sourceExt.includes(path.extname(baseName))) return undefined;\n\n      // Try all the extensions.\n      const foundExt = sourceExt.find((ext) =>\n        fs.existsSync(`${localBin}${ext}`),\n      );\n      if (foundExt) return `${localBin}${foundExt}`;\n\n      return undefined;\n    }\n\n    // Not checking for help first. Unlikely to have mandatory and executable, and can't robustly test for help flags in external command.\n    this._checkForMissingMandatoryOptions();\n    this._checkForConflictingOptions();\n\n    // executableFile and executableDir might be full path, or just a name\n    let executableFile =\n      subcommand._executableFile || `${this._name}-${subcommand._name}`;\n    let executableDir = this._executableDir || '';\n    if (this._scriptPath) {\n      let resolvedScriptPath; // resolve possible symlink for installed npm binary\n      try {\n        resolvedScriptPath = fs.realpathSync(this._scriptPath);\n      } catch (err) {\n        resolvedScriptPath = this._scriptPath;\n      }\n      executableDir = path.resolve(\n        path.dirname(resolvedScriptPath),\n        executableDir,\n      );\n    }\n\n    // Look for a local file in preference to a command in PATH.\n    if (executableDir) {\n      let localFile = findFile(executableDir, executableFile);\n\n      // Legacy search using prefix of script name instead of command name\n      if (!localFile && !subcommand._executableFile && this._scriptPath) {\n        const legacyName = path.basename(\n          this._scriptPath,\n          path.extname(this._scriptPath),\n        );\n        if (legacyName !== this._name) {\n          localFile = findFile(\n            executableDir,\n            `${legacyName}-${subcommand._name}`,\n          );\n        }\n      }\n      executableFile = localFile || executableFile;\n    }\n\n    launchWithNode = sourceExt.includes(path.extname(executableFile));\n\n    let proc;\n    if (process.platform !== 'win32') {\n      if (launchWithNode) {\n        args.unshift(executableFile);\n        // add executable arguments to spawn\n        args = incrementNodeInspectorPort(process.execArgv).concat(args);\n\n        proc = childProcess.spawn(process.argv[0], args, { stdio: 'inherit' });\n      } else {\n        proc = childProcess.spawn(executableFile, args, { stdio: 'inherit' });\n      }\n    } else {\n      args.unshift(executableFile);\n      // add executable arguments to spawn\n      args = incrementNodeInspectorPort(process.execArgv).concat(args);\n      proc = childProcess.spawn(process.execPath, args, { stdio: 'inherit' });\n    }\n\n    if (!proc.killed) {\n      // testing mainly to avoid leak warnings during unit tests with mocked spawn\n      const signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];\n      signals.forEach((signal) => {\n        process.on(signal, () => {\n          if (proc.killed === false && proc.exitCode === null) {\n            // @ts-ignore because signals not typed to known strings\n            proc.kill(signal);\n          }\n        });\n      });\n    }\n\n    // By default terminate process when spawned process terminates.\n    const exitCallback = this._exitCallback;\n    proc.on('close', (code) => {\n      code = code ?? 1; // code is null if spawned process terminated due to a signal\n      if (!exitCallback) {\n        process.exit(code);\n      } else {\n        exitCallback(\n          new CommanderError(\n            code,\n            'commander.executeSubCommandAsync',\n            '(close)',\n          ),\n        );\n      }\n    });\n    proc.on('error', (err) => {\n      // @ts-ignore: because err.code is an unknown property\n      if (err.code === 'ENOENT') {\n        const executableDirMessage = executableDir\n          ? `searched for local subcommand relative to directory '${executableDir}'`\n          : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';\n        const executableMissing = `'${executableFile}' does not exist\n - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead\n - if the default executable name is not suitable, use the executableFile option to supply a custom name or path\n - ${executableDirMessage}`;\n        throw new Error(executableMissing);\n        // @ts-ignore: because err.code is an unknown property\n      } else if (err.code === 'EACCES') {\n        throw new Error(`'${executableFile}' not executable`);\n      }\n      if (!exitCallback) {\n        process.exit(1);\n      } else {\n        const wrappedError = new CommanderError(\n          1,\n          'commander.executeSubCommandAsync',\n          '(error)',\n        );\n        wrappedError.nestedError = err;\n        exitCallback(wrappedError);\n      }\n    });\n\n    // Store the reference to the child process\n    this.runningCommand = proc;\n  }\n\n  /**\n   * @private\n   */\n\n  _dispatchSubcommand(commandName, operands, unknown) {\n    const subCommand = this._findCommand(commandName);\n    if (!subCommand) this.help({ error: true });\n\n    let promiseChain;\n    promiseChain = this._chainOrCallSubCommandHook(\n      promiseChain,\n      subCommand,\n      'preSubcommand',\n    );\n    promiseChain = this._chainOrCall(promiseChain, () => {\n      if (subCommand._executableHandler) {\n        this._executeSubCommand(subCommand, operands.concat(unknown));\n      } else {\n        return subCommand._parseCommand(operands, unknown);\n      }\n    });\n    return promiseChain;\n  }\n\n  /**\n   * Invoke help directly if possible, or dispatch if necessary.\n   * e.g. help foo\n   *\n   * @private\n   */\n\n  _dispatchHelpCommand(subcommandName) {\n    if (!subcommandName) {\n      this.help();\n    }\n    const subCommand = this._findCommand(subcommandName);\n    if (subCommand && !subCommand._executableHandler) {\n      subCommand.help();\n    }\n\n    // Fallback to parsing the help flag to invoke the help.\n    return this._dispatchSubcommand(\n      subcommandName,\n      [],\n      [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help'],\n    );\n  }\n\n  /**\n   * Check this.args against expected this.registeredArguments.\n   *\n   * @private\n   */\n\n  _checkNumberOfArguments() {\n    // too few\n    this.registeredArguments.forEach((arg, i) => {\n      if (arg.required && this.args[i] == null) {\n        this.missingArgument(arg.name());\n      }\n    });\n    // too many\n    if (\n      this.registeredArguments.length > 0 &&\n      this.registeredArguments[this.registeredArguments.length - 1].variadic\n    ) {\n      return;\n    }\n    if (this.args.length > this.registeredArguments.length) {\n      this._excessArguments(this.args);\n    }\n  }\n\n  /**\n   * Process this.args using this.registeredArguments and save as this.processedArgs!\n   *\n   * @private\n   */\n\n  _processArguments() {\n    const myParseArg = (argument, value, previous) => {\n      // Extra processing for nice error message on parsing failure.\n      let parsedValue = value;\n      if (value !== null && argument.parseArg) {\n        const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;\n        parsedValue = this._callParseArg(\n          argument,\n          value,\n          previous,\n          invalidValueMessage,\n        );\n      }\n      return parsedValue;\n    };\n\n    this._checkNumberOfArguments();\n\n    const processedArgs = [];\n    this.registeredArguments.forEach((declaredArg, index) => {\n      let value = declaredArg.defaultValue;\n      if (declaredArg.variadic) {\n        // Collect together remaining arguments for passing together as an array.\n        if (index < this.args.length) {\n          value = this.args.slice(index);\n          if (declaredArg.parseArg) {\n            value = value.reduce((processed, v) => {\n              return myParseArg(declaredArg, v, processed);\n            }, declaredArg.defaultValue);\n          }\n        } else if (value === undefined) {\n          value = [];\n        }\n      } else if (index < this.args.length) {\n        value = this.args[index];\n        if (declaredArg.parseArg) {\n          value = myParseArg(declaredArg, value, declaredArg.defaultValue);\n        }\n      }\n      processedArgs[index] = value;\n    });\n    this.processedArgs = processedArgs;\n  }\n\n  /**\n   * Once we have a promise we chain, but call synchronously until then.\n   *\n   * @param {(Promise|undefined)} promise\n   * @param {Function} fn\n   * @return {(Promise|undefined)}\n   * @private\n   */\n\n  _chainOrCall(promise, fn) {\n    // thenable\n    if (promise && promise.then && typeof promise.then === 'function') {\n      // already have a promise, chain callback\n      return promise.then(() => fn());\n    }\n    // callback might return a promise\n    return fn();\n  }\n\n  /**\n   *\n   * @param {(Promise|undefined)} promise\n   * @param {string} event\n   * @return {(Promise|undefined)}\n   * @private\n   */\n\n  _chainOrCallHooks(promise, event) {\n    let result = promise;\n    const hooks = [];\n    this._getCommandAndAncestors()\n      .reverse()\n      .filter((cmd) => cmd._lifeCycleHooks[event] !== undefined)\n      .forEach((hookedCommand) => {\n        hookedCommand._lifeCycleHooks[event].forEach((callback) => {\n          hooks.push({ hookedCommand, callback });\n        });\n      });\n    if (event === 'postAction') {\n      hooks.reverse();\n    }\n\n    hooks.forEach((hookDetail) => {\n      result = this._chainOrCall(result, () => {\n        return hookDetail.callback(hookDetail.hookedCommand, this);\n      });\n    });\n    return result;\n  }\n\n  /**\n   *\n   * @param {(Promise|undefined)} promise\n   * @param {Command} subCommand\n   * @param {string} event\n   * @return {(Promise|undefined)}\n   * @private\n   */\n\n  _chainOrCallSubCommandHook(promise, subCommand, event) {\n    let result = promise;\n    if (this._lifeCycleHooks[event] !== undefined) {\n      this._lifeCycleHooks[event].forEach((hook) => {\n        result = this._chainOrCall(result, () => {\n          return hook(this, subCommand);\n        });\n      });\n    }\n    return result;\n  }\n\n  /**\n   * Process arguments in context of this command.\n   * Returns action result, in case it is a promise.\n   *\n   * @private\n   */\n\n  _parseCommand(operands, unknown) {\n    const parsed = this.parseOptions(unknown);\n    this._parseOptionsEnv(); // after cli, so parseArg not called on both cli and env\n    this._parseOptionsImplied();\n    operands = operands.concat(parsed.operands);\n    unknown = parsed.unknown;\n    this.args = operands.concat(unknown);\n\n    if (operands && this._findCommand(operands[0])) {\n      return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);\n    }\n    if (\n      this._getHelpCommand() &&\n      operands[0] === this._getHelpCommand().name()\n    ) {\n      return this._dispatchHelpCommand(operands[1]);\n    }\n    if (this._defaultCommandName) {\n      this._outputHelpIfRequested(unknown); // Run the help for default command from parent rather than passing to default command\n      return this._dispatchSubcommand(\n        this._defaultCommandName,\n        operands,\n        unknown,\n      );\n    }\n    if (\n      this.commands.length &&\n      this.args.length === 0 &&\n      !this._actionHandler &&\n      !this._defaultCommandName\n    ) {\n      // probably missing subcommand and no handler, user needs help (and exit)\n      this.help({ error: true });\n    }\n\n    this._outputHelpIfRequested(parsed.unknown);\n    this._checkForMissingMandatoryOptions();\n    this._checkForConflictingOptions();\n\n    // We do not always call this check to avoid masking a \"better\" error, like unknown command.\n    const checkForUnknownOptions = () => {\n      if (parsed.unknown.length > 0) {\n        this.unknownOption(parsed.unknown[0]);\n      }\n    };\n\n    const commandEvent = `command:${this.name()}`;\n    if (this._actionHandler) {\n      checkForUnknownOptions();\n      this._processArguments();\n\n      let promiseChain;\n      promiseChain = this._chainOrCallHooks(promiseChain, 'preAction');\n      promiseChain = this._chainOrCall(promiseChain, () =>\n        this._actionHandler(this.processedArgs),\n      );\n      if (this.parent) {\n        promiseChain = this._chainOrCall(promiseChain, () => {\n          this.parent.emit(commandEvent, operands, unknown); // legacy\n        });\n      }\n      promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');\n      return promiseChain;\n    }\n    if (this.parent && this.parent.listenerCount(commandEvent)) {\n      checkForUnknownOptions();\n      this._processArguments();\n      this.parent.emit(commandEvent, operands, unknown); // legacy\n    } else if (operands.length) {\n      if (this._findCommand('*')) {\n        // legacy default command\n        return this._dispatchSubcommand('*', operands, unknown);\n      }\n      if (this.listenerCount('command:*')) {\n        // skip option check, emit event for possible misspelling suggestion\n        this.emit('command:*', operands, unknown);\n      } else if (this.commands.length) {\n        this.unknownCommand();\n      } else {\n        checkForUnknownOptions();\n        this._processArguments();\n      }\n    } else if (this.commands.length) {\n      checkForUnknownOptions();\n      // This command has subcommands and nothing hooked up at this level, so display help (and exit).\n      this.help({ error: true });\n    } else {\n      checkForUnknownOptions();\n      this._processArguments();\n      // fall through for caller to handle after calling .parse()\n    }\n  }\n\n  /**\n   * Find matching command.\n   *\n   * @private\n   * @return {Command | undefined}\n   */\n  _findCommand(name) {\n    if (!name) return undefined;\n    return this.commands.find(\n      (cmd) => cmd._name === name || cmd._aliases.includes(name),\n    );\n  }\n\n  /**\n   * Return an option matching `arg` if any.\n   *\n   * @param {string} arg\n   * @return {Option}\n   * @package\n   */\n\n  _findOption(arg) {\n    return this.options.find((option) => option.is(arg));\n  }\n\n  /**\n   * Display an error message if a mandatory option does not have a value.\n   * Called after checking for help flags in leaf subcommand.\n   *\n   * @private\n   */\n\n  _checkForMissingMandatoryOptions() {\n    // Walk up hierarchy so can call in subcommand after checking for displaying help.\n    this._getCommandAndAncestors().forEach((cmd) => {\n      cmd.options.forEach((anOption) => {\n        if (\n          anOption.mandatory &&\n          cmd.getOptionValue(anOption.attributeName()) === undefined\n        ) {\n          cmd.missingMandatoryOptionValue(anOption);\n        }\n      });\n    });\n  }\n\n  /**\n   * Display an error message if conflicting options are used together in this.\n   *\n   * @private\n   */\n  _checkForConflictingLocalOptions() {\n    const definedNonDefaultOptions = this.options.filter((option) => {\n      const optionKey = option.attributeName();\n      if (this.getOptionValue(optionKey) === undefined) {\n        return false;\n      }\n      return this.getOptionValueSource(optionKey) !== 'default';\n    });\n\n    const optionsWithConflicting = definedNonDefaultOptions.filter(\n      (option) => option.conflictsWith.length > 0,\n    );\n\n    optionsWithConflicting.forEach((option) => {\n      const conflictingAndDefined = definedNonDefaultOptions.find((defined) =>\n        option.conflictsWith.includes(defined.attributeName()),\n      );\n      if (conflictingAndDefined) {\n        this._conflictingOption(option, conflictingAndDefined);\n      }\n    });\n  }\n\n  /**\n   * Display an error message if conflicting options are used together.\n   * Called after checking for help flags in leaf subcommand.\n   *\n   * @private\n   */\n  _checkForConflictingOptions() {\n    // Walk up hierarchy so can call in subcommand after checking for displaying help.\n    this._getCommandAndAncestors().forEach((cmd) => {\n      cmd._checkForConflictingLocalOptions();\n    });\n  }\n\n  /**\n   * Parse options from `argv` removing known options,\n   * and return argv split into operands and unknown arguments.\n   *\n   * Examples:\n   *\n   *     argv => operands, unknown\n   *     --known kkk op => [op], []\n   *     op --known kkk => [op], []\n   *     sub --unknown uuu op => [sub], [--unknown uuu op]\n   *     sub -- --unknown uuu op => [sub --unknown uuu op], []\n   *\n   * @param {string[]} argv\n   * @return {{operands: string[], unknown: string[]}}\n   */\n\n  parseOptions(argv) {\n    const operands = []; // operands, not options or values\n    const unknown = []; // first unknown option and remaining unknown args\n    let dest = operands;\n    const args = argv.slice();\n\n    function maybeOption(arg) {\n      return arg.length > 1 && arg[0] === '-';\n    }\n\n    // parse options\n    let activeVariadicOption = null;\n    while (args.length) {\n      const arg = args.shift();\n\n      // literal\n      if (arg === '--') {\n        if (dest === unknown) dest.push(arg);\n        dest.push(...args);\n        break;\n      }\n\n      if (activeVariadicOption && !maybeOption(arg)) {\n        this.emit(`option:${activeVariadicOption.name()}`, arg);\n        continue;\n      }\n      activeVariadicOption = null;\n\n      if (maybeOption(arg)) {\n        const option = this._findOption(arg);\n        // recognised option, call listener to assign value with possible custom processing\n        if (option) {\n          if (option.required) {\n            const value = args.shift();\n            if (value === undefined) this.optionMissingArgument(option);\n            this.emit(`option:${option.name()}`, value);\n          } else if (option.optional) {\n            let value = null;\n            // historical behaviour is optional value is following arg unless an option\n            if (args.length > 0 && !maybeOption(args[0])) {\n              value = args.shift();\n            }\n            this.emit(`option:${option.name()}`, value);\n          } else {\n            // boolean flag\n            this.emit(`option:${option.name()}`);\n          }\n          activeVariadicOption = option.variadic ? option : null;\n          continue;\n        }\n      }\n\n      // Look for combo options following single dash, eat first one if known.\n      if (arg.length > 2 && arg[0] === '-' && arg[1] !== '-') {\n        const option = this._findOption(`-${arg[1]}`);\n        if (option) {\n          if (\n            option.required ||\n            (option.optional && this._combineFlagAndOptionalValue)\n          ) {\n            // option with value following in same argument\n            this.emit(`option:${option.name()}`, arg.slice(2));\n          } else {\n            // boolean option, emit and put back remainder of arg for further processing\n            this.emit(`option:${option.name()}`);\n            args.unshift(`-${arg.slice(2)}`);\n          }\n          continue;\n        }\n      }\n\n      // Look for known long flag with value, like --foo=bar\n      if (/^--[^=]+=/.test(arg)) {\n        const index = arg.indexOf('=');\n        const option = this._findOption(arg.slice(0, index));\n        if (option && (option.required || option.optional)) {\n          this.emit(`option:${option.name()}`, arg.slice(index + 1));\n          continue;\n        }\n      }\n\n      // Not a recognised option by this command.\n      // Might be a command-argument, or subcommand option, or unknown option, or help command or option.\n\n      // An unknown option means further arguments also classified as unknown so can be reprocessed by subcommands.\n      if (maybeOption(arg)) {\n        dest = unknown;\n      }\n\n      // If using positionalOptions, stop processing our options at subcommand.\n      if (\n        (this._enablePositionalOptions || this._passThroughOptions) &&\n        operands.length === 0 &&\n        unknown.length === 0\n      ) {\n        if (this._findCommand(arg)) {\n          operands.push(arg);\n          if (args.length > 0) unknown.push(...args);\n          break;\n        } else if (\n          this._getHelpCommand() &&\n          arg === this._getHelpCommand().name()\n        ) {\n          operands.push(arg);\n          if (args.length > 0) operands.push(...args);\n          break;\n        } else if (this._defaultCommandName) {\n          unknown.push(arg);\n          if (args.length > 0) unknown.push(...args);\n          break;\n        }\n      }\n\n      // If using passThroughOptions, stop processing options at first command-argument.\n      if (this._passThroughOptions) {\n        dest.push(arg);\n        if (args.length > 0) dest.push(...args);\n        break;\n      }\n\n      // add arg\n      dest.push(arg);\n    }\n\n    return { operands, unknown };\n  }\n\n  /**\n   * Return an object containing local option values as key-value pairs.\n   *\n   * @return {object}\n   */\n  opts() {\n    if (this._storeOptionsAsProperties) {\n      // Preserve original behaviour so backwards compatible when still using properties\n      const result = {};\n      const len = this.options.length;\n\n      for (let i = 0; i < len; i++) {\n        const key = this.options[i].attributeName();\n        result[key] =\n          key === this._versionOptionName ? this._version : this[key];\n      }\n      return result;\n    }\n\n    return this._optionValues;\n  }\n\n  /**\n   * Return an object containing merged local and global option values as key-value pairs.\n   *\n   * @return {object}\n   */\n  optsWithGlobals() {\n    // globals overwrite locals\n    return this._getCommandAndAncestors().reduce(\n      (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),\n      {},\n    );\n  }\n\n  /**\n   * Display error message and exit (or call exitOverride).\n   *\n   * @param {string} message\n   * @param {object} [errorOptions]\n   * @param {string} [errorOptions.code] - an id string representing the error\n   * @param {number} [errorOptions.exitCode] - used with process.exit\n   */\n  error(message, errorOptions) {\n    // output handling\n    this._outputConfiguration.outputError(\n      `${message}\\n`,\n      this._outputConfiguration.writeErr,\n    );\n    if (typeof this._showHelpAfterError === 'string') {\n      this._outputConfiguration.writeErr(`${this._showHelpAfterError}\\n`);\n    } else if (this._showHelpAfterError) {\n      this._outputConfiguration.writeErr('\\n');\n      this.outputHelp({ error: true });\n    }\n\n    // exit handling\n    const config = errorOptions || {};\n    const exitCode = config.exitCode || 1;\n    const code = config.code || 'commander.error';\n    this._exit(exitCode, code, message);\n  }\n\n  /**\n   * Apply any option related environment variables, if option does\n   * not have a value from cli or client code.\n   *\n   * @private\n   */\n  _parseOptionsEnv() {\n    this.options.forEach((option) => {\n      if (option.envVar && option.envVar in process.env) {\n        const optionKey = option.attributeName();\n        // Priority check. Do not overwrite cli or options from unknown source (client-code).\n        if (\n          this.getOptionValue(optionKey) === undefined ||\n          ['default', 'config', 'env'].includes(\n            this.getOptionValueSource(optionKey),\n          )\n        ) {\n          if (option.required || option.optional) {\n            // option can take a value\n            // keep very simple, optional always takes value\n            this.emit(`optionEnv:${option.name()}`, process.env[option.envVar]);\n          } else {\n            // boolean\n            // keep very simple, only care that envVar defined and not the value\n            this.emit(`optionEnv:${option.name()}`);\n          }\n        }\n      }\n    });\n  }\n\n  /**\n   * Apply any implied option values, if option is undefined or default value.\n   *\n   * @private\n   */\n  _parseOptionsImplied() {\n    const dualHelper = new DualOptions(this.options);\n    const hasCustomOptionValue = (optionKey) => {\n      return (\n        this.getOptionValue(optionKey) !== undefined &&\n        !['default', 'implied'].includes(this.getOptionValueSource(optionKey))\n      );\n    };\n    this.options\n      .filter(\n        (option) =>\n          option.implied !== undefined &&\n          hasCustomOptionValue(option.attributeName()) &&\n          dualHelper.valueFromOption(\n            this.getOptionValue(option.attributeName()),\n            option,\n          ),\n      )\n      .forEach((option) => {\n        Object.keys(option.implied)\n          .filter((impliedKey) => !hasCustomOptionValue(impliedKey))\n          .forEach((impliedKey) => {\n            this.setOptionValueWithSource(\n              impliedKey,\n              option.implied[impliedKey],\n              'implied',\n            );\n          });\n      });\n  }\n\n  /**\n   * Argument `name` is missing.\n   *\n   * @param {string} name\n   * @private\n   */\n\n  missingArgument(name) {\n    const message = `error: missing required argument '${name}'`;\n    this.error(message, { code: 'commander.missingArgument' });\n  }\n\n  /**\n   * `Option` is missing an argument.\n   *\n   * @param {Option} option\n   * @private\n   */\n\n  optionMissingArgument(option) {\n    const message = `error: option '${option.flags}' argument missing`;\n    this.error(message, { code: 'commander.optionMissingArgument' });\n  }\n\n  /**\n   * `Option` does not have a value, and is a mandatory option.\n   *\n   * @param {Option} option\n   * @private\n   */\n\n  missingMandatoryOptionValue(option) {\n    const message = `error: required option '${option.flags}' not specified`;\n    this.error(message, { code: 'commander.missingMandatoryOptionValue' });\n  }\n\n  /**\n   * `Option` conflicts with another option.\n   *\n   * @param {Option} option\n   * @param {Option} conflictingOption\n   * @private\n   */\n  _conflictingOption(option, conflictingOption) {\n    // The calling code does not know whether a negated option is the source of the\n    // value, so do some work to take an educated guess.\n    const findBestOptionFromValue = (option) => {\n      const optionKey = option.attributeName();\n      const optionValue = this.getOptionValue(optionKey);\n      const negativeOption = this.options.find(\n        (target) => target.negate && optionKey === target.attributeName(),\n      );\n      const positiveOption = this.options.find(\n        (target) => !target.negate && optionKey === target.attributeName(),\n      );\n      if (\n        negativeOption &&\n        ((negativeOption.presetArg === undefined && optionValue === false) ||\n          (negativeOption.presetArg !== undefined &&\n            optionValue === negativeOption.presetArg))\n      ) {\n        return negativeOption;\n      }\n      return positiveOption || option;\n    };\n\n    const getErrorMessage = (option) => {\n      const bestOption = findBestOptionFromValue(option);\n      const optionKey = bestOption.attributeName();\n      const source = this.getOptionValueSource(optionKey);\n      if (source === 'env') {\n        return `environment variable '${bestOption.envVar}'`;\n      }\n      return `option '${bestOption.flags}'`;\n    };\n\n    const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;\n    this.error(message, { code: 'commander.conflictingOption' });\n  }\n\n  /**\n   * Unknown option `flag`.\n   *\n   * @param {string} flag\n   * @private\n   */\n\n  unknownOption(flag) {\n    if (this._allowUnknownOption) return;\n    let suggestion = '';\n\n    if (flag.startsWith('--') && this._showSuggestionAfterError) {\n      // Looping to pick up the global options too\n      let candidateFlags = [];\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      let command = this;\n      do {\n        const moreFlags = command\n          .createHelp()\n          .visibleOptions(command)\n          .filter((option) => option.long)\n          .map((option) => option.long);\n        candidateFlags = candidateFlags.concat(moreFlags);\n        command = command.parent;\n      } while (command && !command._enablePositionalOptions);\n      suggestion = suggestSimilar(flag, candidateFlags);\n    }\n\n    const message = `error: unknown option '${flag}'${suggestion}`;\n    this.error(message, { code: 'commander.unknownOption' });\n  }\n\n  /**\n   * Excess arguments, more than expected.\n   *\n   * @param {string[]} receivedArgs\n   * @private\n   */\n\n  _excessArguments(receivedArgs) {\n    if (this._allowExcessArguments) return;\n\n    const expected = this.registeredArguments.length;\n    const s = expected === 1 ? '' : 's';\n    const forSubcommand = this.parent ? ` for '${this.name()}'` : '';\n    const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;\n    this.error(message, { code: 'commander.excessArguments' });\n  }\n\n  /**\n   * Unknown command.\n   *\n   * @private\n   */\n\n  unknownCommand() {\n    const unknownName = this.args[0];\n    let suggestion = '';\n\n    if (this._showSuggestionAfterError) {\n      const candidateNames = [];\n      this.createHelp()\n        .visibleCommands(this)\n        .forEach((command) => {\n          candidateNames.push(command.name());\n          // just visible alias\n          if (command.alias()) candidateNames.push(command.alias());\n        });\n      suggestion = suggestSimilar(unknownName, candidateNames);\n    }\n\n    const message = `error: unknown command '${unknownName}'${suggestion}`;\n    this.error(message, { code: 'commander.unknownCommand' });\n  }\n\n  /**\n   * Get or set the program version.\n   *\n   * This method auto-registers the \"-V, --version\" option which will print the version number.\n   *\n   * You can optionally supply the flags and description to override the defaults.\n   *\n   * @param {string} [str]\n   * @param {string} [flags]\n   * @param {string} [description]\n   * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments\n   */\n\n  version(str, flags, description) {\n    if (str === undefined) return this._version;\n    this._version = str;\n    flags = flags || '-V, --version';\n    description = description || 'output the version number';\n    const versionOption = this.createOption(flags, description);\n    this._versionOptionName = versionOption.attributeName();\n    this._registerOption(versionOption);\n\n    this.on('option:' + versionOption.name(), () => {\n      this._outputConfiguration.writeOut(`${str}\\n`);\n      this._exit(0, 'commander.version', str);\n    });\n    return this;\n  }\n\n  /**\n   * Set the description.\n   *\n   * @param {string} [str]\n   * @param {object} [argsDescription]\n   * @return {(string|Command)}\n   */\n  description(str, argsDescription) {\n    if (str === undefined && argsDescription === undefined)\n      return this._description;\n    this._description = str;\n    if (argsDescription) {\n      this._argsDescription = argsDescription;\n    }\n    return this;\n  }\n\n  /**\n   * Set the summary. Used when listed as subcommand of parent.\n   *\n   * @param {string} [str]\n   * @return {(string|Command)}\n   */\n  summary(str) {\n    if (str === undefined) return this._summary;\n    this._summary = str;\n    return this;\n  }\n\n  /**\n   * Set an alias for the command.\n   *\n   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.\n   *\n   * @param {string} [alias]\n   * @return {(string|Command)}\n   */\n\n  alias(alias) {\n    if (alias === undefined) return this._aliases[0]; // just return first, for backwards compatibility\n\n    /** @type {Command} */\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let command = this;\n    if (\n      this.commands.length !== 0 &&\n      this.commands[this.commands.length - 1]._executableHandler\n    ) {\n      // assume adding alias for last added executable subcommand, rather than this\n      command = this.commands[this.commands.length - 1];\n    }\n\n    if (alias === command._name)\n      throw new Error(\"Command alias can't be the same as its name\");\n    const matchingCommand = this.parent?._findCommand(alias);\n    if (matchingCommand) {\n      // c.f. _registerCommand\n      const existingCmd = [matchingCommand.name()]\n        .concat(matchingCommand.aliases())\n        .join('|');\n      throw new Error(\n        `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`,\n      );\n    }\n\n    command._aliases.push(alias);\n    return this;\n  }\n\n  /**\n   * Set aliases for the command.\n   *\n   * Only the first alias is shown in the auto-generated help.\n   *\n   * @param {string[]} [aliases]\n   * @return {(string[]|Command)}\n   */\n\n  aliases(aliases) {\n    // Getter for the array of aliases is the main reason for having aliases() in addition to alias().\n    if (aliases === undefined) return this._aliases;\n\n    aliases.forEach((alias) => this.alias(alias));\n    return this;\n  }\n\n  /**\n   * Set / get the command usage `str`.\n   *\n   * @param {string} [str]\n   * @return {(string|Command)}\n   */\n\n  usage(str) {\n    if (str === undefined) {\n      if (this._usage) return this._usage;\n\n      const args = this.registeredArguments.map((arg) => {\n        return humanReadableArgName(arg);\n      });\n      return []\n        .concat(\n          this.options.length || this._helpOption !== null ? '[options]' : [],\n          this.commands.length ? '[command]' : [],\n          this.registeredArguments.length ? args : [],\n        )\n        .join(' ');\n    }\n\n    this._usage = str;\n    return this;\n  }\n\n  /**\n   * Get or set the name of the command.\n   *\n   * @param {string} [str]\n   * @return {(string|Command)}\n   */\n\n  name(str) {\n    if (str === undefined) return this._name;\n    this._name = str;\n    return this;\n  }\n\n  /**\n   * Set the name of the command from script filename, such as process.argv[1],\n   * or require.main.filename, or __filename.\n   *\n   * (Used internally and public although not documented in README.)\n   *\n   * @example\n   * program.nameFromFilename(require.main.filename);\n   *\n   * @param {string} filename\n   * @return {Command}\n   */\n\n  nameFromFilename(filename) {\n    this._name = path.basename(filename, path.extname(filename));\n\n    return this;\n  }\n\n  /**\n   * Get or set the directory for searching for executable subcommands of this command.\n   *\n   * @example\n   * program.executableDir(__dirname);\n   * // or\n   * program.executableDir('subcommands');\n   *\n   * @param {string} [path]\n   * @return {(string|null|Command)}\n   */\n\n  executableDir(path) {\n    if (path === undefined) return this._executableDir;\n    this._executableDir = path;\n    return this;\n  }\n\n  /**\n   * Return program help documentation.\n   *\n   * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout\n   * @return {string}\n   */\n\n  helpInformation(contextOptions) {\n    const helper = this.createHelp();\n    if (helper.helpWidth === undefined) {\n      helper.helpWidth =\n        contextOptions && contextOptions.error\n          ? this._outputConfiguration.getErrHelpWidth()\n          : this._outputConfiguration.getOutHelpWidth();\n    }\n    return helper.formatHelp(this, helper);\n  }\n\n  /**\n   * @private\n   */\n\n  _getHelpContext(contextOptions) {\n    contextOptions = contextOptions || {};\n    const context = { error: !!contextOptions.error };\n    let write;\n    if (context.error) {\n      write = (arg) => this._outputConfiguration.writeErr(arg);\n    } else {\n      write = (arg) => this._outputConfiguration.writeOut(arg);\n    }\n    context.write = contextOptions.write || write;\n    context.command = this;\n    return context;\n  }\n\n  /**\n   * Output help information for this command.\n   *\n   * Outputs built-in help, and custom text added using `.addHelpText()`.\n   *\n   * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout\n   */\n\n  outputHelp(contextOptions) {\n    let deprecatedCallback;\n    if (typeof contextOptions === 'function') {\n      deprecatedCallback = contextOptions;\n      contextOptions = undefined;\n    }\n    const context = this._getHelpContext(contextOptions);\n\n    this._getCommandAndAncestors()\n      .reverse()\n      .forEach((command) => command.emit('beforeAllHelp', context));\n    this.emit('beforeHelp', context);\n\n    let helpInformation = this.helpInformation(context);\n    if (deprecatedCallback) {\n      helpInformation = deprecatedCallback(helpInformation);\n      if (\n        typeof helpInformation !== 'string' &&\n        !Buffer.isBuffer(helpInformation)\n      ) {\n        throw new Error('outputHelp callback must return a string or a Buffer');\n      }\n    }\n    context.write(helpInformation);\n\n    if (this._getHelpOption()?.long) {\n      this.emit(this._getHelpOption().long); // deprecated\n    }\n    this.emit('afterHelp', context);\n    this._getCommandAndAncestors().forEach((command) =>\n      command.emit('afterAllHelp', context),\n    );\n  }\n\n  /**\n   * You can pass in flags and a description to customise the built-in help option.\n   * Pass in false to disable the built-in help option.\n   *\n   * @example\n   * program.helpOption('-?, --help' 'show help'); // customise\n   * program.helpOption(false); // disable\n   *\n   * @param {(string | boolean)} flags\n   * @param {string} [description]\n   * @return {Command} `this` command for chaining\n   */\n\n  helpOption(flags, description) {\n    // Support disabling built-in help option.\n    if (typeof flags === 'boolean') {\n      if (flags) {\n        this._helpOption = this._helpOption ?? undefined; // preserve existing option\n      } else {\n        this._helpOption = null; // disable\n      }\n      return this;\n    }\n\n    // Customise flags and description.\n    flags = flags ?? '-h, --help';\n    description = description ?? 'display help for command';\n    this._helpOption = this.createOption(flags, description);\n\n    return this;\n  }\n\n  /**\n   * Lazy create help option.\n   * Returns null if has been disabled with .helpOption(false).\n   *\n   * @returns {(Option | null)} the help option\n   * @package\n   */\n  _getHelpOption() {\n    // Lazy create help option on demand.\n    if (this._helpOption === undefined) {\n      this.helpOption(undefined, undefined);\n    }\n    return this._helpOption;\n  }\n\n  /**\n   * Supply your own option to use for the built-in help option.\n   * This is an alternative to using helpOption() to customise the flags and description etc.\n   *\n   * @param {Option} option\n   * @return {Command} `this` command for chaining\n   */\n  addHelpOption(option) {\n    this._helpOption = option;\n    return this;\n  }\n\n  /**\n   * Output help information and exit.\n   *\n   * Outputs built-in help, and custom text added using `.addHelpText()`.\n   *\n   * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout\n   */\n\n  help(contextOptions) {\n    this.outputHelp(contextOptions);\n    let exitCode = process.exitCode || 0;\n    if (\n      exitCode === 0 &&\n      contextOptions &&\n      typeof contextOptions !== 'function' &&\n      contextOptions.error\n    ) {\n      exitCode = 1;\n    }\n    // message: do not have all displayed text available so only passing placeholder.\n    this._exit(exitCode, 'commander.help', '(outputHelp)');\n  }\n\n  /**\n   * Add additional text to be displayed with the built-in help.\n   *\n   * Position is 'before' or 'after' to affect just this command,\n   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.\n   *\n   * @param {string} position - before or after built-in help\n   * @param {(string | Function)} text - string to add, or a function returning a string\n   * @return {Command} `this` command for chaining\n   */\n  addHelpText(position, text) {\n    const allowedValues = ['beforeAll', 'before', 'after', 'afterAll'];\n    if (!allowedValues.includes(position)) {\n      throw new Error(`Unexpected value for position to addHelpText.\nExpecting one of '${allowedValues.join(\"', '\")}'`);\n    }\n    const helpEvent = `${position}Help`;\n    this.on(helpEvent, (context) => {\n      let helpStr;\n      if (typeof text === 'function') {\n        helpStr = text({ error: context.error, command: context.command });\n      } else {\n        helpStr = text;\n      }\n      // Ignore falsy value when nothing to output.\n      if (helpStr) {\n        context.write(`${helpStr}\\n`);\n      }\n    });\n    return this;\n  }\n\n  /**\n   * Output help information if help flags specified\n   *\n   * @param {Array} args - array of options to search for help flags\n   * @private\n   */\n\n  _outputHelpIfRequested(args) {\n    const helpOption = this._getHelpOption();\n    const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));\n    if (helpRequested) {\n      this.outputHelp();\n      // (Do not have all displayed text available so only passing placeholder.)\n      this._exit(0, 'commander.helpDisplayed', '(outputHelp)');\n    }\n  }\n}\n\n/**\n * Scan arguments and increment port number for inspect calls (to avoid conflicts when spawning new command).\n *\n * @param {string[]} args - array of arguments from node.execArgv\n * @returns {string[]}\n * @private\n */\n\nfunction incrementNodeInspectorPort(args) {\n  // Testing for these options:\n  //  --inspect[=[host:]port]\n  //  --inspect-brk[=[host:]port]\n  //  --inspect-port=[host:]port\n  return args.map((arg) => {\n    if (!arg.startsWith('--inspect')) {\n      return arg;\n    }\n    let debugOption;\n    let debugHost = '127.0.0.1';\n    let debugPort = '9229';\n    let match;\n    if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {\n      // e.g. --inspect\n      debugOption = match[1];\n    } else if (\n      (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null\n    ) {\n      debugOption = match[1];\n      if (/^\\d+$/.test(match[3])) {\n        // e.g. --inspect=1234\n        debugPort = match[3];\n      } else {\n        // e.g. --inspect=localhost\n        debugHost = match[3];\n      }\n    } else if (\n      (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\\d+)$/)) !== null\n    ) {\n      // e.g. --inspect=localhost:1234\n      debugOption = match[1];\n      debugHost = match[3];\n      debugPort = match[4];\n    }\n\n    if (debugOption && debugPort !== '0') {\n      return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;\n    }\n    return arg;\n  });\n}\n\nexports.Command = Command;\n",
    "const { Argument } = require('./lib/argument.js');\nconst { Command } = require('./lib/command.js');\nconst { CommanderError, InvalidArgumentError } = require('./lib/error.js');\nconst { Help } = require('./lib/help.js');\nconst { Option } = require('./lib/option.js');\n\nexports.program = new Command();\n\nexports.createCommand = (name) => new Command(name);\nexports.createOption = (flags, description) => new Option(flags, description);\nexports.createArgument = (name, description) => new Argument(name, description);\n\n/**\n * Expose classes\n */\n\nexports.Command = Command;\nexports.Option = Option;\nexports.Argument = Argument;\nexports.Help = Help;\n\nexports.CommanderError = CommanderError;\nexports.InvalidArgumentError = InvalidArgumentError;\nexports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated\n",
    "'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n",
    "import commander from './index.js';\n\n// wrapper to provide named exports for ESM.\nexport const {\n  program,\n  createCommand,\n  createArgument,\n  createOption,\n  CommanderError,\n  InvalidArgumentError,\n  InvalidOptionArgumentError, // deprecated old name\n  Command,\n  Argument,\n  Option,\n  Help,\n} = commander;\n",
    "import { readdir } from \"node:fs/promises\";\nimport { cpus } from \"node:os\";\nimport { program } from \"commander\";\nimport { parse } from \"jsonc-parser\";\nimport PQueue from \"p-queue\";\n\nconst getDirectories = async (path = \".\") =>\n\t(await readdir(path, { withFileTypes: true }))\n\t\t.filter((x) => x.isDirectory())\n\t\t.filter((x) => !x.name.startsWith(\".\"))\n\t\t.filter((x) => !x.name.includes(\"node_modules\"))\n\t\t.map((x) => `${path}/${x.name}`);\n\nconst getDirectoriesDeep = async (path = \".\", level = 0) => {\n\tif (level === 0) return [path];\n\tconst directories = await getDirectories(path);\n\tlet _level = level - 1;\n\twhile (_level > 0) {\n\t\tfor (const directory of directories) {\n\t\t\tconst p = await getDirectories(directory);\n\t\t\tdirectories.push(...p);\n\t\t}\n\t\t_level--;\n\t}\n\tdirectories.push(path);\n\treturn directories;\n};\n\nexport const command = async () => {\n\tlet cwd: string = program.processedArgs[0];\n\tif (typeof cwd !== \"string\") cwd = \".\";\n\tlet recursive: number = program.opts().recursive;\n\tif (typeof recursive !== \"number\") recursive = 0;\n\tif (recursive > 4) {\n\t\tconsole.error(\"👁️ Recursion level is too high\");\n\t\tprocess.exit(1);\n\t}\n\tconst directories = await getDirectoriesDeep(cwd, recursive);\n\tconst queue = new PQueue({ concurrency: cpus().length });\n\tawait Promise.all(\n\t\tdirectories.map((dir) => queue.add(() => purify(dir).catch(console.error))),\n\t).catch(console.error);\n};\n\nconst purify = async (dir: string) => {\n\tconsole.log(`🚀 Managing files in ${dir}`);\n\tawait managePackagelockjson(dir).catch(console.error);\n\tawait manageYarnlock(dir).catch(console.error);\n\tconst packageJsonExists = await managePackagejson(dir).catch(console.error);\n\tconst tsconfigExists = await manageTsconfig(dir).catch(console.error);\n\tawait manageGitignore(dir, packageJsonExists ?? false).catch(console.error);\n\tif (packageJsonExists) {\n\t\tconsole.log(\"🚀 Updating everything!\");\n\t\tawait Bun.$`timeout 20s bun run --cwd=${dir} upgrade`\n\t\t\t.nothrow()\n\t\t\t.catch(console.error);\n\t}\n\tif (tsconfigExists) {\n\t\tconsole.log(\"🚀 Checking and linting!\");\n\t\tawait Promise.all([\n\t\t\tBun.$`timeout 3s bun run --cwd=${dir} check`.nothrow(),\n\t\t\tBun.$`timeout 3s bun run --cwd=${dir} lint`.nothrow(),\n\t\t]).catch(console.error);\n\t}\n\tconsole.log(\"🎉 Done with all files\");\n};\n\nconst manageYarnlock = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/yarn.lock`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tawait Bun.$`rm -f ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst managePackagelockjson = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/package-lock.json`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tawait Bun.$`rm -f ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst manageGitignore = async (\n\tdir: string,\n\tisBunProject: boolean,\n): Promise<boolean> => {\n\tconst filename = `${dir}/.gitignore`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tconst gitignore = await file.text();\n\tconst lines = gitignore\n\t\t.split(\"\\n\")\n\t\t.map((x) => x.trim())\n\t\t.filter(Boolean);\n\tconst isTooLong = lines.length > 10;\n\tif (isTooLong) console.error(`👁️ ${filename} is too long`);\n\tif (isBunProject) {\n\t\tconst hasNodeModules = lines.includes(\"node_modules\");\n\t\tif (!hasNodeModules) {\n\t\t\tlines.push(\"node_modules\");\n\t\t}\n\t}\n\tawait Bun.write(file, lines.join(\"\\n\"));\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst manageTsconfig = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/tsconfig.json`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tconst tsconfig = parse(await file.text());\n\tif (!tsconfig.compilerOptions) return false;\n\tconst expected = {\n\t\tnoUnusedLocals: true,\n\t\tnoUnusedParameters: true,\n\t\tnoUncheckedIndexedAccess: true,\n\t\tnoFallthroughCasesInSwitch: true,\n\t\tnoEmit: true,\n\t\tstrict: true,\n\t\tskipLibCheck: true,\n\t};\n\tfor (const [key, value] of Object.entries(expected)) {\n\t\tif (tsconfig.compilerOptions[key] === value) continue;\n\t\ttsconfig.compilerOptions[key] = value;\n\t}\n\tawait Bun.write(file, JSON.stringify(tsconfig, null, 2));\n\tawait Bun.$`biome check --write --unsafe ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n\nconst managePackagejson = async (dir: string): Promise<boolean> => {\n\tconst filename = `${dir}/package.json`;\n\tconst file = Bun.file(filename);\n\tif (!(await file.exists())) return false;\n\tconst pkgJson = await file.json();\n\tpkgJson.scripts ??= {};\n\tconst hasDependencies = pkgJson.dependencies || pkgJson.devDependencies;\n\tif (!hasDependencies) return false;\n\tconst expected = {\n\t\tupgrade: \"bun update --latest\",\n\t\tcheck:\n\t\t\t\"deno fmt --use-tabs --quiet; oxlint --fix-dangerously --quiet; biome check --write --unsafe .\",\n\t\tlint: \"tsc\",\n\t\tall: \"bun run upgrade; bun run check; bun run lint\",\n\t};\n\tfor (const [key, value] of Object.entries(expected)) {\n\t\tif (\n\t\t\ttypeof pkgJson.scripts[key] === \"string\" &&\n\t\t\tpkgJson.scripts[key].includes(\"bun\") &&\n\t\t\t(pkgJson.scripts[key].includes(\"--filter\") ||\n\t\t\t\tpkgJson.scripts[key].includes(\"--cwd\"))\n\t\t) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (pkgJson.scripts[key] === value) continue;\n\t\tpkgJson.scripts[key] = value;\n\t}\n\tpkgJson.prettier = undefined;\n\tawait Bun.write(file, JSON.stringify(pkgJson, null, 2));\n\tawait Bun.$`biome check --write --unsafe ${filename}`.nothrow();\n\tconsole.log(`✅ Done with ${filename}`);\n\treturn true;\n};\n",
    "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport function createScanner(text, ignoreTrivia = false) {\n    const len = text.length;\n    let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;\n    function scanHexDigits(count, exact) {\n        let digits = 0;\n        let value = 0;\n        while (digits < count || !exact) {\n            let ch = text.charCodeAt(pos);\n            if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {\n                value = value * 16 + ch - 48 /* CharacterCodes._0 */;\n            }\n            else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {\n                value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;\n            }\n            else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {\n                value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;\n            }\n            else {\n                break;\n            }\n            pos++;\n            digits++;\n        }\n        if (digits < count) {\n            value = -1;\n        }\n        return value;\n    }\n    function setPosition(newPosition) {\n        pos = newPosition;\n        value = '';\n        tokenOffset = 0;\n        token = 16 /* SyntaxKind.Unknown */;\n        scanError = 0 /* ScanError.None */;\n    }\n    function scanNumber() {\n        let start = pos;\n        if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {\n            pos++;\n        }\n        else {\n            pos++;\n            while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n            }\n        }\n        if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {\n            pos++;\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n            }\n            else {\n                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;\n                return text.substring(start, pos);\n            }\n        }\n        let end = pos;\n        if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {\n            pos++;\n            if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {\n                pos++;\n            }\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n                end = pos;\n            }\n            else {\n                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;\n            }\n        }\n        return text.substring(start, end);\n    }\n    function scanString() {\n        let result = '', start = pos;\n        while (true) {\n            if (pos >= len) {\n                result += text.substring(start, pos);\n                scanError = 2 /* ScanError.UnexpectedEndOfString */;\n                break;\n            }\n            const ch = text.charCodeAt(pos);\n            if (ch === 34 /* CharacterCodes.doubleQuote */) {\n                result += text.substring(start, pos);\n                pos++;\n                break;\n            }\n            if (ch === 92 /* CharacterCodes.backslash */) {\n                result += text.substring(start, pos);\n                pos++;\n                if (pos >= len) {\n                    scanError = 2 /* ScanError.UnexpectedEndOfString */;\n                    break;\n                }\n                const ch2 = text.charCodeAt(pos++);\n                switch (ch2) {\n                    case 34 /* CharacterCodes.doubleQuote */:\n                        result += '\\\"';\n                        break;\n                    case 92 /* CharacterCodes.backslash */:\n                        result += '\\\\';\n                        break;\n                    case 47 /* CharacterCodes.slash */:\n                        result += '/';\n                        break;\n                    case 98 /* CharacterCodes.b */:\n                        result += '\\b';\n                        break;\n                    case 102 /* CharacterCodes.f */:\n                        result += '\\f';\n                        break;\n                    case 110 /* CharacterCodes.n */:\n                        result += '\\n';\n                        break;\n                    case 114 /* CharacterCodes.r */:\n                        result += '\\r';\n                        break;\n                    case 116 /* CharacterCodes.t */:\n                        result += '\\t';\n                        break;\n                    case 117 /* CharacterCodes.u */:\n                        const ch3 = scanHexDigits(4, true);\n                        if (ch3 >= 0) {\n                            result += String.fromCharCode(ch3);\n                        }\n                        else {\n                            scanError = 4 /* ScanError.InvalidUnicode */;\n                        }\n                        break;\n                    default:\n                        scanError = 5 /* ScanError.InvalidEscapeCharacter */;\n                }\n                start = pos;\n                continue;\n            }\n            if (ch >= 0 && ch <= 0x1f) {\n                if (isLineBreak(ch)) {\n                    result += text.substring(start, pos);\n                    scanError = 2 /* ScanError.UnexpectedEndOfString */;\n                    break;\n                }\n                else {\n                    scanError = 6 /* ScanError.InvalidCharacter */;\n                    // mark as error but continue with string\n                }\n            }\n            pos++;\n        }\n        return result;\n    }\n    function scanNext() {\n        value = '';\n        scanError = 0 /* ScanError.None */;\n        tokenOffset = pos;\n        lineStartOffset = lineNumber;\n        prevTokenLineStartOffset = tokenLineStartOffset;\n        if (pos >= len) {\n            // at the end\n            tokenOffset = len;\n            return token = 17 /* SyntaxKind.EOF */;\n        }\n        let code = text.charCodeAt(pos);\n        // trivia: whitespace\n        if (isWhiteSpace(code)) {\n            do {\n                pos++;\n                value += String.fromCharCode(code);\n                code = text.charCodeAt(pos);\n            } while (isWhiteSpace(code));\n            return token = 15 /* SyntaxKind.Trivia */;\n        }\n        // trivia: newlines\n        if (isLineBreak(code)) {\n            pos++;\n            value += String.fromCharCode(code);\n            if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {\n                pos++;\n                value += '\\n';\n            }\n            lineNumber++;\n            tokenLineStartOffset = pos;\n            return token = 14 /* SyntaxKind.LineBreakTrivia */;\n        }\n        switch (code) {\n            // tokens: []{}:,\n            case 123 /* CharacterCodes.openBrace */:\n                pos++;\n                return token = 1 /* SyntaxKind.OpenBraceToken */;\n            case 125 /* CharacterCodes.closeBrace */:\n                pos++;\n                return token = 2 /* SyntaxKind.CloseBraceToken */;\n            case 91 /* CharacterCodes.openBracket */:\n                pos++;\n                return token = 3 /* SyntaxKind.OpenBracketToken */;\n            case 93 /* CharacterCodes.closeBracket */:\n                pos++;\n                return token = 4 /* SyntaxKind.CloseBracketToken */;\n            case 58 /* CharacterCodes.colon */:\n                pos++;\n                return token = 6 /* SyntaxKind.ColonToken */;\n            case 44 /* CharacterCodes.comma */:\n                pos++;\n                return token = 5 /* SyntaxKind.CommaToken */;\n            // strings\n            case 34 /* CharacterCodes.doubleQuote */:\n                pos++;\n                value = scanString();\n                return token = 10 /* SyntaxKind.StringLiteral */;\n            // comments\n            case 47 /* CharacterCodes.slash */:\n                const start = pos - 1;\n                // Single-line comment\n                if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {\n                    pos += 2;\n                    while (pos < len) {\n                        if (isLineBreak(text.charCodeAt(pos))) {\n                            break;\n                        }\n                        pos++;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 12 /* SyntaxKind.LineCommentTrivia */;\n                }\n                // Multi-line comment\n                if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {\n                    pos += 2;\n                    const safeLength = len - 1; // For lookahead.\n                    let commentClosed = false;\n                    while (pos < safeLength) {\n                        const ch = text.charCodeAt(pos);\n                        if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {\n                            pos += 2;\n                            commentClosed = true;\n                            break;\n                        }\n                        pos++;\n                        if (isLineBreak(ch)) {\n                            if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {\n                                pos++;\n                            }\n                            lineNumber++;\n                            tokenLineStartOffset = pos;\n                        }\n                    }\n                    if (!commentClosed) {\n                        pos++;\n                        scanError = 1 /* ScanError.UnexpectedEndOfComment */;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 13 /* SyntaxKind.BlockCommentTrivia */;\n                }\n                // just a single slash\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* SyntaxKind.Unknown */;\n            // numbers\n            case 45 /* CharacterCodes.minus */:\n                value += String.fromCharCode(code);\n                pos++;\n                if (pos === len || !isDigit(text.charCodeAt(pos))) {\n                    return token = 16 /* SyntaxKind.Unknown */;\n                }\n            // found a minus, followed by a number so\n            // we fall through to proceed with scanning\n            // numbers\n            case 48 /* CharacterCodes._0 */:\n            case 49 /* CharacterCodes._1 */:\n            case 50 /* CharacterCodes._2 */:\n            case 51 /* CharacterCodes._3 */:\n            case 52 /* CharacterCodes._4 */:\n            case 53 /* CharacterCodes._5 */:\n            case 54 /* CharacterCodes._6 */:\n            case 55 /* CharacterCodes._7 */:\n            case 56 /* CharacterCodes._8 */:\n            case 57 /* CharacterCodes._9 */:\n                value += scanNumber();\n                return token = 11 /* SyntaxKind.NumericLiteral */;\n            // literals and unknown symbols\n            default:\n                // is a literal? Read the full word.\n                while (pos < len && isUnknownContentCharacter(code)) {\n                    pos++;\n                    code = text.charCodeAt(pos);\n                }\n                if (tokenOffset !== pos) {\n                    value = text.substring(tokenOffset, pos);\n                    // keywords: true, false, null\n                    switch (value) {\n                        case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;\n                        case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;\n                        case 'null': return token = 7 /* SyntaxKind.NullKeyword */;\n                    }\n                    return token = 16 /* SyntaxKind.Unknown */;\n                }\n                // some\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* SyntaxKind.Unknown */;\n        }\n    }\n    function isUnknownContentCharacter(code) {\n        if (isWhiteSpace(code) || isLineBreak(code)) {\n            return false;\n        }\n        switch (code) {\n            case 125 /* CharacterCodes.closeBrace */:\n            case 93 /* CharacterCodes.closeBracket */:\n            case 123 /* CharacterCodes.openBrace */:\n            case 91 /* CharacterCodes.openBracket */:\n            case 34 /* CharacterCodes.doubleQuote */:\n            case 58 /* CharacterCodes.colon */:\n            case 44 /* CharacterCodes.comma */:\n            case 47 /* CharacterCodes.slash */:\n                return false;\n        }\n        return true;\n    }\n    function scanNextNonTrivia() {\n        let result;\n        do {\n            result = scanNext();\n        } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);\n        return result;\n    }\n    return {\n        setPosition: setPosition,\n        getPosition: () => pos,\n        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,\n        getToken: () => token,\n        getTokenValue: () => value,\n        getTokenOffset: () => tokenOffset,\n        getTokenLength: () => pos - tokenOffset,\n        getTokenStartLine: () => lineStartOffset,\n        getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,\n        getTokenError: () => scanError,\n    };\n}\nfunction isWhiteSpace(ch) {\n    return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;\n}\nfunction isLineBreak(ch) {\n    return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;\n}\nfunction isDigit(ch) {\n    return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;\n}\nvar CharacterCodes;\n(function (CharacterCodes) {\n    CharacterCodes[CharacterCodes[\"lineFeed\"] = 10] = \"lineFeed\";\n    CharacterCodes[CharacterCodes[\"carriageReturn\"] = 13] = \"carriageReturn\";\n    CharacterCodes[CharacterCodes[\"space\"] = 32] = \"space\";\n    CharacterCodes[CharacterCodes[\"_0\"] = 48] = \"_0\";\n    CharacterCodes[CharacterCodes[\"_1\"] = 49] = \"_1\";\n    CharacterCodes[CharacterCodes[\"_2\"] = 50] = \"_2\";\n    CharacterCodes[CharacterCodes[\"_3\"] = 51] = \"_3\";\n    CharacterCodes[CharacterCodes[\"_4\"] = 52] = \"_4\";\n    CharacterCodes[CharacterCodes[\"_5\"] = 53] = \"_5\";\n    CharacterCodes[CharacterCodes[\"_6\"] = 54] = \"_6\";\n    CharacterCodes[CharacterCodes[\"_7\"] = 55] = \"_7\";\n    CharacterCodes[CharacterCodes[\"_8\"] = 56] = \"_8\";\n    CharacterCodes[CharacterCodes[\"_9\"] = 57] = \"_9\";\n    CharacterCodes[CharacterCodes[\"a\"] = 97] = \"a\";\n    CharacterCodes[CharacterCodes[\"b\"] = 98] = \"b\";\n    CharacterCodes[CharacterCodes[\"c\"] = 99] = \"c\";\n    CharacterCodes[CharacterCodes[\"d\"] = 100] = \"d\";\n    CharacterCodes[CharacterCodes[\"e\"] = 101] = \"e\";\n    CharacterCodes[CharacterCodes[\"f\"] = 102] = \"f\";\n    CharacterCodes[CharacterCodes[\"g\"] = 103] = \"g\";\n    CharacterCodes[CharacterCodes[\"h\"] = 104] = \"h\";\n    CharacterCodes[CharacterCodes[\"i\"] = 105] = \"i\";\n    CharacterCodes[CharacterCodes[\"j\"] = 106] = \"j\";\n    CharacterCodes[CharacterCodes[\"k\"] = 107] = \"k\";\n    CharacterCodes[CharacterCodes[\"l\"] = 108] = \"l\";\n    CharacterCodes[CharacterCodes[\"m\"] = 109] = \"m\";\n    CharacterCodes[CharacterCodes[\"n\"] = 110] = \"n\";\n    CharacterCodes[CharacterCodes[\"o\"] = 111] = \"o\";\n    CharacterCodes[CharacterCodes[\"p\"] = 112] = \"p\";\n    CharacterCodes[CharacterCodes[\"q\"] = 113] = \"q\";\n    CharacterCodes[CharacterCodes[\"r\"] = 114] = \"r\";\n    CharacterCodes[CharacterCodes[\"s\"] = 115] = \"s\";\n    CharacterCodes[CharacterCodes[\"t\"] = 116] = \"t\";\n    CharacterCodes[CharacterCodes[\"u\"] = 117] = \"u\";\n    CharacterCodes[CharacterCodes[\"v\"] = 118] = \"v\";\n    CharacterCodes[CharacterCodes[\"w\"] = 119] = \"w\";\n    CharacterCodes[CharacterCodes[\"x\"] = 120] = \"x\";\n    CharacterCodes[CharacterCodes[\"y\"] = 121] = \"y\";\n    CharacterCodes[CharacterCodes[\"z\"] = 122] = \"z\";\n    CharacterCodes[CharacterCodes[\"A\"] = 65] = \"A\";\n    CharacterCodes[CharacterCodes[\"B\"] = 66] = \"B\";\n    CharacterCodes[CharacterCodes[\"C\"] = 67] = \"C\";\n    CharacterCodes[CharacterCodes[\"D\"] = 68] = \"D\";\n    CharacterCodes[CharacterCodes[\"E\"] = 69] = \"E\";\n    CharacterCodes[CharacterCodes[\"F\"] = 70] = \"F\";\n    CharacterCodes[CharacterCodes[\"G\"] = 71] = \"G\";\n    CharacterCodes[CharacterCodes[\"H\"] = 72] = \"H\";\n    CharacterCodes[CharacterCodes[\"I\"] = 73] = \"I\";\n    CharacterCodes[CharacterCodes[\"J\"] = 74] = \"J\";\n    CharacterCodes[CharacterCodes[\"K\"] = 75] = \"K\";\n    CharacterCodes[CharacterCodes[\"L\"] = 76] = \"L\";\n    CharacterCodes[CharacterCodes[\"M\"] = 77] = \"M\";\n    CharacterCodes[CharacterCodes[\"N\"] = 78] = \"N\";\n    CharacterCodes[CharacterCodes[\"O\"] = 79] = \"O\";\n    CharacterCodes[CharacterCodes[\"P\"] = 80] = \"P\";\n    CharacterCodes[CharacterCodes[\"Q\"] = 81] = \"Q\";\n    CharacterCodes[CharacterCodes[\"R\"] = 82] = \"R\";\n    CharacterCodes[CharacterCodes[\"S\"] = 83] = \"S\";\n    CharacterCodes[CharacterCodes[\"T\"] = 84] = \"T\";\n    CharacterCodes[CharacterCodes[\"U\"] = 85] = \"U\";\n    CharacterCodes[CharacterCodes[\"V\"] = 86] = \"V\";\n    CharacterCodes[CharacterCodes[\"W\"] = 87] = \"W\";\n    CharacterCodes[CharacterCodes[\"X\"] = 88] = \"X\";\n    CharacterCodes[CharacterCodes[\"Y\"] = 89] = \"Y\";\n    CharacterCodes[CharacterCodes[\"Z\"] = 90] = \"Z\";\n    CharacterCodes[CharacterCodes[\"asterisk\"] = 42] = \"asterisk\";\n    CharacterCodes[CharacterCodes[\"backslash\"] = 92] = \"backslash\";\n    CharacterCodes[CharacterCodes[\"closeBrace\"] = 125] = \"closeBrace\";\n    CharacterCodes[CharacterCodes[\"closeBracket\"] = 93] = \"closeBracket\";\n    CharacterCodes[CharacterCodes[\"colon\"] = 58] = \"colon\";\n    CharacterCodes[CharacterCodes[\"comma\"] = 44] = \"comma\";\n    CharacterCodes[CharacterCodes[\"dot\"] = 46] = \"dot\";\n    CharacterCodes[CharacterCodes[\"doubleQuote\"] = 34] = \"doubleQuote\";\n    CharacterCodes[CharacterCodes[\"minus\"] = 45] = \"minus\";\n    CharacterCodes[CharacterCodes[\"openBrace\"] = 123] = \"openBrace\";\n    CharacterCodes[CharacterCodes[\"openBracket\"] = 91] = \"openBracket\";\n    CharacterCodes[CharacterCodes[\"plus\"] = 43] = \"plus\";\n    CharacterCodes[CharacterCodes[\"slash\"] = 47] = \"slash\";\n    CharacterCodes[CharacterCodes[\"formFeed\"] = 12] = \"formFeed\";\n    CharacterCodes[CharacterCodes[\"tab\"] = 9] = \"tab\";\n})(CharacterCodes || (CharacterCodes = {}));\n",
    "export const cachedSpaces = new Array(20).fill(0).map((_, index) => {\n    return ' '.repeat(index);\n});\nconst maxCachedValues = 200;\nexport const cachedBreakLinesWithSpaces = {\n    ' ': {\n        '\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\n' + ' '.repeat(index);\n        }),\n        '\\r': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r' + ' '.repeat(index);\n        }),\n        '\\r\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r\\n' + ' '.repeat(index);\n        }),\n    },\n    '\\t': {\n        '\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\n' + '\\t'.repeat(index);\n        }),\n        '\\r': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r' + '\\t'.repeat(index);\n        }),\n        '\\r\\n': new Array(maxCachedValues).fill(0).map((_, index) => {\n            return '\\r\\n' + '\\t'.repeat(index);\n        }),\n    }\n};\nexport const supportedEols = ['\\n', '\\r', '\\r\\n'];\n",
    "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport { createScanner } from './scanner';\nvar ParseOptions;\n(function (ParseOptions) {\n    ParseOptions.DEFAULT = {\n        allowTrailingComma: false\n    };\n})(ParseOptions || (ParseOptions = {}));\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport function getLocation(text, position) {\n    const segments = []; // strings or numbers\n    const earlyReturnException = new Object();\n    let previousNode = undefined;\n    const previousNodeInst = {\n        value: {},\n        offset: 0,\n        length: 0,\n        type: 'object',\n        parent: undefined\n    };\n    let isAtPropertyKey = false;\n    function setPreviousNode(value, offset, length, type) {\n        previousNodeInst.value = value;\n        previousNodeInst.offset = offset;\n        previousNodeInst.length = length;\n        previousNodeInst.type = type;\n        previousNodeInst.colonOffset = undefined;\n        previousNode = previousNodeInst;\n    }\n    try {\n        visit(text, {\n            onObjectBegin: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                isAtPropertyKey = position > offset;\n                segments.push(''); // push a placeholder (will be replaced)\n            },\n            onObjectProperty: (name, offset, length) => {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(name, offset, length, 'property');\n                segments[segments.length - 1] = name;\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onObjectEnd: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.pop();\n            },\n            onArrayBegin: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.push(0);\n            },\n            onArrayEnd: (offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.pop();\n            },\n            onLiteralValue: (value, offset, length) => {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(value, offset, length, getNodeType(value));\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onSeparator: (sep, offset, length) => {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                if (sep === ':' && previousNode && previousNode.type === 'property') {\n                    previousNode.colonOffset = offset;\n                    isAtPropertyKey = false;\n                    previousNode = undefined;\n                }\n                else if (sep === ',') {\n                    const last = segments[segments.length - 1];\n                    if (typeof last === 'number') {\n                        segments[segments.length - 1] = last + 1;\n                    }\n                    else {\n                        isAtPropertyKey = true;\n                        segments[segments.length - 1] = '';\n                    }\n                    previousNode = undefined;\n                }\n            }\n        });\n    }\n    catch (e) {\n        if (e !== earlyReturnException) {\n            throw e;\n        }\n    }\n    return {\n        path: segments,\n        previousNode,\n        isAtPropertyKey,\n        matches: (pattern) => {\n            let k = 0;\n            for (let i = 0; k < pattern.length && i < segments.length; i++) {\n                if (pattern[k] === segments[i] || pattern[k] === '*') {\n                    k++;\n                }\n                else if (pattern[k] !== '**') {\n                    return false;\n                }\n            }\n            return k === pattern.length;\n        }\n    };\n}\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore always check the errors list to find out if the input was valid.\n */\nexport function parse(text, errors = [], options = ParseOptions.DEFAULT) {\n    let currentProperty = null;\n    let currentParent = [];\n    const previousParents = [];\n    function onValue(value) {\n        if (Array.isArray(currentParent)) {\n            currentParent.push(value);\n        }\n        else if (currentProperty !== null) {\n            currentParent[currentProperty] = value;\n        }\n    }\n    const visitor = {\n        onObjectBegin: () => {\n            const object = {};\n            onValue(object);\n            previousParents.push(currentParent);\n            currentParent = object;\n            currentProperty = null;\n        },\n        onObjectProperty: (name) => {\n            currentProperty = name;\n        },\n        onObjectEnd: () => {\n            currentParent = previousParents.pop();\n        },\n        onArrayBegin: () => {\n            const array = [];\n            onValue(array);\n            previousParents.push(currentParent);\n            currentParent = array;\n            currentProperty = null;\n        },\n        onArrayEnd: () => {\n            currentParent = previousParents.pop();\n        },\n        onLiteralValue: onValue,\n        onError: (error, offset, length) => {\n            errors.push({ error, offset, length });\n        }\n    };\n    visit(text, visitor, options);\n    return currentParent[0];\n}\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {\n    let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root\n    function ensurePropertyComplete(endOffset) {\n        if (currentParent.type === 'property') {\n            currentParent.length = endOffset - currentParent.offset;\n            currentParent = currentParent.parent;\n        }\n    }\n    function onValue(valueNode) {\n        currentParent.children.push(valueNode);\n        return valueNode;\n    }\n    const visitor = {\n        onObjectBegin: (offset) => {\n            currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });\n        },\n        onObjectProperty: (name, offset, length) => {\n            currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });\n            currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });\n        },\n        onObjectEnd: (offset, length) => {\n            ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onArrayBegin: (offset, length) => {\n            currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });\n        },\n        onArrayEnd: (offset, length) => {\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onLiteralValue: (value, offset, length) => {\n            onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });\n            ensurePropertyComplete(offset + length);\n        },\n        onSeparator: (sep, offset, length) => {\n            if (currentParent.type === 'property') {\n                if (sep === ':') {\n                    currentParent.colonOffset = offset;\n                }\n                else if (sep === ',') {\n                    ensurePropertyComplete(offset);\n                }\n            }\n        },\n        onError: (error, offset, length) => {\n            errors.push({ error, offset, length });\n        }\n    };\n    visit(text, visitor, options);\n    const result = currentParent.children[0];\n    if (result) {\n        delete result.parent;\n    }\n    return result;\n}\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport function findNodeAtLocation(root, path) {\n    if (!root) {\n        return undefined;\n    }\n    let node = root;\n    for (let segment of path) {\n        if (typeof segment === 'string') {\n            if (node.type !== 'object' || !Array.isArray(node.children)) {\n                return undefined;\n            }\n            let found = false;\n            for (const propertyNode of node.children) {\n                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {\n                    node = propertyNode.children[1];\n                    found = true;\n                    break;\n                }\n            }\n            if (!found) {\n                return undefined;\n            }\n        }\n        else {\n            const index = segment;\n            if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {\n                return undefined;\n            }\n            node = node.children[index];\n        }\n    }\n    return node;\n}\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport function getNodePath(node) {\n    if (!node.parent || !node.parent.children) {\n        return [];\n    }\n    const path = getNodePath(node.parent);\n    if (node.parent.type === 'property') {\n        const key = node.parent.children[0].value;\n        path.push(key);\n    }\n    else if (node.parent.type === 'array') {\n        const index = node.parent.children.indexOf(node);\n        if (index !== -1) {\n            path.push(index);\n        }\n    }\n    return path;\n}\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport function getNodeValue(node) {\n    switch (node.type) {\n        case 'array':\n            return node.children.map(getNodeValue);\n        case 'object':\n            const obj = Object.create(null);\n            for (let prop of node.children) {\n                const valueNode = prop.children[1];\n                if (valueNode) {\n                    obj[prop.children[0].value] = getNodeValue(valueNode);\n                }\n            }\n            return obj;\n        case 'null':\n        case 'string':\n        case 'number':\n        case 'boolean':\n            return node.value;\n        default:\n            return undefined;\n    }\n}\nexport function contains(node, offset, includeRightBound = false) {\n    return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));\n}\n/**\n * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport function findNodeAtOffset(node, offset, includeRightBound = false) {\n    if (contains(node, offset, includeRightBound)) {\n        const children = node.children;\n        if (Array.isArray(children)) {\n            for (let i = 0; i < children.length && children[i].offset <= offset; i++) {\n                const item = findNodeAtOffset(children[i], offset, includeRightBound);\n                if (item) {\n                    return item;\n                }\n            }\n        }\n        return node;\n    }\n    return undefined;\n}\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport function visit(text, visitor, options = ParseOptions.DEFAULT) {\n    const _scanner = createScanner(text, false);\n    // Important: Only pass copies of this to visitor functions to prevent accidental modification, and\n    // to not affect visitor functions which stored a reference to a previous JSONPath\n    const _jsonPath = [];\n    // Depth of onXXXBegin() callbacks suppressed. onXXXEnd() decrements this if it isn't 0 already.\n    // Callbacks are only called when this value is 0.\n    let suppressedCallbacks = 0;\n    function toNoArgVisit(visitFunction) {\n        return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;\n    }\n    function toOneArgVisit(visitFunction) {\n        return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;\n    }\n    function toOneArgVisitWithPath(visitFunction) {\n        return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;\n    }\n    function toBeginVisit(visitFunction) {\n        return visitFunction ?\n            () => {\n                if (suppressedCallbacks > 0) {\n                    suppressedCallbacks++;\n                }\n                else {\n                    let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());\n                    if (cbReturn === false) {\n                        suppressedCallbacks = 1;\n                    }\n                }\n            }\n            : () => true;\n    }\n    function toEndVisit(visitFunction) {\n        return visitFunction ?\n            () => {\n                if (suppressedCallbacks > 0) {\n                    suppressedCallbacks--;\n                }\n                if (suppressedCallbacks === 0) {\n                    visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());\n                }\n            }\n            : () => true;\n    }\n    const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);\n    const disallowComments = options && options.disallowComments;\n    const allowTrailingComma = options && options.allowTrailingComma;\n    function scanNext() {\n        while (true) {\n            const token = _scanner.scan();\n            switch (_scanner.getTokenError()) {\n                case 4 /* ScanError.InvalidUnicode */:\n                    handleError(14 /* ParseErrorCode.InvalidUnicode */);\n                    break;\n                case 5 /* ScanError.InvalidEscapeCharacter */:\n                    handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);\n                    break;\n                case 3 /* ScanError.UnexpectedEndOfNumber */:\n                    handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);\n                    break;\n                case 1 /* ScanError.UnexpectedEndOfComment */:\n                    if (!disallowComments) {\n                        handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);\n                    }\n                    break;\n                case 2 /* ScanError.UnexpectedEndOfString */:\n                    handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);\n                    break;\n                case 6 /* ScanError.InvalidCharacter */:\n                    handleError(16 /* ParseErrorCode.InvalidCharacter */);\n                    break;\n            }\n            switch (token) {\n                case 12 /* SyntaxKind.LineCommentTrivia */:\n                case 13 /* SyntaxKind.BlockCommentTrivia */:\n                    if (disallowComments) {\n                        handleError(10 /* ParseErrorCode.InvalidCommentToken */);\n                    }\n                    else {\n                        onComment();\n                    }\n                    break;\n                case 16 /* SyntaxKind.Unknown */:\n                    handleError(1 /* ParseErrorCode.InvalidSymbol */);\n                    break;\n                case 15 /* SyntaxKind.Trivia */:\n                case 14 /* SyntaxKind.LineBreakTrivia */:\n                    break;\n                default:\n                    return token;\n            }\n        }\n    }\n    function handleError(error, skipUntilAfter = [], skipUntil = []) {\n        onError(error);\n        if (skipUntilAfter.length + skipUntil.length > 0) {\n            let token = _scanner.getToken();\n            while (token !== 17 /* SyntaxKind.EOF */) {\n                if (skipUntilAfter.indexOf(token) !== -1) {\n                    scanNext();\n                    break;\n                }\n                else if (skipUntil.indexOf(token) !== -1) {\n                    break;\n                }\n                token = scanNext();\n            }\n        }\n    }\n    function parseString(isValue) {\n        const value = _scanner.getTokenValue();\n        if (isValue) {\n            onLiteralValue(value);\n        }\n        else {\n            onObjectProperty(value);\n            // add property name afterwards\n            _jsonPath.push(value);\n        }\n        scanNext();\n        return true;\n    }\n    function parseLiteral() {\n        switch (_scanner.getToken()) {\n            case 11 /* SyntaxKind.NumericLiteral */:\n                const tokenValue = _scanner.getTokenValue();\n                let value = Number(tokenValue);\n                if (isNaN(value)) {\n                    handleError(2 /* ParseErrorCode.InvalidNumberFormat */);\n                    value = 0;\n                }\n                onLiteralValue(value);\n                break;\n            case 7 /* SyntaxKind.NullKeyword */:\n                onLiteralValue(null);\n                break;\n            case 8 /* SyntaxKind.TrueKeyword */:\n                onLiteralValue(true);\n                break;\n            case 9 /* SyntaxKind.FalseKeyword */:\n                onLiteralValue(false);\n                break;\n            default:\n                return false;\n        }\n        scanNext();\n        return true;\n    }\n    function parseProperty() {\n        if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {\n            handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n            return false;\n        }\n        parseString(false);\n        if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {\n            onSeparator(':');\n            scanNext(); // consume colon\n            if (!parseValue()) {\n                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n            }\n        }\n        else {\n            handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n        }\n        _jsonPath.pop(); // remove processed property name\n        return true;\n    }\n    function parseObject() {\n        onObjectBegin();\n        scanNext(); // consume open brace\n        let needsComma = false;\n        while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {\n            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);\n            }\n            if (!parseProperty()) {\n                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onObjectEnd();\n        if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {\n            handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);\n        }\n        else {\n            scanNext(); // consume close brace\n        }\n        return true;\n    }\n    function parseArray() {\n        onArrayBegin();\n        scanNext(); // consume open bracket\n        let isFirstElement = true;\n        let needsComma = false;\n        while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {\n            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);\n            }\n            if (isFirstElement) {\n                _jsonPath.push(0);\n                isFirstElement = false;\n            }\n            else {\n                _jsonPath[_jsonPath.length - 1]++;\n            }\n            if (!parseValue()) {\n                handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onArrayEnd();\n        if (!isFirstElement) {\n            _jsonPath.pop(); // remove array index\n        }\n        if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {\n            handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);\n        }\n        else {\n            scanNext(); // consume close bracket\n        }\n        return true;\n    }\n    function parseValue() {\n        switch (_scanner.getToken()) {\n            case 3 /* SyntaxKind.OpenBracketToken */:\n                return parseArray();\n            case 1 /* SyntaxKind.OpenBraceToken */:\n                return parseObject();\n            case 10 /* SyntaxKind.StringLiteral */:\n                return parseString(true);\n            default:\n                return parseLiteral();\n        }\n    }\n    scanNext();\n    if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {\n        if (options.allowEmptyContent) {\n            return true;\n        }\n        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n        return false;\n    }\n    if (!parseValue()) {\n        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);\n        return false;\n    }\n    if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {\n        handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);\n    }\n    return true;\n}\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport function stripComments(text, replaceCh) {\n    let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;\n    do {\n        pos = _scanner.getPosition();\n        kind = _scanner.scan();\n        switch (kind) {\n            case 12 /* SyntaxKind.LineCommentTrivia */:\n            case 13 /* SyntaxKind.BlockCommentTrivia */:\n            case 17 /* SyntaxKind.EOF */:\n                if (offset !== pos) {\n                    parts.push(text.substring(offset, pos));\n                }\n                if (replaceCh !== undefined) {\n                    parts.push(_scanner.getTokenValue().replace(/[^\\r\\n]/g, replaceCh));\n                }\n                offset = _scanner.getPosition();\n                break;\n        }\n    } while (kind !== 17 /* SyntaxKind.EOF */);\n    return parts.join('');\n}\nexport function getNodeType(value) {\n    switch (typeof value) {\n        case 'boolean': return 'boolean';\n        case 'number': return 'number';\n        case 'string': return 'string';\n        case 'object': {\n            if (!value) {\n                return 'null';\n            }\n            else if (Array.isArray(value)) {\n                return 'array';\n            }\n            return 'object';\n        }\n        default: return 'null';\n    }\n}\n",
    "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport * as formatter from './impl/format';\nimport * as edit from './impl/edit';\nimport * as scanner from './impl/scanner';\nimport * as parser from './impl/parser';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport const createScanner = scanner.createScanner;\nexport var ScanError;\n(function (ScanError) {\n    ScanError[ScanError[\"None\"] = 0] = \"None\";\n    ScanError[ScanError[\"UnexpectedEndOfComment\"] = 1] = \"UnexpectedEndOfComment\";\n    ScanError[ScanError[\"UnexpectedEndOfString\"] = 2] = \"UnexpectedEndOfString\";\n    ScanError[ScanError[\"UnexpectedEndOfNumber\"] = 3] = \"UnexpectedEndOfNumber\";\n    ScanError[ScanError[\"InvalidUnicode\"] = 4] = \"InvalidUnicode\";\n    ScanError[ScanError[\"InvalidEscapeCharacter\"] = 5] = \"InvalidEscapeCharacter\";\n    ScanError[ScanError[\"InvalidCharacter\"] = 6] = \"InvalidCharacter\";\n})(ScanError || (ScanError = {}));\nexport var SyntaxKind;\n(function (SyntaxKind) {\n    SyntaxKind[SyntaxKind[\"OpenBraceToken\"] = 1] = \"OpenBraceToken\";\n    SyntaxKind[SyntaxKind[\"CloseBraceToken\"] = 2] = \"CloseBraceToken\";\n    SyntaxKind[SyntaxKind[\"OpenBracketToken\"] = 3] = \"OpenBracketToken\";\n    SyntaxKind[SyntaxKind[\"CloseBracketToken\"] = 4] = \"CloseBracketToken\";\n    SyntaxKind[SyntaxKind[\"CommaToken\"] = 5] = \"CommaToken\";\n    SyntaxKind[SyntaxKind[\"ColonToken\"] = 6] = \"ColonToken\";\n    SyntaxKind[SyntaxKind[\"NullKeyword\"] = 7] = \"NullKeyword\";\n    SyntaxKind[SyntaxKind[\"TrueKeyword\"] = 8] = \"TrueKeyword\";\n    SyntaxKind[SyntaxKind[\"FalseKeyword\"] = 9] = \"FalseKeyword\";\n    SyntaxKind[SyntaxKind[\"StringLiteral\"] = 10] = \"StringLiteral\";\n    SyntaxKind[SyntaxKind[\"NumericLiteral\"] = 11] = \"NumericLiteral\";\n    SyntaxKind[SyntaxKind[\"LineCommentTrivia\"] = 12] = \"LineCommentTrivia\";\n    SyntaxKind[SyntaxKind[\"BlockCommentTrivia\"] = 13] = \"BlockCommentTrivia\";\n    SyntaxKind[SyntaxKind[\"LineBreakTrivia\"] = 14] = \"LineBreakTrivia\";\n    SyntaxKind[SyntaxKind[\"Trivia\"] = 15] = \"Trivia\";\n    SyntaxKind[SyntaxKind[\"Unknown\"] = 16] = \"Unknown\";\n    SyntaxKind[SyntaxKind[\"EOF\"] = 17] = \"EOF\";\n})(SyntaxKind || (SyntaxKind = {}));\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport const getLocation = parser.getLocation;\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore, always check the errors list to find out if the input was valid.\n */\nexport const parse = parser.parse;\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport const parseTree = parser.parseTree;\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport const findNodeAtLocation = parser.findNodeAtLocation;\n/**\n * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport const findNodeAtOffset = parser.findNodeAtOffset;\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport const getNodePath = parser.getNodePath;\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport const getNodeValue = parser.getNodeValue;\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport const visit = parser.visit;\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport const stripComments = parser.stripComments;\nexport var ParseErrorCode;\n(function (ParseErrorCode) {\n    ParseErrorCode[ParseErrorCode[\"InvalidSymbol\"] = 1] = \"InvalidSymbol\";\n    ParseErrorCode[ParseErrorCode[\"InvalidNumberFormat\"] = 2] = \"InvalidNumberFormat\";\n    ParseErrorCode[ParseErrorCode[\"PropertyNameExpected\"] = 3] = \"PropertyNameExpected\";\n    ParseErrorCode[ParseErrorCode[\"ValueExpected\"] = 4] = \"ValueExpected\";\n    ParseErrorCode[ParseErrorCode[\"ColonExpected\"] = 5] = \"ColonExpected\";\n    ParseErrorCode[ParseErrorCode[\"CommaExpected\"] = 6] = \"CommaExpected\";\n    ParseErrorCode[ParseErrorCode[\"CloseBraceExpected\"] = 7] = \"CloseBraceExpected\";\n    ParseErrorCode[ParseErrorCode[\"CloseBracketExpected\"] = 8] = \"CloseBracketExpected\";\n    ParseErrorCode[ParseErrorCode[\"EndOfFileExpected\"] = 9] = \"EndOfFileExpected\";\n    ParseErrorCode[ParseErrorCode[\"InvalidCommentToken\"] = 10] = \"InvalidCommentToken\";\n    ParseErrorCode[ParseErrorCode[\"UnexpectedEndOfComment\"] = 11] = \"UnexpectedEndOfComment\";\n    ParseErrorCode[ParseErrorCode[\"UnexpectedEndOfString\"] = 12] = \"UnexpectedEndOfString\";\n    ParseErrorCode[ParseErrorCode[\"UnexpectedEndOfNumber\"] = 13] = \"UnexpectedEndOfNumber\";\n    ParseErrorCode[ParseErrorCode[\"InvalidUnicode\"] = 14] = \"InvalidUnicode\";\n    ParseErrorCode[ParseErrorCode[\"InvalidEscapeCharacter\"] = 15] = \"InvalidEscapeCharacter\";\n    ParseErrorCode[ParseErrorCode[\"InvalidCharacter\"] = 16] = \"InvalidCharacter\";\n})(ParseErrorCode || (ParseErrorCode = {}));\nexport function printParseErrorCode(code) {\n    switch (code) {\n        case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol';\n        case 2 /* ParseErrorCode.InvalidNumberFormat */: return 'InvalidNumberFormat';\n        case 3 /* ParseErrorCode.PropertyNameExpected */: return 'PropertyNameExpected';\n        case 4 /* ParseErrorCode.ValueExpected */: return 'ValueExpected';\n        case 5 /* ParseErrorCode.ColonExpected */: return 'ColonExpected';\n        case 6 /* ParseErrorCode.CommaExpected */: return 'CommaExpected';\n        case 7 /* ParseErrorCode.CloseBraceExpected */: return 'CloseBraceExpected';\n        case 8 /* ParseErrorCode.CloseBracketExpected */: return 'CloseBracketExpected';\n        case 9 /* ParseErrorCode.EndOfFileExpected */: return 'EndOfFileExpected';\n        case 10 /* ParseErrorCode.InvalidCommentToken */: return 'InvalidCommentToken';\n        case 11 /* ParseErrorCode.UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';\n        case 12 /* ParseErrorCode.UnexpectedEndOfString */: return 'UnexpectedEndOfString';\n        case 13 /* ParseErrorCode.UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';\n        case 14 /* ParseErrorCode.InvalidUnicode */: return 'InvalidUnicode';\n        case 15 /* ParseErrorCode.InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';\n        case 16 /* ParseErrorCode.InvalidCharacter */: return 'InvalidCharacter';\n    }\n    return '<unknown ParseErrorCode>';\n}\n/**\n * Computes the edit operations needed to format a JSON document.\n *\n * @param documentText The input text\n * @param range The range to format or `undefined` to format the full content\n * @param options The formatting options\n * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.\n * To apply the edit operations to the input, use {@linkcode applyEdits}.\n */\nexport function format(documentText, range, options) {\n    return formatter.format(documentText, range, options);\n}\n/**\n * Computes the edit operations needed to modify a value in the JSON document.\n *\n * @param documentText The input text\n * @param path The path of the value to change. The path represents either to the document root, a property or an array item.\n * If the path points to an non-existing property or item, it will be created.\n * @param value The new value for the specified property or item. If the value is undefined,\n * the property or item will be removed.\n * @param options Options\n * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.\n * To apply the edit operations to the input, use {@linkcode applyEdits}.\n */\nexport function modify(text, path, value, options) {\n    return edit.setProperty(text, path, value, options);\n}\n/**\n * Applies edits to an input string.\n * @param text The input text\n * @param edits Edit operations following the format described in {@linkcode EditResult}.\n * @returns The text with the applied edits.\n * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.\n */\nexport function applyEdits(text, edits) {\n    let sortedEdits = edits.slice(0).sort((a, b) => {\n        const diff = a.offset - b.offset;\n        if (diff === 0) {\n            return a.length - b.length;\n        }\n        return diff;\n    });\n    let lastModifiedOffset = text.length;\n    for (let i = sortedEdits.length - 1; i >= 0; i--) {\n        let e = sortedEdits[i];\n        if (e.offset + e.length <= lastModifiedOffset) {\n            text = edit.applyEdit(text, e);\n        }\n        else {\n            throw new Error('Overlapping edit');\n        }\n        lastModifiedOffset = e.offset;\n    }\n    return text;\n}\n",
    "import EventEmitter from './index.js'\n\nexport { EventEmitter }\nexport default EventEmitter\n",
    "export class TimeoutError extends Error {\n\tconstructor(message) {\n\t\tsuper(message);\n\t\tthis.name = 'TimeoutError';\n\t}\n}\n\n/**\nAn error to be thrown when the request is aborted by AbortController.\nDOMException is thrown instead of this Error when DOMException is available.\n*/\nexport class AbortError extends Error {\n\tconstructor(message) {\n\t\tsuper();\n\t\tthis.name = 'AbortError';\n\t\tthis.message = message;\n\t}\n}\n\n/**\nTODO: Remove AbortError and just throw DOMException when targeting Node 18.\n*/\nconst getDOMException = errorMessage => globalThis.DOMException === undefined\n\t? new AbortError(errorMessage)\n\t: new DOMException(errorMessage);\n\n/**\nTODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.\n*/\nconst getAbortedReason = signal => {\n\tconst reason = signal.reason === undefined\n\t\t? getDOMException('This operation was aborted.')\n\t\t: signal.reason;\n\n\treturn reason instanceof Error ? reason : getDOMException(reason);\n};\n\nexport default function pTimeout(promise, options) {\n\tconst {\n\t\tmilliseconds,\n\t\tfallback,\n\t\tmessage,\n\t\tcustomTimers = {setTimeout, clearTimeout},\n\t} = options;\n\n\tlet timer;\n\n\tconst wrappedPromise = new Promise((resolve, reject) => {\n\t\tif (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {\n\t\t\tthrow new TypeError(`Expected \\`milliseconds\\` to be a positive number, got \\`${milliseconds}\\``);\n\t\t}\n\n\t\tif (options.signal) {\n\t\t\tconst {signal} = options;\n\t\t\tif (signal.aborted) {\n\t\t\t\treject(getAbortedReason(signal));\n\t\t\t}\n\n\t\t\tsignal.addEventListener('abort', () => {\n\t\t\t\treject(getAbortedReason(signal));\n\t\t\t});\n\t\t}\n\n\t\tif (milliseconds === Number.POSITIVE_INFINITY) {\n\t\t\tpromise.then(resolve, reject);\n\t\t\treturn;\n\t\t}\n\n\t\t// We create the error outside of `setTimeout` to preserve the stack trace.\n\t\tconst timeoutError = new TimeoutError();\n\n\t\ttimer = customTimers.setTimeout.call(undefined, () => {\n\t\t\tif (fallback) {\n\t\t\t\ttry {\n\t\t\t\t\tresolve(fallback());\n\t\t\t\t} catch (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t}\n\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (typeof promise.cancel === 'function') {\n\t\t\t\tpromise.cancel();\n\t\t\t}\n\n\t\t\tif (message === false) {\n\t\t\t\tresolve();\n\t\t\t} else if (message instanceof Error) {\n\t\t\t\treject(message);\n\t\t\t} else {\n\t\t\t\ttimeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;\n\t\t\t\treject(timeoutError);\n\t\t\t}\n\t\t}, milliseconds);\n\n\t\t(async () => {\n\t\t\ttry {\n\t\t\t\tresolve(await promise);\n\t\t\t} catch (error) {\n\t\t\t\treject(error);\n\t\t\t}\n\t\t})();\n\t});\n\n\tconst cancelablePromise = wrappedPromise.finally(() => {\n\t\tcancelablePromise.clear();\n\t});\n\n\tcancelablePromise.clear = () => {\n\t\tcustomTimers.clearTimeout.call(undefined, timer);\n\t\ttimer = undefined;\n\t};\n\n\treturn cancelablePromise;\n}\n",
    "// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound\n// Used to compute insertion index to keep queue sorted after insertion\nexport default function lowerBound(array, value, comparator) {\n    let first = 0;\n    let count = array.length;\n    while (count > 0) {\n        const step = Math.trunc(count / 2);\n        let it = first + step;\n        if (comparator(array[it], value) <= 0) {\n            first = ++it;\n            count -= step + 1;\n        }\n        else {\n            count = step;\n        }\n    }\n    return first;\n}\n",
    "import lowerBound from './lower-bound.js';\nexport default class PriorityQueue {\n    #queue = [];\n    enqueue(run, options) {\n        options = {\n            priority: 0,\n            ...options,\n        };\n        const element = {\n            priority: options.priority,\n            run,\n        };\n        if (this.size && this.#queue[this.size - 1].priority >= options.priority) {\n            this.#queue.push(element);\n            return;\n        }\n        const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);\n        this.#queue.splice(index, 0, element);\n    }\n    dequeue() {\n        const item = this.#queue.shift();\n        return item?.run;\n    }\n    filter(options) {\n        return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);\n    }\n    get size() {\n        return this.#queue.length;\n    }\n}\n",
    "import { EventEmitter } from 'eventemitter3';\nimport pTimeout, { TimeoutError } from 'p-timeout';\nimport PriorityQueue from './priority-queue.js';\n/**\nPromise queue with concurrency control.\n*/\nexport default class PQueue extends EventEmitter {\n    #carryoverConcurrencyCount;\n    #isIntervalIgnored;\n    #intervalCount = 0;\n    #intervalCap;\n    #interval;\n    #intervalEnd = 0;\n    #intervalId;\n    #timeoutId;\n    #queue;\n    #queueClass;\n    #pending = 0;\n    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194\n    #concurrency;\n    #isPaused;\n    #throwOnTimeout;\n    /**\n    Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.\n\n    Applies to each future operation.\n    */\n    timeout;\n    // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`\n    constructor(options) {\n        super();\n        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n        options = {\n            carryoverConcurrencyCount: false,\n            intervalCap: Number.POSITIVE_INFINITY,\n            interval: 0,\n            concurrency: Number.POSITIVE_INFINITY,\n            autoStart: true,\n            queueClass: PriorityQueue,\n            ...options,\n        };\n        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {\n            throw new TypeError(`Expected \\`intervalCap\\` to be a number from 1 and up, got \\`${options.intervalCap?.toString() ?? ''}\\` (${typeof options.intervalCap})`);\n        }\n        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {\n            throw new TypeError(`Expected \\`interval\\` to be a finite number >= 0, got \\`${options.interval?.toString() ?? ''}\\` (${typeof options.interval})`);\n        }\n        this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;\n        this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;\n        this.#intervalCap = options.intervalCap;\n        this.#interval = options.interval;\n        this.#queue = new options.queueClass();\n        this.#queueClass = options.queueClass;\n        this.concurrency = options.concurrency;\n        this.timeout = options.timeout;\n        this.#throwOnTimeout = options.throwOnTimeout === true;\n        this.#isPaused = options.autoStart === false;\n    }\n    get #doesIntervalAllowAnother() {\n        return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;\n    }\n    get #doesConcurrentAllowAnother() {\n        return this.#pending < this.#concurrency;\n    }\n    #next() {\n        this.#pending--;\n        this.#tryToStartAnother();\n        this.emit('next');\n    }\n    #onResumeInterval() {\n        this.#onInterval();\n        this.#initializeIntervalIfNeeded();\n        this.#timeoutId = undefined;\n    }\n    get #isIntervalPaused() {\n        const now = Date.now();\n        if (this.#intervalId === undefined) {\n            const delay = this.#intervalEnd - now;\n            if (delay < 0) {\n                // Act as the interval was done\n                // We don't need to resume it here because it will be resumed on line 160\n                this.#intervalCount = (this.#carryoverConcurrencyCount) ? this.#pending : 0;\n            }\n            else {\n                // Act as the interval is pending\n                if (this.#timeoutId === undefined) {\n                    this.#timeoutId = setTimeout(() => {\n                        this.#onResumeInterval();\n                    }, delay);\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    #tryToStartAnother() {\n        if (this.#queue.size === 0) {\n            // We can clear the interval (\"pause\")\n            // Because we can redo it later (\"resume\")\n            if (this.#intervalId) {\n                clearInterval(this.#intervalId);\n            }\n            this.#intervalId = undefined;\n            this.emit('empty');\n            if (this.#pending === 0) {\n                this.emit('idle');\n            }\n            return false;\n        }\n        if (!this.#isPaused) {\n            const canInitializeInterval = !this.#isIntervalPaused;\n            if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {\n                const job = this.#queue.dequeue();\n                if (!job) {\n                    return false;\n                }\n                this.emit('active');\n                job();\n                if (canInitializeInterval) {\n                    this.#initializeIntervalIfNeeded();\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    #initializeIntervalIfNeeded() {\n        if (this.#isIntervalIgnored || this.#intervalId !== undefined) {\n            return;\n        }\n        this.#intervalId = setInterval(() => {\n            this.#onInterval();\n        }, this.#interval);\n        this.#intervalEnd = Date.now() + this.#interval;\n    }\n    #onInterval() {\n        if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {\n            clearInterval(this.#intervalId);\n            this.#intervalId = undefined;\n        }\n        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;\n        this.#processQueue();\n    }\n    /**\n    Executes all queued functions until it reaches the limit.\n    */\n    #processQueue() {\n        // eslint-disable-next-line no-empty\n        while (this.#tryToStartAnother()) { }\n    }\n    get concurrency() {\n        return this.#concurrency;\n    }\n    set concurrency(newConcurrency) {\n        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {\n            throw new TypeError(`Expected \\`concurrency\\` to be a number from 1 and up, got \\`${newConcurrency}\\` (${typeof newConcurrency})`);\n        }\n        this.#concurrency = newConcurrency;\n        this.#processQueue();\n    }\n    async #throwOnAbort(signal) {\n        return new Promise((_resolve, reject) => {\n            signal.addEventListener('abort', () => {\n                reject(signal.reason);\n            }, { once: true });\n        });\n    }\n    async add(function_, options = {}) {\n        options = {\n            timeout: this.timeout,\n            throwOnTimeout: this.#throwOnTimeout,\n            ...options,\n        };\n        return new Promise((resolve, reject) => {\n            this.#queue.enqueue(async () => {\n                this.#pending++;\n                this.#intervalCount++;\n                try {\n                    options.signal?.throwIfAborted();\n                    let operation = function_({ signal: options.signal });\n                    if (options.timeout) {\n                        operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });\n                    }\n                    if (options.signal) {\n                        operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);\n                    }\n                    const result = await operation;\n                    resolve(result);\n                    this.emit('completed', result);\n                }\n                catch (error) {\n                    if (error instanceof TimeoutError && !options.throwOnTimeout) {\n                        resolve();\n                        return;\n                    }\n                    reject(error);\n                    this.emit('error', error);\n                }\n                finally {\n                    this.#next();\n                }\n            }, options);\n            this.emit('add');\n            this.#tryToStartAnother();\n        });\n    }\n    async addAll(functions, options) {\n        return Promise.all(functions.map(async (function_) => this.add(function_, options)));\n    }\n    /**\n    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)\n    */\n    start() {\n        if (!this.#isPaused) {\n            return this;\n        }\n        this.#isPaused = false;\n        this.#processQueue();\n        return this;\n    }\n    /**\n    Put queue execution on hold.\n    */\n    pause() {\n        this.#isPaused = true;\n    }\n    /**\n    Clear the queue.\n    */\n    clear() {\n        this.#queue = new this.#queueClass();\n    }\n    /**\n    Can be called multiple times. Useful if you for example add additional items at a later time.\n\n    @returns A promise that settles when the queue becomes empty.\n    */\n    async onEmpty() {\n        // Instantly resolve if the queue is empty\n        if (this.#queue.size === 0) {\n            return;\n        }\n        await this.#onEvent('empty');\n    }\n    /**\n    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.\n\n    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.\n\n    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.\n    */\n    async onSizeLessThan(limit) {\n        // Instantly resolve if the queue is empty.\n        if (this.#queue.size < limit) {\n            return;\n        }\n        await this.#onEvent('next', () => this.#queue.size < limit);\n    }\n    /**\n    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.\n\n    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.\n    */\n    async onIdle() {\n        // Instantly resolve if none pending and if nothing else is queued\n        if (this.#pending === 0 && this.#queue.size === 0) {\n            return;\n        }\n        await this.#onEvent('idle');\n    }\n    async #onEvent(event, filter) {\n        return new Promise(resolve => {\n            const listener = () => {\n                if (filter && !filter()) {\n                    return;\n                }\n                this.off(event, listener);\n                resolve();\n            };\n            this.on(event, listener);\n        });\n    }\n    /**\n    Size of the queue, the number of queued items waiting to run.\n    */\n    get size() {\n        return this.#queue.size;\n    }\n    /**\n    Size of the queue, filtered by the given options.\n\n    For example, this can be used to find the number of items remaining in the queue with a specific priority level.\n    */\n    sizeBy(options) {\n        // eslint-disable-next-line unicorn/no-array-callback-reference\n        return this.#queue.filter(options).length;\n    }\n    /**\n    Number of running items (no longer in the queue).\n    */\n    get pending() {\n        return this.#pending;\n    }\n    /**\n    Whether the queue is currently paused.\n    */\n    get isPaused() {\n        return this.#isPaused;\n    }\n}\n",
    "import { $ } from \"bun\";\nimport { canSudo, isRoot } from \"./helpers\";\nimport { pkgs } from \"./pkgs\";\n\nBun.env.PATH = [\n\tBun.env.PATH ?? \"\",\n\t\"/home/linuxbrew/.linuxbrew/bin\",\n\t\"/home/linuxbrew/.linuxbrew/sbin\",\n\t\"$BUN_INSTALL/bin\",\n\t\"$HOME/go/bin\",\n\t\"$HOME/.arkade/bin\",\n\t\"${KREW_ROOT:-$HOME/.krew}/bin\",\n\t\"$HOME/.cargo/bin\",\n\t\"$HOME/.dotnet\",\n\t\"$HOME/.dotnet/tools\",\n\t\"$HOME/.go/bin\",\n\t\"$HOME/.local/bin\",\n\t\"$HOME/bin\",\n\t\"/snap/bin\",\n\t\"/usr/local/sbin\",\n\t\"/usr/sbin\",\n\t\"/sbin\",\n].join(\":\");\n\nconst doctorRoot = async () => {\n\tif (!(await isRoot())) console.log(\"✅ You are not root\");\n\telse throw new Error(\"❌ You are root\");\n};\n\nconst doctorSudo = async () => {\n\tif (await canSudo()) console.log(\"✅ You can sudo\");\n\telse throw new Error(\"❌ You cannot sudo\");\n};\n\nconst doctorPkgs = async () => {\n\tconst result = await Promise.all(\n\t\tpkgs.map(async (pkg) => ({\n\t\t\tname: pkg.name,\n\t\t\texists: await pkg.check(),\n\t\t\tinstall: pkg.install,\n\t\t})),\n\t).then((x) => x.filter((y) => !y.exists));\n\tif (!result.length) {\n\t\tconsole.log(\"✅ All packages are installed\");\n\t} else {\n\t\tconsole.log(\"❌ Some packages are not installed\");\n\t\tconsole.table(result);\n\t\tfor (const r of result) {\n\t\t\tconsole.log(`🕒 Installing ${r.name}`);\n\t\t\tawait r\n\t\t\t\t.install()\n\t\t\t\t.then(() => console.log(`✅ Installed ${r.name}`))\n\t\t\t\t.catch(() => console.log(`❌ Failed to install ${r.name}`));\n\t\t}\n\t}\n};\n\nconst doctorGitconfig = async () => {\n\tconst expected = `[user]\n        email = charles63500@gmail.com\n        name = chneau\n[url \"ssh://git@github.com/\"]\n        insteadOf = https://github.com/\n[merge]\n        ff = false\n[pull]\n        ff = true\n        rebase = true\n[core]\n        whitespace = blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol\n[fetch]\n        prune = true\n`;\n\tconst gitconfig = await Bun.file(`${Bun.env.HOME}/.gitconfig`)\n\t\t.text()\n\t\t.catch(() => \"\");\n\tif (gitconfig === expected) {\n\t\tconsole.log(\"✅ Git config is set\");\n\t} else {\n\t\tconsole.log(\"❌ Git config is not set\");\n\t\tconsole.log(\"🕒 Setting git config\");\n\t\tawait Bun.write(`${Bun.env.HOME}/.gitconfig`, expected);\n\t\tconsole.log(\"✅ Git config is set\");\n\t}\n};\n\nconst doctorDotfiles = async () => {\n\tconst baseFiles = \"https://raw.githubusercontent.com/chneau/dotfiles/HEAD/\";\n\tconst expected = await Promise.all(\n\t\t[\".bashrc\", \".zshrc\", \".aliases\", \".profile\"].map(async (x) => ({\n\t\t\tname: x,\n\t\t\tcontent: await fetch(`${baseFiles}${x}`).then((x) => x.text()),\n\t\t\tisPresent: await Bun.file(`${Bun.env.HOME}/${x}`).exists(),\n\t\t})),\n\t);\n\tif (expected.every((x) => x.isPresent)) {\n\t\tconsole.log(\"✅ Dotfiles are installed\");\n\t} else {\n\t\tconsole.log(\"❌ Dotfiles are not installed\");\n\t\tconsole.log(\"🕒 Installing dotfiles\");\n\t\tawait Promise.all(\n\t\t\texpected.map(async (x) => {\n\t\t\t\tconsole.log(`🕒 Installing ${x.name}`);\n\t\t\t\tawait Bun.write(`${Bun.env.HOME}/${x.name}`, x.content);\n\t\t\t\tconsole.log(`✅ Installed ${x.name}`);\n\t\t\t}),\n\t\t);\n\t\tconsole.log(\"✅ Dotfiles are installed\");\n\t}\n};\n\nconst doctorDocker = async () => {\n\tif (!(await $`which docker`.nothrow().text()).includes(\"not found\")) {\n\t\tconsole.log(\"✅ Docker is installed\");\n\t} else {\n\t\tconsole.log(\"❌ Docker is not installed\");\n\t\tconsole.log(\"🕒 Installing Docker\");\n\t\tawait $`curl -sSL get.docker.com | sh`;\n\t\tconsole.log(\"✅ Docker is installed\");\n\t}\n};\n\nconst doctorUserGroups = async () => {\n\tconst groups = await $`groups`.text();\n\tif (groups.includes(\"docker\")) {\n\t\tconsole.log(\"✅ User is in docker groups\");\n\t} else {\n\t\tconsole.log(\"❌ User is not in docker groups\");\n\t\tconsole.log(\"🕒 Adding user to docker groups\");\n\t\tawait $`sudo usermod -aG docker $USER`.catch(() => {});\n\t\tconsole.log(\"✅ User is in docker groups\");\n\t}\n};\n\nconst doctorSsh = async () => {\n\tconst sshDir = `${Bun.env.HOME}/.ssh/id_rsa`;\n\tif (await Bun.file(sshDir).exists()) {\n\t\tconsole.log(\"✅ SSH key is set\");\n\t} else {\n\t\tconsole.log(\"❌ SSH key is not set\");\n\t\tconsole.log(\n\t\t\t'⚡ Please execute this command:\\n\\nssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -P \"\"',\n\t\t);\n\t\tthrow new Error(\"❌ SSH key is not set\");\n\t}\n};\n\nconst doctorGithub = async () => {\n\tif (\n\t\tawait $`ssh -o \"StrictHostKeyChecking no\" git@github.com 2>&1`\n\t\t\t.nothrow()\n\t\t\t.text()\n\t\t\t.then((x) => x.includes(\"successfully authenticated\"))\n\t) {\n\t\tconsole.log(\"✅ SSH key is set on GitHub\");\n\t} else {\n\t\tconsole.log(\"❌ SSH key is not set on GitHub\");\n\t\tconsole.log(\"🕒 Adding SSH key to GitHub\");\n\t\tawait $`cat ~/.ssh/id_rsa.pub`;\n\t\tconsole.log(\n\t\t\t\"⚡ Go to https://github.com/settings/ssh/new and past the text above\",\n\t\t);\n\t}\n};\n\nconst doctorZsh = async () => {\n\tconst etcShells = await Bun.file(\"/etc/shells\")\n\t\t.text()\n\t\t.then((x) => x.split(\"\\n\"));\n\tconst whichZsh = await $`which zsh`.nothrow().text();\n\tif (etcShells.includes(whichZsh)) {\n\t\tconsole.log(\"✅ Zsh is set as a valid shell\");\n\t} else {\n\t\tconsole.log(\"❌ Zsh is not set as a valid shell\");\n\t\tconsole.log(\"🕒 Adding Zsh to /etc/shells\");\n\t\tawait $`echo ${whichZsh} | sudo tee -a /etc/shells`;\n\t\tconsole.log(\"✅ Zsh is set as a valid shell\");\n\t}\n\tconst etcPasswdOfUSer = await $`cat /etc/passwd | grep \"^$USER:\"`.text();\n\tif (etcPasswdOfUSer.includes(whichZsh)) {\n\t\tconsole.log(\"✅ Zsh is set as your shell\");\n\t} else {\n\t\tconsole.log(\"❌ Zsh is not set as your shell\");\n\t\tconsole.log(\"🕒 Setting Zsh as your shell\");\n\t\tawait $`sudo chsh -s ${whichZsh} $USER`;\n\t\tconsole.log(\"✅ Zsh is set as your shell\");\n\t}\n};\n\nexport const commandDoctor = async () => {\n\tawait Promise.all([doctorRoot(), doctorSudo()]);\n\tawait Promise.all([\n\t\tdoctorDotfiles(),\n\t\tdoctorPkgs().then(() =>\n\t\t\tPromise.all([\n\t\t\t\tdoctorGitconfig().then(doctorSsh).then(doctorGithub),\n\t\t\t\tdoctorZsh(),\n\t\t\t\tdoctorDocker().then(doctorUserGroups),\n\t\t\t]),\n\t\t),\n\t]);\n};\n",
    "import { $ } from \"bun\";\n\nexport const commandExists = async (cmd: string) =>\n\t(await $`which ${cmd}`.text().catch(() => \"\")).trim() !== \"\";\n\nexport const isRoot = async () => {\n\tconst id = (await $`id -u`.text()).trim();\n\treturn id === \"0\";\n};\n\nexport const canSudo = async () => {\n\tconst text = (await $`sudo echo 0`.text().catch(() => \"\")).trim();\n\treturn text === \"0\";\n};\n\nexport const getCurrentVersion = async () =>\n\tawait Bun.file(`${import.meta.dir}/package.json`)\n\t\t.json()\n\t\t.then((x) => x.version as string)\n\t\t.catch(() => \"UNKNOWN\");\n",
    "import { $ } from \"bun\";\nimport { commandExists } from \"./helpers\";\n\ntype Pkg = {\n\tname: string;\n\tcheck: () => Promise<boolean>;\n\tinstall: () => Promise<unknown>;\n};\n\nconst aptIt = (name: string) => ({\n\tname,\n\tcheck: async () => commandExists(name),\n\tinstall: async () => await $`sudo apt install -y ${name}`,\n});\n\nconst aptPkgs: Pkg[] = [\n\taptIt(\"git\"),\n\taptIt(\"curl\"),\n\taptIt(\"wget\"),\n\taptIt(\"unzip\"),\n\taptIt(\"bash\"),\n];\n\nconst brewIt = (name: string) => ({\n\tname,\n\tcheck: async () => commandExists(name),\n\tinstall: async () => await $`brew install ${name}`,\n});\n\nconst brewPkgs: Pkg[] = [\n\tbrewIt(\"aichat\"),\n\tbrewIt(\"bpytop\"),\n\tbrewIt(\"docker-compose\"),\n\tbrewIt(\"go\"),\n\tbrewIt(\"helm\"),\n\tbrewIt(\"hyperfine\"),\n\tbrewIt(\"kubecolor\"),\n\tbrewIt(\"kubectx\"),\n\t{\n\t\t...brewIt(\"kubernetes-cli\"),\n\t\tcheck: async () => commandExists(\"kubectl\"),\n\t},\n\tbrewIt(\"lazygit\"),\n\tbrewIt(\"node\"),\n\tbrewIt(\"pipx\"),\n\tbrewIt(\"zsh\"),\n];\n\nconst bunIt = (name: string) => ({\n\tname,\n\tcheck: async () => commandExists(name),\n\tinstall: async () => await $`bun install --force --global ${name}`,\n});\n\nconst bunPkgs: Pkg[] = [\n\t{\n\t\t...bunIt(\"biome\"),\n\t\tinstall: async () => await $`bun install --force --global @biomejs/biome`,\n\t},\n\tbunIt(\"http-server\"),\n\tbunIt(\"live-server\"),\n\t{\n\t\t...bunIt(\"fkill\"),\n\t\tinstall: async () => await $`bun install --force --global fkill-cli`,\n\t},\n\tbunIt(\"ungit\"),\n\tbunIt(\"npm-check\"),\n\tbunIt(\"tsx\"),\n\tbunIt(\"npm-check-updates\"),\n\tbunIt(\"nodemon\"),\n\tbunIt(\"prettier\"),\n\tbunIt(\"typesync\"),\n\tbunIt(\"depcheck\"),\n\tbunIt(\"oxlint\"),\n\tbunIt(\"concurrently\"),\n\tbunIt(\"ts-unused-exports\"),\n];\nexport const pkgs: Pkg[] = [\n\t...aptPkgs,\n\t{\n\t\tname: \"brew\",\n\t\tcheck: async () => commandExists(\"brew\"),\n\t\tinstall: async () =>\n\t\t\tawait $`HOME=/tmp CI=1 bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"`,\n\t},\n\t{\n\t\tname: \"deno\",\n\t\tcheck: async () => commandExists(\"deno\"),\n\t\tinstall: async () => await $`curl -fsSL https://deno.land/install.sh | sh`,\n\t},\n\t...brewPkgs,\n\t...bunPkgs,\n];\n",
    "import { $ } from \"bun\";\n\nexport const commandFmt = async () =>\n\tvoid (await Promise.all([\n\t\t$`deno fmt --use-tabs --quiet; oxlint --fix-dangerously --quiet; biome check --write --unsafe .`.nothrow(),\n\t\t$`go fmt ./...`.nothrow(),\n\t\t$`dotnet csharpier .`.nothrow(),\n\t]));\n",
    "import { $ } from \"bun\";\nimport { canSudo, commandExists, isRoot } from \"./helpers\";\n\nconst updateDotfiles = async () => {\n\tconst initScript = await fetch(\n\t\t\"https://raw.githubusercontent.com/chneau/dotfiles/master/bootstrap.sh\",\n\t).then((x) => x.text());\n\tawait $`echo ${initScript} | sh`;\n};\n\nconst updateBun = async () => {\n\tconst bunPkgs = [\n\t\t\"@biomejs/biome\",\n\t\t\"http-server\",\n\t\t\"live-server\",\n\t\t\"fkill-cli\",\n\t\t\"ungit\",\n\t\t\"npm-check\",\n\t\t\"tsx\",\n\t\t\"npm-check-updates\",\n\t\t\"nodemon\",\n\t\t\"prettier\",\n\t\t\"typesync\",\n\t\t\"depcheck\",\n\t\t\"concurrently\",\n\t\t\"ts-unused-exports\",\n\t];\n\tawait $`bun upgrade`;\n\tawait $`bun install --force --global ${{ raw: bunPkgs.join(\" \") }}`;\n\tawait $`bun update --latest --force --global`;\n};\n\nconst updateApt = async () => {\n\tconst essentialPkgs = [\"git\", \"curl\", \"wget\", \"unzip\", \"zsh\", \"bash\"];\n\tawait $`sudo apt install -y ${{ raw: essentialPkgs.join(\" \") }}`;\n\tawait $`sudo apt update -y`;\n\tawait $`sudo apt upgrade -y`;\n\tawait $`sudo apt autoremove -y`;\n\tawait $`sudo apt autoclean -y`;\n};\n\nconst updateBrew = async () => {\n\tif (!(await commandExists(\"brew\"))) {\n\t\tawait $`CI=1 bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"`;\n\t}\n\tconst essentialPkgs = [\n\t\t\"bpytop\",\n\t\t\"dive\",\n\t\t\"dldash/core/docker-color-output\",\n\t\t\"docker-compose\",\n\t\t\"go\",\n\t\t\"helm\",\n\t\t\"hyperfine\",\n\t\t\"kubecolor\",\n\t\t\"kubectx\",\n\t\t\"kubernetes-cli\",\n\t\t\"lazygit\",\n\t\t\"node\",\n\t\t\"pipx\",\n\t\t\"zsh\",\n\t];\n\tconst brew =\n\t\t(await $`which brew`.text().catch(() => \"\")).trim() ||\n\t\t\"/home/linuxbrew/.linuxbrew/bin/brew\";\n\tawait $`${brew} install ${{ raw: essentialPkgs.join(\" \") }}`;\n\tawait $`${brew} update`;\n\tawait $`${brew} upgrade`;\n\tawait $`${brew} cleanup`;\n};\n\nexport const commandSystem = async () => {\n\tif (await isRoot()) throw new Error(\"You cannot run this command as root\");\n\tif (!(await canSudo())) throw new Error(\"You cannot sudo\");\n\tawait updateDotfiles();\n\tawait updateApt();\n\tawait updateBun();\n\tawait updateBrew();\n\tconsole.log(\"System updated\");\n};\n",
    "import { $ } from \"bun\";\nimport { fetchLatestVersion } from \"./fetchLatestVersion\";\nimport { getCurrentVersion } from \"./helpers\";\n\nexport const commandUpdate = async () => {\n\tconst latestVersion = await fetchLatestVersion();\n\tconst currentVersion = await getCurrentVersion();\n\tif (latestVersion === currentVersion) {\n\t\tconsole.log(\n\t\t\t`✅ You are already using the latest version ${currentVersion}`,\n\t\t);\n\t\treturn;\n\t}\n\tconsole.log(`🕒 You are using version ${currentVersion}`);\n\twhile (true) {\n\t\tconsole.log(`🕒 Updating to version ${latestVersion}`);\n\t\tconst installed = await $`bun i -fg @chneau/x@${latestVersion}`\n\t\t\t.quiet()\n\t\t\t.then(() => true)\n\t\t\t.catch(() => false);\n\t\tif (installed) break;\n\t\tawait Bun.sleep(1000);\n\t}\n\tconsole.log(`✅ Updated to version ${latestVersion}`);\n};\n",
    "export const fetchLatestVersion = async () =>\n\tawait fetch(\"https://registry.npmjs.org/@chneau/x/latest\")\n\t\t.then((x) => x.json().then((x) => x.version as string))\n\t\t.catch(() => \"UNKNOWN\");\n",
    "#!/usr/bin/env bun\nimport { program } from \"commander\";\nimport { command } from \"./command\";\nimport { commandDoctor } from \"./commandDoctor\";\nimport { commandFmt } from \"./commandFmt\";\nimport { commandSystem } from \"./commandSystem\";\nimport { commandUpdate } from \"./commandUpdate\";\nimport { getCurrentVersion } from \"./helpers\";\n\nconst version = await getCurrentVersion();\n\nprogram.name(\"x\").description(\"chneau's utility CLI\").version(version);\n\nprogram\n\t.option(\"-r, --recursive [number]\", \"Recursion level\", Number.parseFloat)\n\t.argument(\"[dir]\", \"Directory to manage\", \".\")\n\t.action(command);\n\nprogram.command(\"fmt\").description(\"Format all files\").action(commandFmt);\n\nprogram\n\t.command(\"update\")\n\t.description(\"Update x to the latest version\")\n\t.action(commandUpdate);\n\nprogram\n\t.command(\"system\")\n\t.description(\"Update/install the system packages\")\n\t.action(commandSystem);\n\nprogram\n\t.command(\"doctor\")\n\t.description(\"Check the system for issues\")\n\t.action(commandDoctor);\n\nprogram.parse();\n"
  ],
  "mappings": "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AO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,OAAO;AAC5C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAAe,OAAO,MAAM;AAC3C,kBAAe,gBAA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",
  "debugId": "863DA44C78FD2ABC64756E2164756E21",
  "names": []
}