@betty-blocks/cli 26.0.0-beta.9 → 26.0.0

package/build/src/bb-functions-build.js

@@ -1,4284 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
-    }
-  }
-
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-    }
-  }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-});
-
-// node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.length > 3 && this._name.slice(-3) === "...") {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
-    }
-  }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-  }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
-});
-
-// node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
-
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.minWidthToWrap = 40;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    prepareContext(contextOptions) {
-      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
-    }
-    visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
-    }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
-    }
-    visibleOptions(cmd) {
-      const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const helpOption = cmd._getHelpOption();
-      if (helpOption && !helpOption.hidden) {
-        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-        if (!removeShort && !removeLong) {
-          visibleOptions.push(helpOption);
-        } else if (helpOption.long && !removeLong) {
-          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-        } else if (helpOption.short && !removeShort) {
-          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
-    }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
-      }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
-      }
-      return globalOptions;
-    }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
-    }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-    }
-    optionTerm(option) {
-      return option.flags;
-    }
-    argumentTerm(argument) {
-      return argument.name();
-    }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
-      }, 0);
-    }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
-      }, 0);
-    }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
-      }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
-    }
-    commandDescription(cmd) {
-      return cmd.description();
-    }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
-    }
-    optionDescription(option) {
-      const extraInfo = [];
-      if (option.argChoices) {
-        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (option.defaultValue !== undefined) {
-        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-        if (showDefault) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-      }
-      if (option.presetArg !== undefined && option.optional) {
-        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-      }
-      if (option.envVar !== undefined) {
-        extraInfo.push(`env: ${option.envVar}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (option.description) {
-          return `${option.description} ${extraDescription}`;
-        }
-        return extraDescription;
-      }
-      return option.description;
-    }
-    argumentDescription(argument) {
-      const extraInfo = [];
-      if (argument.argChoices) {
-        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (argument.defaultValue !== undefined) {
-        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescription}`;
-        }
-        return extraDescription;
-      }
-      return argument.description;
-    }
-    formatItemList(heading, items, helper) {
-      if (items.length === 0)
-        return [];
-      return [helper.styleTitle(heading), ...items, ""];
-    }
-    groupItems(unsortedItems, visibleItems, getGroup) {
-      const result = new Map;
-      unsortedItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group))
-          result.set(group, []);
-      });
-      visibleItems.forEach((item) => {
-        const group = getGroup(item);
-        if (!result.has(group)) {
-          result.set(group, []);
-        }
-        result.get(group).push(item);
-      });
-      return result;
-    }
-    formatHelp(cmd, helper) {
-      const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth ?? 80;
-      function callFormatItem(term, description) {
-        return helper.formatItem(term, termWidth, description, helper);
-      }
-      let output = [
-        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
-        ""
-      ];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
-      });
-      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
-      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
-      optionGroups.forEach((options, group) => {
-        const optionList = options.map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList(group, optionList, helper));
-      });
-      if (helper.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
-      }
-      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
-      commandGroups.forEach((commands, group) => {
-        const commandList = commands.map((sub) => {
-          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
-        });
-        output = output.concat(this.formatItemList(group, commandList, helper));
-      });
-      return output.join(`
-`);
-    }
-    displayWidth(str) {
-      return stripColor(str).length;
-    }
-    styleTitle(str) {
-      return str;
-    }
-    styleUsage(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word === "[command]")
-          return this.styleSubcommandText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleCommandText(word);
-      }).join(" ");
-    }
-    styleCommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleOptionDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleSubcommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleArgumentDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleDescriptionText(str) {
-      return str;
-    }
-    styleOptionTerm(str) {
-      return this.styleOptionText(str);
-    }
-    styleSubcommandTerm(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleSubcommandText(word);
-      }).join(" ");
-    }
-    styleArgumentTerm(str) {
-      return this.styleArgumentText(str);
-    }
-    styleOptionText(str) {
-      return str;
-    }
-    styleArgumentText(str) {
-      return str;
-    }
-    styleSubcommandText(str) {
-      return str;
-    }
-    styleCommandText(str) {
-      return str;
-    }
-    padWidth(cmd, helper) {
-      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
-    }
-    preformatted(str) {
-      return /\n[^\S\r\n]/.test(str);
-    }
-    formatItem(term, termWidth, description, helper) {
-      const itemIndent = 2;
-      const itemIndentStr = " ".repeat(itemIndent);
-      if (!description)
-        return itemIndentStr + term;
-      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
-      const spacerWidth = 2;
-      const helpWidth = this.helpWidth ?? 80;
-      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
-      let formattedDescription;
-      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
-        formattedDescription = description;
-      } else {
-        const wrappedDescription = helper.boxWrap(description, remainingWidth);
-        formattedDescription = wrappedDescription.replace(/\n/g, `
-` + " ".repeat(termWidth + spacerWidth));
-      }
-      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
-${itemIndentStr}`);
-    }
-    boxWrap(str, width) {
-      if (width < this.minWidthToWrap)
-        return str;
-      const rawLines = str.split(/\r\n|\n/);
-      const chunkPattern = /[\s]*[^\s]+/g;
-      const wrappedLines = [];
-      rawLines.forEach((line) => {
-        const chunks = line.match(chunkPattern);
-        if (chunks === null) {
-          wrappedLines.push("");
-          return;
-        }
-        let sumChunks = [chunks.shift()];
-        let sumWidth = this.displayWidth(sumChunks[0]);
-        chunks.forEach((chunk) => {
-          const visibleWidth = this.displayWidth(chunk);
-          if (sumWidth + visibleWidth <= width) {
-            sumChunks.push(chunk);
-            sumWidth += visibleWidth;
-            return;
-          }
-          wrappedLines.push(sumChunks.join(""));
-          const nextChunk = chunk.trimStart();
-          sumChunks = [nextChunk];
-          sumWidth = this.displayWidth(nextChunk);
-        });
-        wrappedLines.push(sumChunks.join(""));
-      });
-      return wrappedLines.join(`
-`);
-    }
-  }
-  function stripColor(str) {
-    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str.replace(sgrPattern, "");
-  }
-  exports.Help = Help;
-  exports.stripColor = stripColor;
-});
-
-// node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Option {
-    constructor(flags, description) {
-      this.flags = flags;
-      this.description = description || "";
-      this.required = flags.includes("<");
-      this.optional = flags.includes("[");
-      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-      this.mandatory = false;
-      const optionFlags = splitOptionFlags(flags);
-      this.short = optionFlags.shortFlag;
-      this.long = optionFlags.longFlag;
-      this.negate = false;
-      if (this.long) {
-        this.negate = this.long.startsWith("--no-");
-      }
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.presetArg = undefined;
-      this.envVar = undefined;
-      this.parseArg = undefined;
-      this.hidden = false;
-      this.argChoices = undefined;
-      this.conflictsWith = [];
-      this.implied = undefined;
-      this.helpGroupHeading = undefined;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    preset(arg) {
-      this.presetArg = arg;
-      return this;
-    }
-    conflicts(names) {
-      this.conflictsWith = this.conflictsWith.concat(names);
-      return this;
-    }
-    implies(impliedOptionValues) {
-      let newImplied = impliedOptionValues;
-      if (typeof impliedOptionValues === "string") {
-        newImplied = { [impliedOptionValues]: true };
-      }
-      this.implied = Object.assign(this.implied || {}, newImplied);
-      return this;
-    }
-    env(name) {
-      this.envVar = name;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    makeOptionMandatory(mandatory = true) {
-      this.mandatory = !!mandatory;
-      return this;
-    }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
-      }
-      return this.short.replace(/^-/, "");
-    }
-    attributeName() {
-      if (this.negate) {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      return camelcase(this.name());
-    }
-    helpGroup(heading) {
-      this.helpGroupHeading = heading;
-      return this;
-    }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
-    }
-  }
-
-  class DualOptions {
-    constructor(options) {
-      this.positiveOptions = new Map;
-      this.negativeOptions = new Map;
-      this.dualOptions = new Set;
-      options.forEach((option) => {
-        if (option.negate) {
-          this.negativeOptions.set(option.attributeName(), option);
-        } else {
-          this.positiveOptions.set(option.attributeName(), option);
-        }
-      });
-      this.negativeOptions.forEach((value, key) => {
-        if (this.positiveOptions.has(key)) {
-          this.dualOptions.add(key);
-        }
-      });
-    }
-    valueFromOption(value, option) {
-      const optionKey = option.attributeName();
-      if (!this.dualOptions.has(optionKey))
-        return true;
-      const preset = this.negativeOptions.get(optionKey).presetArg;
-      const negativeValue = preset !== undefined ? preset : false;
-      return option.negate === (negativeValue === value);
-    }
-  }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
-    });
-  }
-  function splitOptionFlags(flags) {
-    let shortFlag;
-    let longFlag;
-    const shortFlagExp = /^-[^-]$/;
-    const longFlagExp = /^--[^-]/;
-    const flagParts = flags.split(/[ |,]+/).concat("guard");
-    if (shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (longFlagExp.test(flagParts[0]))
-      longFlag = flagParts.shift();
-    if (!shortFlag && shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (!shortFlag && longFlagExp.test(flagParts[0])) {
-      shortFlag = longFlag;
-      longFlag = flagParts.shift();
-    }
-    if (flagParts[0].startsWith("-")) {
-      const unsupportedFlag = flagParts[0];
-      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
-      if (/^-[^-][^-]/.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- a short flag is a single dash and a single character
-  - either use a single dash and a single character (for a short flag)
-  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
-      if (shortFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many short flags`);
-      if (longFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many long flags`);
-      throw new Error(`${baseError}
-- unrecognised flag format`);
-    }
-    if (shortFlag === undefined && longFlag === undefined)
-      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
-    return { shortFlag, longFlag };
-  }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
-});
-
-// node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS((exports) => {
-  var maxDistance = 3;
-  function editDistance(a, b) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-      return Math.max(a.length, b.length);
-    const d = [];
-    for (let i = 0;i <= a.length; i++) {
-      d[i] = [i];
-    }
-    for (let j = 0;j <= b.length; j++) {
-      d[0][j] = j;
-    }
-    for (let j = 1;j <= b.length; j++) {
-      for (let i = 1;i <= a.length; i++) {
-        let cost = 1;
-        if (a[i - 1] === b[j - 1]) {
-          cost = 0;
-        } else {
-          cost = 1;
-        }
-        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
-        }
-      }
-    }
-    return d[a.length][b.length];
-  }
-  function suggestSimilar(word, candidates) {
-    if (!candidates || candidates.length === 0)
-      return "";
-    candidates = Array.from(new Set(candidates));
-    const searchingOptions = word.startsWith("--");
-    if (searchingOptions) {
-      word = word.slice(2);
-      candidates = candidates.map((candidate) => candidate.slice(2));
-    }
-    let similar = [];
-    let bestDistance = maxDistance;
-    const minSimilarity = 0.4;
-    candidates.forEach((candidate) => {
-      if (candidate.length <= 1)
-        return;
-      const distance = editDistance(word, candidate);
-      const length = Math.max(word.length, candidate.length);
-      const similarity = (length - distance) / length;
-      if (similarity > minSimilarity) {
-        if (distance < bestDistance) {
-          bestDistance = distance;
-          similar = [candidate];
-        } else if (distance === bestDistance) {
-          similar.push(candidate);
-        }
-      }
-    });
-    similar.sort((a, b) => a.localeCompare(b));
-    if (searchingOptions) {
-      similar = similar.map((candidate) => `--${candidate}`);
-    }
-    if (similar.length > 1) {
-      return `
-(Did you mean one of ${similar.join(", ")}?)`;
-    }
-    if (similar.length === 1) {
-      return `
-(Did you mean ${similar[0]}?)`;
-    }
-    return "";
-  }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("node:events").EventEmitter;
-  var childProcess = __require("node:child_process");
-  var path = __require("node:path");
-  var fs = __require("node:fs");
-  var process2 = __require("node:process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help, stripColor } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
-
-  class Command extends EventEmitter {
-    constructor(name) {
-      super();
-      this.commands = [];
-      this.options = [];
-      this.parent = null;
-      this._allowUnknownOption = false;
-      this._allowExcessArguments = false;
-      this.registeredArguments = [];
-      this._args = this.registeredArguments;
-      this.args = [];
-      this.rawArgs = [];
-      this.processedArgs = [];
-      this._scriptPath = null;
-      this._name = name || "";
-      this._optionValues = {};
-      this._optionValueSources = {};
-      this._storeOptionsAsProperties = false;
-      this._actionHandler = null;
-      this._executableHandler = false;
-      this._executableFile = null;
-      this._executableDir = null;
-      this._defaultCommandName = null;
-      this._exitCallback = null;
-      this._aliases = [];
-      this._combineFlagAndOptionalValue = true;
-      this._description = "";
-      this._summary = "";
-      this._argsDescription = undefined;
-      this._enablePositionalOptions = false;
-      this._passThroughOptions = false;
-      this._lifeCycleHooks = {};
-      this._showHelpAfterError = false;
-      this._showSuggestionAfterError = true;
-      this._savedState = null;
-      this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        outputError: (str, write) => write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
-        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
-        stripColor: (str) => stripColor(str)
-      };
-      this._hidden = false;
-      this._helpOption = undefined;
-      this._addImplicitHelpCommand = undefined;
-      this._helpCommand = undefined;
-      this._helpConfiguration = {};
-      this._helpGroupHeading = undefined;
-      this._defaultCommandGroup = undefined;
-      this._defaultOptionGroup = undefined;
-    }
-    copyInheritedSettings(sourceCommand) {
-      this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._helpOption = sourceCommand._helpOption;
-      this._helpCommand = sourceCommand._helpCommand;
-      this._helpConfiguration = sourceCommand._helpConfiguration;
-      this._exitCallback = sourceCommand._exitCallback;
-      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
-      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
-      this._allowExcessArguments = sourceCommand._allowExcessArguments;
-      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
-      this._showHelpAfterError = sourceCommand._showHelpAfterError;
-      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
-      return this;
-    }
-    _getCommandAndAncestors() {
-      const result = [];
-      for (let command = this;command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
-    }
-    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
-      let desc = actionOptsOrExecDesc;
-      let opts = execOpts;
-      if (typeof desc === "object" && desc !== null) {
-        opts = desc;
-        desc = null;
-      }
-      opts = opts || {};
-      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const cmd = this.createCommand(name);
-      if (desc) {
-        cmd.description(desc);
-        cmd._executableHandler = true;
-      }
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      cmd._hidden = !!(opts.noHelp || opts.hidden);
-      cmd._executableFile = opts.executableFile || null;
-      if (args)
-        cmd.arguments(args);
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd.copyInheritedSettings(this);
-      if (desc)
-        return this;
-      return cmd;
-    }
-    createCommand(name) {
-      return new Command(name);
-    }
-    createHelp() {
-      return Object.assign(new Help, this.configureHelp());
-    }
-    configureHelp(configuration) {
-      if (configuration === undefined)
-        return this._helpConfiguration;
-      this._helpConfiguration = configuration;
-      return this;
-    }
-    configureOutput(configuration) {
-      if (configuration === undefined)
-        return this._outputConfiguration;
-      this._outputConfiguration = Object.assign({}, this._outputConfiguration, configuration);
-      return this;
-    }
-    showHelpAfterError(displayHelp = true) {
-      if (typeof displayHelp !== "string")
-        displayHelp = !!displayHelp;
-      this._showHelpAfterError = displayHelp;
-      return this;
-    }
-    showSuggestionAfterError(displaySuggestion = true) {
-      this._showSuggestionAfterError = !!displaySuggestion;
-      return this;
-    }
-    addCommand(cmd, opts) {
-      if (!cmd._name) {
-        throw new Error(`Command passed to .addCommand() must have a name
-- specify the name in Command constructor or using .name()`);
-      }
-      opts = opts || {};
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      if (opts.noHelp || opts.hidden)
-        cmd._hidden = true;
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd._checkForBrokenPassThrough();
-      return this;
-    }
-    createArgument(name, description) {
-      return new Argument(name, description);
-    }
-    argument(name, description, parseArg, defaultValue) {
-      const argument = this.createArgument(name, description);
-      if (typeof parseArg === "function") {
-        argument.default(defaultValue).argParser(parseArg);
-      } else {
-        argument.default(parseArg);
-      }
-      this.addArgument(argument);
-      return this;
-    }
-    arguments(names) {
-      names.trim().split(/ +/).forEach((detail) => {
-        this.argument(detail);
-      });
-      return this;
-    }
-    addArgument(argument) {
-      const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
-        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
-      }
-      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
-        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
-      }
-      this.registeredArguments.push(argument);
-      return this;
-    }
-    helpCommand(enableOrNameAndArgs, description) {
-      if (typeof enableOrNameAndArgs === "boolean") {
-        this._addImplicitHelpCommand = enableOrNameAndArgs;
-        if (enableOrNameAndArgs && this._defaultCommandGroup) {
-          this._initCommandGroup(this._getHelpCommand());
-        }
-        return this;
-      }
-      const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const helpDescription = description ?? "display help for command";
-      const helpCommand = this.createCommand(helpName);
-      helpCommand.helpOption(false);
-      if (helpArgs)
-        helpCommand.arguments(helpArgs);
-      if (helpDescription)
-        helpCommand.description(helpDescription);
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      if (enableOrNameAndArgs || description)
-        this._initCommandGroup(helpCommand);
-      return this;
-    }
-    addHelpCommand(helpCommand, deprecatedDescription) {
-      if (typeof helpCommand !== "object") {
-        this.helpCommand(helpCommand, deprecatedDescription);
-        return this;
-      }
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      this._initCommandGroup(helpCommand);
-      return this;
-    }
-    _getHelpCommand() {
-      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
-      if (hasImplicitHelpCommand) {
-        if (this._helpCommand === undefined) {
-          this.helpCommand(undefined, undefined);
-        }
-        return this._helpCommand;
-      }
-      return null;
-    }
-    hook(event, listener) {
-      const allowedValues = ["preSubcommand", "preAction", "postAction"];
-      if (!allowedValues.includes(event)) {
-        throw new Error(`Unexpected value for event passed to hook : '${event}'.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      if (this._lifeCycleHooks[event]) {
-        this._lifeCycleHooks[event].push(listener);
-      } else {
-        this._lifeCycleHooks[event] = [listener];
-      }
-      return this;
-    }
-    exitOverride(fn) {
-      if (fn) {
-        this._exitCallback = fn;
-      } else {
-        this._exitCallback = (err) => {
-          if (err.code !== "commander.executeSubCommandAsync") {
-            throw err;
-          } else {}
-        };
-      }
-      return this;
-    }
-    _exit(exitCode, code, message) {
-      if (this._exitCallback) {
-        this._exitCallback(new CommanderError(exitCode, code, message));
-      }
-      process2.exit(exitCode);
-    }
-    action(fn) {
-      const listener = (args) => {
-        const expectedArgsCount = this.registeredArguments.length;
-        const actionArgs = args.slice(0, expectedArgsCount);
-        if (this._storeOptionsAsProperties) {
-          actionArgs[expectedArgsCount] = this;
-        } else {
-          actionArgs[expectedArgsCount] = this.opts();
-        }
-        actionArgs.push(this);
-        return fn.apply(this, actionArgs);
-      };
-      this._actionHandler = listener;
-      return this;
-    }
-    createOption(flags, description) {
-      return new Option(flags, description);
-    }
-    _callParseArg(target, value, previous, invalidArgumentMessage) {
-      try {
-        return target.parseArg(value, previous);
-      } catch (err) {
-        if (err.code === "commander.invalidArgument") {
-          const message = `${invalidArgumentMessage} ${err.message}`;
-          this.error(message, { exitCode: err.exitCode, code: err.code });
-        }
-        throw err;
-      }
-    }
-    _registerOption(option) {
-      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
-      if (matchingOption) {
-        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
-        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
--  already used by option '${matchingOption.flags}'`);
-      }
-      this._initOptionGroup(option);
-      this.options.push(option);
-    }
-    _registerCommand(command) {
-      const knownBy = (cmd) => {
-        return [cmd.name()].concat(cmd.aliases());
-      };
-      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
-      if (alreadyUsed) {
-        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
-        const newCmd = knownBy(command).join("|");
-        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
-      }
-      this._initCommandGroup(command);
-      this.commands.push(command);
-    }
-    addOption(option) {
-      this._registerOption(option);
-      const oname = option.name();
-      const name = option.attributeName();
-      if (option.negate) {
-        const positiveLongFlag = option.long.replace(/^--no-/, "--");
-        if (!this._findOption(positiveLongFlag)) {
-          this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, "default");
-        }
-      } else if (option.defaultValue !== undefined) {
-        this.setOptionValueWithSource(name, option.defaultValue, "default");
-      }
-      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
-        if (val == null && option.presetArg !== undefined) {
-          val = option.presetArg;
-        }
-        const oldValue = this.getOptionValue(name);
-        if (val !== null && option.parseArg) {
-          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
-        } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
-        }
-        if (val == null) {
-          if (option.negate) {
-            val = false;
-          } else if (option.isBoolean() || option.optional) {
-            val = true;
-          } else {
-            val = "";
-          }
-        }
-        this.setOptionValueWithSource(name, val, valueSource);
-      };
-      this.on("option:" + oname, (val) => {
-        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
-        handleOptionValue(val, invalidValueMessage, "cli");
-      });
-      if (option.envVar) {
-        this.on("optionEnv:" + oname, (val) => {
-          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
-          handleOptionValue(val, invalidValueMessage, "env");
-        });
-      }
-      return this;
-    }
-    _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option) {
-        throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
-      }
-      const option = this.createOption(flags, description);
-      option.makeOptionMandatory(!!config.mandatory);
-      if (typeof fn === "function") {
-        option.default(defaultValue).argParser(fn);
-      } else if (fn instanceof RegExp) {
-        const regex = fn;
-        fn = (val, def) => {
-          const m = regex.exec(val);
-          return m ? m[0] : def;
-        };
-        option.default(defaultValue).argParser(fn);
-      } else {
-        option.default(fn);
-      }
-      return this.addOption(option);
-    }
-    option(flags, description, parseArg, defaultValue) {
-      return this._optionEx({}, flags, description, parseArg, defaultValue);
-    }
-    requiredOption(flags, description, parseArg, defaultValue) {
-      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
-    }
-    combineFlagAndOptionalValue(combine = true) {
-      this._combineFlagAndOptionalValue = !!combine;
-      return this;
-    }
-    allowUnknownOption(allowUnknown = true) {
-      this._allowUnknownOption = !!allowUnknown;
-      return this;
-    }
-    allowExcessArguments(allowExcess = true) {
-      this._allowExcessArguments = !!allowExcess;
-      return this;
-    }
-    enablePositionalOptions(positional = true) {
-      this._enablePositionalOptions = !!positional;
-      return this;
-    }
-    passThroughOptions(passThrough = true) {
-      this._passThroughOptions = !!passThrough;
-      this._checkForBrokenPassThrough();
-      return this;
-    }
-    _checkForBrokenPassThrough() {
-      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
-        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
-      }
-    }
-    storeOptionsAsProperties(storeAsProperties = true) {
-      if (this.options.length) {
-        throw new Error("call .storeOptionsAsProperties() before adding options");
-      }
-      if (Object.keys(this._optionValues).length) {
-        throw new Error("call .storeOptionsAsProperties() before setting option values");
-      }
-      this._storeOptionsAsProperties = !!storeAsProperties;
-      return this;
-    }
-    getOptionValue(key) {
-      if (this._storeOptionsAsProperties) {
-        return this[key];
-      }
-      return this._optionValues[key];
-    }
-    setOptionValue(key, value) {
-      return this.setOptionValueWithSource(key, value, undefined);
-    }
-    setOptionValueWithSource(key, value, source) {
-      if (this._storeOptionsAsProperties) {
-        this[key] = value;
-      } else {
-        this._optionValues[key] = value;
-      }
-      this._optionValueSources[key] = source;
-      return this;
-    }
-    getOptionValueSource(key) {
-      return this._optionValueSources[key];
-    }
-    getOptionValueSourceWithGlobals(key) {
-      let source;
-      this._getCommandAndAncestors().forEach((cmd) => {
-        if (cmd.getOptionValueSource(key) !== undefined) {
-          source = cmd.getOptionValueSource(key);
-        }
-      });
-      return source;
-    }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
-        throw new Error("first parameter to parse must be array or undefined");
-      }
-      parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
-          parseOptions.from = "electron";
-        }
-        const execArgv = process2.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-          parseOptions.from = "eval";
-        }
-      }
-      if (argv === undefined) {
-        argv = process2.argv;
-      }
-      this.rawArgs = argv.slice();
-      let userArgs;
-      switch (parseOptions.from) {
-        case undefined:
-        case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
-          break;
-        case "electron":
-          if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
-          } else {
-            userArgs = argv.slice(1);
-          }
-          break;
-        case "user":
-          userArgs = argv.slice(0);
-          break;
-        case "eval":
-          userArgs = argv.slice(1);
-          break;
-        default:
-          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
-      }
-      if (!this._name && this._scriptPath)
-        this.nameFromFilename(this._scriptPath);
-      this._name = this._name || "program";
-      return userArgs;
-    }
-    parse(argv, parseOptions) {
-      this._prepareForParse();
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      this._parseCommand([], userArgs);
-      return this;
-    }
-    async parseAsync(argv, parseOptions) {
-      this._prepareForParse();
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      await this._parseCommand([], userArgs);
-      return this;
-    }
-    _prepareForParse() {
-      if (this._savedState === null) {
-        this.saveStateBeforeParse();
-      } else {
-        this.restoreStateBeforeParse();
-      }
-    }
-    saveStateBeforeParse() {
-      this._savedState = {
-        _name: this._name,
-        _optionValues: { ...this._optionValues },
-        _optionValueSources: { ...this._optionValueSources }
-      };
-    }
-    restoreStateBeforeParse() {
-      if (this._storeOptionsAsProperties)
-        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
-- either make a new Command for each call to parse, or stop storing options as properties`);
-      this._name = this._savedState._name;
-      this._scriptPath = null;
-      this.rawArgs = [];
-      this._optionValues = { ...this._savedState._optionValues };
-      this._optionValueSources = { ...this._savedState._optionValueSources };
-      this.args = [];
-      this.processedArgs = [];
-    }
-    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs.existsSync(executableFile))
-        return;
-      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-      const executableMissing = `'${executableFile}' does not exist
- - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-      throw new Error(executableMissing);
-    }
-    _executeSubCommand(subcommand, args) {
-      args = args.slice();
-      let launchWithNode = false;
-      const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-      function findFile(baseDir, baseName) {
-        const localBin = path.resolve(baseDir, baseName);
-        if (fs.existsSync(localBin))
-          return localBin;
-        if (sourceExt.includes(path.extname(baseName)))
-          return;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
-        if (foundExt)
-          return `${localBin}${foundExt}`;
-        return;
-      }
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
-      let executableDir = this._executableDir || "";
-      if (this._scriptPath) {
-        let resolvedScriptPath;
-        try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch {
-          resolvedScriptPath = this._scriptPath;
-        }
-        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
-      }
-      if (executableDir) {
-        let localFile = findFile(executableDir, executableFile);
-        if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
-          if (legacyName !== this._name) {
-            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
-          }
-        }
-        executableFile = localFile || executableFile;
-      }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
-      let proc;
-      if (process2.platform !== "win32") {
-        if (launchWithNode) {
-          args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
-        } else {
-          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
-        }
-      } else {
-        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
-        args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
-      }
-      if (!proc.killed) {
-        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-        signals.forEach((signal) => {
-          process2.on(signal, () => {
-            if (proc.killed === false && proc.exitCode === null) {
-              proc.kill(signal);
-            }
-          });
-        });
-      }
-      const exitCallback = this._exitCallback;
-      proc.on("close", (code) => {
-        code = code ?? 1;
-        if (!exitCallback) {
-          process2.exit(code);
-        } else {
-          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
-        }
-      });
-      proc.on("error", (err) => {
-        if (err.code === "ENOENT") {
-          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
-        } else if (err.code === "EACCES") {
-          throw new Error(`'${executableFile}' not executable`);
-        }
-        if (!exitCallback) {
-          process2.exit(1);
-        } else {
-          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
-          wrappedError.nestedError = err;
-          exitCallback(wrappedError);
-        }
-      });
-      this.runningCommand = proc;
-    }
-    _dispatchSubcommand(commandName, operands, unknown) {
-      const subCommand = this._findCommand(commandName);
-      if (!subCommand)
-        this.help({ error: true });
-      subCommand._prepareForParse();
-      let promiseChain;
-      promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
-      promiseChain = this._chainOrCall(promiseChain, () => {
-        if (subCommand._executableHandler) {
-          this._executeSubCommand(subCommand, operands.concat(unknown));
-        } else {
-          return subCommand._parseCommand(operands, unknown);
-        }
-      });
-      return promiseChain;
-    }
-    _dispatchHelpCommand(subcommandName) {
-      if (!subcommandName) {
-        this.help();
-      }
-      const subCommand = this._findCommand(subcommandName);
-      if (subCommand && !subCommand._executableHandler) {
-        subCommand.help();
-      }
-      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
-    }
-    _checkNumberOfArguments() {
-      this.registeredArguments.forEach((arg, i) => {
-        if (arg.required && this.args[i] == null) {
-          this.missingArgument(arg.name());
-        }
-      });
-      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
-        return;
-      }
-      if (this.args.length > this.registeredArguments.length) {
-        this._excessArguments(this.args);
-      }
-    }
-    _processArguments() {
-      const myParseArg = (argument, value, previous) => {
-        let parsedValue = value;
-        if (value !== null && argument.parseArg) {
-          const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
-          parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
-        }
-        return parsedValue;
-      };
-      this._checkNumberOfArguments();
-      const processedArgs = [];
-      this.registeredArguments.forEach((declaredArg, index) => {
-        let value = declaredArg.defaultValue;
-        if (declaredArg.variadic) {
-          if (index < this.args.length) {
-            value = this.args.slice(index);
-            if (declaredArg.parseArg) {
-              value = value.reduce((processed, v) => {
-                return myParseArg(declaredArg, v, processed);
-              }, declaredArg.defaultValue);
-            }
-          } else if (value === undefined) {
-            value = [];
-          }
-        } else if (index < this.args.length) {
-          value = this.args[index];
-          if (declaredArg.parseArg) {
-            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
-          }
-        }
-        processedArgs[index] = value;
-      });
-      this.processedArgs = processedArgs;
-    }
-    _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === "function") {
-        return promise.then(() => fn());
-      }
-      return fn();
-    }
-    _chainOrCallHooks(promise, event) {
-      let result = promise;
-      const hooks = [];
-      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
-        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
-          hooks.push({ hookedCommand, callback });
-        });
-      });
-      if (event === "postAction") {
-        hooks.reverse();
-      }
-      hooks.forEach((hookDetail) => {
-        result = this._chainOrCall(result, () => {
-          return hookDetail.callback(hookDetail.hookedCommand, this);
-        });
-      });
-      return result;
-    }
-    _chainOrCallSubCommandHook(promise, subCommand, event) {
-      let result = promise;
-      if (this._lifeCycleHooks[event] !== undefined) {
-        this._lifeCycleHooks[event].forEach((hook) => {
-          result = this._chainOrCall(result, () => {
-            return hook(this, subCommand);
-          });
-        });
-      }
-      return result;
-    }
-    _parseCommand(operands, unknown) {
-      const parsed = this.parseOptions(unknown);
-      this._parseOptionsEnv();
-      this._parseOptionsImplied();
-      operands = operands.concat(parsed.operands);
-      unknown = parsed.unknown;
-      this.args = operands.concat(unknown);
-      if (operands && this._findCommand(operands[0])) {
-        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
-      }
-      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
-        return this._dispatchHelpCommand(operands[1]);
-      }
-      if (this._defaultCommandName) {
-        this._outputHelpIfRequested(unknown);
-        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
-      }
-      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
-        this.help({ error: true });
-      }
-      this._outputHelpIfRequested(parsed.unknown);
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      const checkForUnknownOptions = () => {
-        if (parsed.unknown.length > 0) {
-          this.unknownOption(parsed.unknown[0]);
-        }
-      };
-      const commandEvent = `command:${this.name()}`;
-      if (this._actionHandler) {
-        checkForUnknownOptions();
-        this._processArguments();
-        let promiseChain;
-        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
-        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
-        if (this.parent) {
-          promiseChain = this._chainOrCall(promiseChain, () => {
-            this.parent.emit(commandEvent, operands, unknown);
-          });
-        }
-        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
-        return promiseChain;
-      }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
-        checkForUnknownOptions();
-        this._processArguments();
-        this.parent.emit(commandEvent, operands, unknown);
-      } else if (operands.length) {
-        if (this._findCommand("*")) {
-          return this._dispatchSubcommand("*", operands, unknown);
-        }
-        if (this.listenerCount("command:*")) {
-          this.emit("command:*", operands, unknown);
-        } else if (this.commands.length) {
-          this.unknownCommand();
-        } else {
-          checkForUnknownOptions();
-          this._processArguments();
-        }
-      } else if (this.commands.length) {
-        checkForUnknownOptions();
-        this.help({ error: true });
-      } else {
-        checkForUnknownOptions();
-        this._processArguments();
-      }
-    }
-    _findCommand(name) {
-      if (!name)
-        return;
-      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
-    }
-    _findOption(arg) {
-      return this.options.find((option) => option.is(arg));
-    }
-    _checkForMissingMandatoryOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd.options.forEach((anOption) => {
-          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
-            cmd.missingMandatoryOptionValue(anOption);
-          }
-        });
-      });
-    }
-    _checkForConflictingLocalOptions() {
-      const definedNonDefaultOptions = this.options.filter((option) => {
-        const optionKey = option.attributeName();
-        if (this.getOptionValue(optionKey) === undefined) {
-          return false;
-        }
-        return this.getOptionValueSource(optionKey) !== "default";
-      });
-      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
-      optionsWithConflicting.forEach((option) => {
-        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
-        if (conflictingAndDefined) {
-          this._conflictingOption(option, conflictingAndDefined);
-        }
-      });
-    }
-    _checkForConflictingOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd._checkForConflictingLocalOptions();
-      });
-    }
-    parseOptions(argv) {
-      const operands = [];
-      const unknown = [];
-      let dest = operands;
-      const args = argv.slice();
-      function maybeOption(arg) {
-        return arg.length > 1 && arg[0] === "-";
-      }
-      const negativeNumberArg = (arg) => {
-        if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg))
-          return false;
-        return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
-      };
-      let activeVariadicOption = null;
-      while (args.length) {
-        const arg = args.shift();
-        if (arg === "--") {
-          if (dest === unknown)
-            dest.push(arg);
-          dest.push(...args);
-          break;
-        }
-        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
-          this.emit(`option:${activeVariadicOption.name()}`, arg);
-          continue;
-        }
-        activeVariadicOption = null;
-        if (maybeOption(arg)) {
-          const option = this._findOption(arg);
-          if (option) {
-            if (option.required) {
-              const value = args.shift();
-              if (value === undefined)
-                this.optionMissingArgument(option);
-              this.emit(`option:${option.name()}`, value);
-            } else if (option.optional) {
-              let value = null;
-              if (args.length > 0 && (!maybeOption(args[0]) || negativeNumberArg(args[0]))) {
-                value = args.shift();
-              }
-              this.emit(`option:${option.name()}`, value);
-            } else {
-              this.emit(`option:${option.name()}`);
-            }
-            activeVariadicOption = option.variadic ? option : null;
-            continue;
-          }
-        }
-        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
-          const option = this._findOption(`-${arg[1]}`);
-          if (option) {
-            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
-              this.emit(`option:${option.name()}`, arg.slice(2));
-            } else {
-              this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
-            }
-            continue;
-          }
-        }
-        if (/^--[^=]+=/.test(arg)) {
-          const index = arg.indexOf("=");
-          const option = this._findOption(arg.slice(0, index));
-          if (option && (option.required || option.optional)) {
-            this.emit(`option:${option.name()}`, arg.slice(index + 1));
-            continue;
-          }
-        }
-        if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
-          dest = unknown;
-        }
-        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
-          if (this._findCommand(arg)) {
-            operands.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0)
-              operands.push(...args);
-            break;
-          } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          }
-        }
-        if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0)
-            dest.push(...args);
-          break;
-        }
-        dest.push(arg);
-      }
-      return { operands, unknown };
-    }
-    opts() {
-      if (this._storeOptionsAsProperties) {
-        const result = {};
-        const len = this.options.length;
-        for (let i = 0;i < len; i++) {
-          const key = this.options[i].attributeName();
-          result[key] = key === this._versionOptionName ? this._version : this[key];
-        }
-        return result;
-      }
-      return this._optionValues;
-    }
-    optsWithGlobals() {
-      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
-    }
-    error(message, errorOptions) {
-      this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
-      if (typeof this._showHelpAfterError === "string") {
-        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
-`);
-      } else if (this._showHelpAfterError) {
-        this._outputConfiguration.writeErr(`
-`);
-        this.outputHelp({ error: true });
-      }
-      const config = errorOptions || {};
-      const exitCode = config.exitCode || 1;
-      const code = config.code || "commander.error";
-      this._exit(exitCode, code, message);
-    }
-    _parseOptionsEnv() {
-      this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
-          const optionKey = option.attributeName();
-          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
-            if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
-            } else {
-              this.emit(`optionEnv:${option.name()}`);
-            }
-          }
-        }
-      });
-    }
-    _parseOptionsImplied() {
-      const dualHelper = new DualOptions(this.options);
-      const hasCustomOptionValue = (optionKey) => {
-        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
-      };
-      this.options.filter((option) => option.implied !== undefined && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
-        Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
-          this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
-        });
-      });
-    }
-    missingArgument(name) {
-      const message = `error: missing required argument '${name}'`;
-      this.error(message, { code: "commander.missingArgument" });
-    }
-    optionMissingArgument(option) {
-      const message = `error: option '${option.flags}' argument missing`;
-      this.error(message, { code: "commander.optionMissingArgument" });
-    }
-    missingMandatoryOptionValue(option) {
-      const message = `error: required option '${option.flags}' not specified`;
-      this.error(message, { code: "commander.missingMandatoryOptionValue" });
-    }
-    _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
-        const optionValue = this.getOptionValue(optionKey);
-        const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
-        const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
-        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
-          return negativeOption;
-        }
-        return positiveOption || option2;
-      };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
-        const optionKey = bestOption.attributeName();
-        const source = this.getOptionValueSource(optionKey);
-        if (source === "env") {
-          return `environment variable '${bestOption.envVar}'`;
-        }
-        return `option '${bestOption.flags}'`;
-      };
-      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
-      this.error(message, { code: "commander.conflictingOption" });
-    }
-    unknownOption(flag) {
-      if (this._allowUnknownOption)
-        return;
-      let suggestion = "";
-      if (flag.startsWith("--") && this._showSuggestionAfterError) {
-        let candidateFlags = [];
-        let command = this;
-        do {
-          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
-          candidateFlags = candidateFlags.concat(moreFlags);
-          command = command.parent;
-        } while (command && !command._enablePositionalOptions);
-        suggestion = suggestSimilar(flag, candidateFlags);
-      }
-      const message = `error: unknown option '${flag}'${suggestion}`;
-      this.error(message, { code: "commander.unknownOption" });
-    }
-    _excessArguments(receivedArgs) {
-      if (this._allowExcessArguments)
-        return;
-      const expected = this.registeredArguments.length;
-      const s = expected === 1 ? "" : "s";
-      const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
-      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
-      this.error(message, { code: "commander.excessArguments" });
-    }
-    unknownCommand() {
-      const unknownName = this.args[0];
-      let suggestion = "";
-      if (this._showSuggestionAfterError) {
-        const candidateNames = [];
-        this.createHelp().visibleCommands(this).forEach((command) => {
-          candidateNames.push(command.name());
-          if (command.alias())
-            candidateNames.push(command.alias());
-        });
-        suggestion = suggestSimilar(unknownName, candidateNames);
-      }
-      const message = `error: unknown command '${unknownName}'${suggestion}`;
-      this.error(message, { code: "commander.unknownCommand" });
-    }
-    version(str, flags, description) {
-      if (str === undefined)
-        return this._version;
-      this._version = str;
-      flags = flags || "-V, --version";
-      description = description || "output the version number";
-      const versionOption = this.createOption(flags, description);
-      this._versionOptionName = versionOption.attributeName();
-      this._registerOption(versionOption);
-      this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str}
-`);
-        this._exit(0, "commander.version", str);
-      });
-      return this;
-    }
-    description(str, argsDescription) {
-      if (str === undefined && argsDescription === undefined)
-        return this._description;
-      this._description = str;
-      if (argsDescription) {
-        this._argsDescription = argsDescription;
-      }
-      return this;
-    }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        return this._aliases[0];
-      let command = this;
-      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command = this.commands[this.commands.length - 1];
-      }
-      if (alias === command._name)
-        throw new Error("Command alias can't be the same as its name");
-      const matchingCommand = this.parent?._findCommand(alias);
-      if (matchingCommand) {
-        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
-        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
-      }
-      command._aliases.push(alias);
-      return this;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        const args = this.registeredArguments.map((arg) => {
-          return humanReadableArgName(arg);
-        });
-        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
-      }
-      this._usage = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    helpGroup(heading) {
-      if (heading === undefined)
-        return this._helpGroupHeading ?? "";
-      this._helpGroupHeading = heading;
-      return this;
-    }
-    commandsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultCommandGroup ?? "";
-      this._defaultCommandGroup = heading;
-      return this;
-    }
-    optionsGroup(heading) {
-      if (heading === undefined)
-        return this._defaultOptionGroup ?? "";
-      this._defaultOptionGroup = heading;
-      return this;
-    }
-    _initOptionGroup(option) {
-      if (this._defaultOptionGroup && !option.helpGroupHeading)
-        option.helpGroup(this._defaultOptionGroup);
-    }
-    _initCommandGroup(cmd) {
-      if (this._defaultCommandGroup && !cmd.helpGroup())
-        cmd.helpGroup(this._defaultCommandGroup);
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    helpInformation(contextOptions) {
-      const helper = this.createHelp();
-      const context = this._getOutputContext(contextOptions);
-      helper.prepareContext({
-        error: context.error,
-        helpWidth: context.helpWidth,
-        outputHasColors: context.hasColors
-      });
-      const text = helper.formatHelp(this, helper);
-      if (context.hasColors)
-        return text;
-      return this._outputConfiguration.stripColor(text);
-    }
-    _getOutputContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const error = !!contextOptions.error;
-      let baseWrite;
-      let hasColors;
-      let helpWidth;
-      if (error) {
-        baseWrite = (str) => this._outputConfiguration.writeErr(str);
-        hasColors = this._outputConfiguration.getErrHasColors();
-        helpWidth = this._outputConfiguration.getErrHelpWidth();
-      } else {
-        baseWrite = (str) => this._outputConfiguration.writeOut(str);
-        hasColors = this._outputConfiguration.getOutHasColors();
-        helpWidth = this._outputConfiguration.getOutHelpWidth();
-      }
-      const write = (str) => {
-        if (!hasColors)
-          str = this._outputConfiguration.stripColor(str);
-        return baseWrite(str);
-      };
-      return { error, write, hasColors, helpWidth };
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        deprecatedCallback = contextOptions;
-        contextOptions = undefined;
-      }
-      const outputContext = this._getOutputContext(contextOptions);
-      const eventContext = {
-        error: outputContext.error,
-        write: outputContext.write,
-        command: this
-      };
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
-      this.emit("beforeHelp", eventContext);
-      let helpInformation = this.helpInformation({ error: outputContext.error });
-      if (deprecatedCallback) {
-        helpInformation = deprecatedCallback(helpInformation);
-        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
-          throw new Error("outputHelp callback must return a string or a Buffer");
-        }
-      }
-      outputContext.write(helpInformation);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
-      }
-      this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          if (this._helpOption === null)
-            this._helpOption = undefined;
-          if (this._defaultOptionGroup) {
-            this._initOptionGroup(this._getHelpOption());
-          }
-        } else {
-          this._helpOption = null;
-        }
-        return this;
-      }
-      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
-      if (flags || description)
-        this._initOptionGroup(this._helpOption);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
-      this._initOptionGroup(option);
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      return this;
-    }
-    _outputHelpIfRequested(args) {
-      const helpOption = this._getHelpOption();
-      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
-      if (helpRequested) {
-        this.outputHelp();
-        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
-    }
-  }
-  function incrementNodeInspectorPort(args) {
-    return args.map((arg) => {
-      if (!arg.startsWith("--inspect")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
-    });
-  }
-  function useColor() {
-    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
-      return false;
-    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
-      return true;
-    return;
-  }
-  exports.Command = Command;
-  exports.useColor = useColor;
-});
-
-// node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
-
-// node_modules/universalify/index.js
-var require_universalify = __commonJS((exports) => {
-  exports.fromCallback = function(fn) {
-    return Object.defineProperty(function(...args) {
-      if (typeof args[args.length - 1] === "function")
-        fn.apply(this, args);
-      else {
-        return new Promise((resolve, reject) => {
-          args.push((err, res) => err != null ? reject(err) : resolve(res));
-          fn.apply(this, args);
-        });
-      }
-    }, "name", { value: fn.name });
-  };
-  exports.fromPromise = function(fn) {
-    return Object.defineProperty(function(...args) {
-      const cb = args[args.length - 1];
-      if (typeof cb !== "function")
-        return fn.apply(this, args);
-      else {
-        args.pop();
-        fn.apply(this, args).then((r) => cb(null, r), cb);
-      }
-    }, "name", { value: fn.name });
-  };
-});
-
-// node_modules/graceful-fs/polyfills.js
-var require_polyfills = __commonJS((exports, module) => {
-  var constants = __require("constants");
-  var origCwd = process.cwd;
-  var cwd = null;
-  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-  process.cwd = function() {
-    if (!cwd)
-      cwd = origCwd.call(process);
-    return cwd;
-  };
-  try {
-    process.cwd();
-  } catch (er) {}
-  if (typeof process.chdir === "function") {
-    chdir = process.chdir;
-    process.chdir = function(d) {
-      cwd = null;
-      chdir.call(process, d);
-    };
-    if (Object.setPrototypeOf)
-      Object.setPrototypeOf(process.chdir, chdir);
-  }
-  var chdir;
-  module.exports = patch;
-  function patch(fs) {
-    if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-      patchLchmod(fs);
-    }
-    if (!fs.lutimes) {
-      patchLutimes(fs);
-    }
-    fs.chown = chownFix(fs.chown);
-    fs.fchown = chownFix(fs.fchown);
-    fs.lchown = chownFix(fs.lchown);
-    fs.chmod = chmodFix(fs.chmod);
-    fs.fchmod = chmodFix(fs.fchmod);
-    fs.lchmod = chmodFix(fs.lchmod);
-    fs.chownSync = chownFixSync(fs.chownSync);
-    fs.fchownSync = chownFixSync(fs.fchownSync);
-    fs.lchownSync = chownFixSync(fs.lchownSync);
-    fs.chmodSync = chmodFixSync(fs.chmodSync);
-    fs.fchmodSync = chmodFixSync(fs.fchmodSync);
-    fs.lchmodSync = chmodFixSync(fs.lchmodSync);
-    fs.stat = statFix(fs.stat);
-    fs.fstat = statFix(fs.fstat);
-    fs.lstat = statFix(fs.lstat);
-    fs.statSync = statFixSync(fs.statSync);
-    fs.fstatSync = statFixSync(fs.fstatSync);
-    fs.lstatSync = statFixSync(fs.lstatSync);
-    if (fs.chmod && !fs.lchmod) {
-      fs.lchmod = function(path, mode, cb) {
-        if (cb)
-          process.nextTick(cb);
-      };
-      fs.lchmodSync = function() {};
-    }
-    if (fs.chown && !fs.lchown) {
-      fs.lchown = function(path, uid, gid, cb) {
-        if (cb)
-          process.nextTick(cb);
-      };
-      fs.lchownSync = function() {};
-    }
-    if (platform === "win32") {
-      fs.rename = typeof fs.rename !== "function" ? fs.rename : function(fs$rename) {
-        function rename(from, to, cb) {
-          var start = Date.now();
-          var backoff = 0;
-          fs$rename(from, to, function CB(er) {
-            if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 60000) {
-              setTimeout(function() {
-                fs.stat(to, function(stater, st) {
-                  if (stater && stater.code === "ENOENT")
-                    fs$rename(from, to, CB);
-                  else
-                    cb(er);
-                });
-              }, backoff);
-              if (backoff < 100)
-                backoff += 10;
-              return;
-            }
-            if (cb)
-              cb(er);
-          });
-        }
-        if (Object.setPrototypeOf)
-          Object.setPrototypeOf(rename, fs$rename);
-        return rename;
-      }(fs.rename);
-    }
-    fs.read = typeof fs.read !== "function" ? fs.read : function(fs$read) {
-      function read(fd, buffer, offset, length, position, callback_) {
-        var callback;
-        if (callback_ && typeof callback_ === "function") {
-          var eagCounter = 0;
-          callback = function(er, _, __) {
-            if (er && er.code === "EAGAIN" && eagCounter < 10) {
-              eagCounter++;
-              return fs$read.call(fs, fd, buffer, offset, length, position, callback);
-            }
-            callback_.apply(this, arguments);
-          };
-        }
-        return fs$read.call(fs, fd, buffer, offset, length, position, callback);
-      }
-      if (Object.setPrototypeOf)
-        Object.setPrototypeOf(read, fs$read);
-      return read;
-    }(fs.read);
-    fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : function(fs$readSync) {
-      return function(fd, buffer, offset, length, position) {
-        var eagCounter = 0;
-        while (true) {
-          try {
-            return fs$readSync.call(fs, fd, buffer, offset, length, position);
-          } catch (er) {
-            if (er.code === "EAGAIN" && eagCounter < 10) {
-              eagCounter++;
-              continue;
-            }
-            throw er;
-          }
-        }
-      };
-    }(fs.readSync);
-    function patchLchmod(fs2) {
-      fs2.lchmod = function(path, mode, callback) {
-        fs2.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
-          if (err) {
-            if (callback)
-              callback(err);
-            return;
-          }
-          fs2.fchmod(fd, mode, function(err2) {
-            fs2.close(fd, function(err22) {
-              if (callback)
-                callback(err2 || err22);
-            });
-          });
-        });
-      };
-      fs2.lchmodSync = function(path, mode) {
-        var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
-        var threw = true;
-        var ret;
-        try {
-          ret = fs2.fchmodSync(fd, mode);
-          threw = false;
-        } finally {
-          if (threw) {
-            try {
-              fs2.closeSync(fd);
-            } catch (er) {}
-          } else {
-            fs2.closeSync(fd);
-          }
-        }
-        return ret;
-      };
-    }
-    function patchLutimes(fs2) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
-        fs2.lutimes = function(path, at, mt, cb) {
-          fs2.open(path, constants.O_SYMLINK, function(er, fd) {
-            if (er) {
-              if (cb)
-                cb(er);
-              return;
-            }
-            fs2.futimes(fd, at, mt, function(er2) {
-              fs2.close(fd, function(er22) {
-                if (cb)
-                  cb(er2 || er22);
-              });
-            });
-          });
-        };
-        fs2.lutimesSync = function(path, at, mt) {
-          var fd = fs2.openSync(path, constants.O_SYMLINK);
-          var ret;
-          var threw = true;
-          try {
-            ret = fs2.futimesSync(fd, at, mt);
-            threw = false;
-          } finally {
-            if (threw) {
-              try {
-                fs2.closeSync(fd);
-              } catch (er) {}
-            } else {
-              fs2.closeSync(fd);
-            }
-          }
-          return ret;
-        };
-      } else if (fs2.futimes) {
-        fs2.lutimes = function(_a, _b, _c, cb) {
-          if (cb)
-            process.nextTick(cb);
-        };
-        fs2.lutimesSync = function() {};
-      }
-    }
-    function chmodFix(orig) {
-      if (!orig)
-        return orig;
-      return function(target, mode, cb) {
-        return orig.call(fs, target, mode, function(er) {
-          if (chownErOk(er))
-            er = null;
-          if (cb)
-            cb.apply(this, arguments);
-        });
-      };
-    }
-    function chmodFixSync(orig) {
-      if (!orig)
-        return orig;
-      return function(target, mode) {
-        try {
-          return orig.call(fs, target, mode);
-        } catch (er) {
-          if (!chownErOk(er))
-            throw er;
-        }
-      };
-    }
-    function chownFix(orig) {
-      if (!orig)
-        return orig;
-      return function(target, uid, gid, cb) {
-        return orig.call(fs, target, uid, gid, function(er) {
-          if (chownErOk(er))
-            er = null;
-          if (cb)
-            cb.apply(this, arguments);
-        });
-      };
-    }
-    function chownFixSync(orig) {
-      if (!orig)
-        return orig;
-      return function(target, uid, gid) {
-        try {
-          return orig.call(fs, target, uid, gid);
-        } catch (er) {
-          if (!chownErOk(er))
-            throw er;
-        }
-      };
-    }
-    function statFix(orig) {
-      if (!orig)
-        return orig;
-      return function(target, options, cb) {
-        if (typeof options === "function") {
-          cb = options;
-          options = null;
-        }
-        function callback(er, stats) {
-          if (stats) {
-            if (stats.uid < 0)
-              stats.uid += 4294967296;
-            if (stats.gid < 0)
-              stats.gid += 4294967296;
-          }
-          if (cb)
-            cb.apply(this, arguments);
-        }
-        return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
-      };
-    }
-    function statFixSync(orig) {
-      if (!orig)
-        return orig;
-      return function(target, options) {
-        var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
-        if (stats) {
-          if (stats.uid < 0)
-            stats.uid += 4294967296;
-          if (stats.gid < 0)
-            stats.gid += 4294967296;
-        }
-        return stats;
-      };
-    }
-    function chownErOk(er) {
-      if (!er)
-        return true;
-      if (er.code === "ENOSYS")
-        return true;
-      var nonroot = !process.getuid || process.getuid() !== 0;
-      if (nonroot) {
-        if (er.code === "EINVAL" || er.code === "EPERM")
-          return true;
-      }
-      return false;
-    }
-  }
-});
-
-// node_modules/graceful-fs/legacy-streams.js
-var require_legacy_streams = __commonJS((exports, module) => {
-  var Stream = __require("stream").Stream;
-  module.exports = legacy;
-  function legacy(fs) {
-    return {
-      ReadStream,
-      WriteStream
-    };
-    function ReadStream(path, options) {
-      if (!(this instanceof ReadStream))
-        return new ReadStream(path, options);
-      Stream.call(this);
-      var self = this;
-      this.path = path;
-      this.fd = null;
-      this.readable = true;
-      this.paused = false;
-      this.flags = "r";
-      this.mode = 438;
-      this.bufferSize = 64 * 1024;
-      options = options || {};
-      var keys = Object.keys(options);
-      for (var index = 0, length = keys.length;index < length; index++) {
-        var key = keys[index];
-        this[key] = options[key];
-      }
-      if (this.encoding)
-        this.setEncoding(this.encoding);
-      if (this.start !== undefined) {
-        if (typeof this.start !== "number") {
-          throw TypeError("start must be a Number");
-        }
-        if (this.end === undefined) {
-          this.end = Infinity;
-        } else if (typeof this.end !== "number") {
-          throw TypeError("end must be a Number");
-        }
-        if (this.start > this.end) {
-          throw new Error("start must be <= end");
-        }
-        this.pos = this.start;
-      }
-      if (this.fd !== null) {
-        process.nextTick(function() {
-          self._read();
-        });
-        return;
-      }
-      fs.open(this.path, this.flags, this.mode, function(err, fd) {
-        if (err) {
-          self.emit("error", err);
-          self.readable = false;
-          return;
-        }
-        self.fd = fd;
-        self.emit("open", fd);
-        self._read();
-      });
-    }
-    function WriteStream(path, options) {
-      if (!(this instanceof WriteStream))
-        return new WriteStream(path, options);
-      Stream.call(this);
-      this.path = path;
-      this.fd = null;
-      this.writable = true;
-      this.flags = "w";
-      this.encoding = "binary";
-      this.mode = 438;
-      this.bytesWritten = 0;
-      options = options || {};
-      var keys = Object.keys(options);
-      for (var index = 0, length = keys.length;index < length; index++) {
-        var key = keys[index];
-        this[key] = options[key];
-      }
-      if (this.start !== undefined) {
-        if (typeof this.start !== "number") {
-          throw TypeError("start must be a Number");
-        }
-        if (this.start < 0) {
-          throw new Error("start must be >= zero");
-        }
-        this.pos = this.start;
-      }
-      this.busy = false;
-      this._queue = [];
-      if (this.fd === null) {
-        this._open = fs.open;
-        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
-        this.flush();
-      }
-    }
-  }
-});
-
-// node_modules/graceful-fs/clone.js
-var require_clone = __commonJS((exports, module) => {
-  module.exports = clone;
-  var getPrototypeOf = Object.getPrototypeOf || function(obj) {
-    return obj.__proto__;
-  };
-  function clone(obj) {
-    if (obj === null || typeof obj !== "object")
-      return obj;
-    if (obj instanceof Object)
-      var copy = { __proto__: getPrototypeOf(obj) };
-    else
-      var copy = Object.create(null);
-    Object.getOwnPropertyNames(obj).forEach(function(key) {
-      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
-    });
-    return copy;
-  }
-});
-
-// node_modules/graceful-fs/graceful-fs.js
-var require_graceful_fs = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var polyfills = require_polyfills();
-  var legacy = require_legacy_streams();
-  var clone = require_clone();
-  var util = __require("util");
-  var gracefulQueue;
-  var previousSymbol;
-  if (typeof Symbol === "function" && typeof Symbol.for === "function") {
-    gracefulQueue = Symbol.for("graceful-fs.queue");
-    previousSymbol = Symbol.for("graceful-fs.previous");
-  } else {
-    gracefulQueue = "___graceful-fs.queue";
-    previousSymbol = "___graceful-fs.previous";
-  }
-  function noop() {}
-  function publishQueue(context, queue2) {
-    Object.defineProperty(context, gracefulQueue, {
-      get: function() {
-        return queue2;
-      }
-    });
-  }
-  var debug = noop;
-  if (util.debuglog)
-    debug = util.debuglog("gfs4");
-  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-    debug = function() {
-      var m = util.format.apply(util, arguments);
-      m = "GFS4: " + m.split(/\n/).join(`
-GFS4: `);
-      console.error(m);
-    };
-  if (!fs[gracefulQueue]) {
-    queue = global[gracefulQueue] || [];
-    publishQueue(fs, queue);
-    fs.close = function(fs$close) {
-      function close(fd, cb) {
-        return fs$close.call(fs, fd, function(err) {
-          if (!err) {
-            resetQueue();
-          }
-          if (typeof cb === "function")
-            cb.apply(this, arguments);
-        });
-      }
-      Object.defineProperty(close, previousSymbol, {
-        value: fs$close
-      });
-      return close;
-    }(fs.close);
-    fs.closeSync = function(fs$closeSync) {
-      function closeSync(fd) {
-        fs$closeSync.apply(fs, arguments);
-        resetQueue();
-      }
-      Object.defineProperty(closeSync, previousSymbol, {
-        value: fs$closeSync
-      });
-      return closeSync;
-    }(fs.closeSync);
-    if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
-      process.on("exit", function() {
-        debug(fs[gracefulQueue]);
-        __require("assert").equal(fs[gracefulQueue].length, 0);
-      });
-    }
-  }
-  var queue;
-  if (!global[gracefulQueue]) {
-    publishQueue(global, fs[gracefulQueue]);
-  }
-  module.exports = patch(clone(fs));
-  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-    module.exports = patch(fs);
-    fs.__patched = true;
-  }
-  function patch(fs2) {
-    polyfills(fs2);
-    fs2.gracefulify = patch;
-    fs2.createReadStream = createReadStream;
-    fs2.createWriteStream = createWriteStream;
-    var fs$readFile = fs2.readFile;
-    fs2.readFile = readFile;
-    function readFile(path, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      return go$readFile(path, options, cb);
-      function go$readFile(path2, options2, cb2, startTime) {
-        return fs$readFile(path2, options2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$writeFile = fs2.writeFile;
-    fs2.writeFile = writeFile;
-    function writeFile(path, data, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      return go$writeFile(path, data, options, cb);
-      function go$writeFile(path2, data2, options2, cb2, startTime) {
-        return fs$writeFile(path2, data2, options2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$appendFile = fs2.appendFile;
-    if (fs$appendFile)
-      fs2.appendFile = appendFile;
-    function appendFile(path, data, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      return go$appendFile(path, data, options, cb);
-      function go$appendFile(path2, data2, options2, cb2, startTime) {
-        return fs$appendFile(path2, data2, options2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$copyFile = fs2.copyFile;
-    if (fs$copyFile)
-      fs2.copyFile = copyFile;
-    function copyFile(src, dest, flags, cb) {
-      if (typeof flags === "function") {
-        cb = flags;
-        flags = 0;
-      }
-      return go$copyFile(src, dest, flags, cb);
-      function go$copyFile(src2, dest2, flags2, cb2, startTime) {
-        return fs$copyFile(src2, dest2, flags2, function(err) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    var fs$readdir = fs2.readdir;
-    fs2.readdir = readdir;
-    var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir(path, options, cb) {
-      if (typeof options === "function")
-        cb = options, options = null;
-      var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path2, options2, cb2, startTime) {
-        return fs$readdir(path2, fs$readdirCallback(path2, options2, cb2, startTime));
-      } : function go$readdir(path2, options2, cb2, startTime) {
-        return fs$readdir(path2, options2, fs$readdirCallback(path2, options2, cb2, startTime));
-      };
-      return go$readdir(path, options, cb);
-      function fs$readdirCallback(path2, options2, cb2, startTime) {
-        return function(err, files) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([
-              go$readdir,
-              [path2, options2, cb2],
-              err,
-              startTime || Date.now(),
-              Date.now()
-            ]);
-          else {
-            if (files && files.sort)
-              files.sort();
-            if (typeof cb2 === "function")
-              cb2.call(this, err, files);
-          }
-        };
-      }
-    }
-    if (process.version.substr(0, 4) === "v0.8") {
-      var legStreams = legacy(fs2);
-      ReadStream = legStreams.ReadStream;
-      WriteStream = legStreams.WriteStream;
-    }
-    var fs$ReadStream = fs2.ReadStream;
-    if (fs$ReadStream) {
-      ReadStream.prototype = Object.create(fs$ReadStream.prototype);
-      ReadStream.prototype.open = ReadStream$open;
-    }
-    var fs$WriteStream = fs2.WriteStream;
-    if (fs$WriteStream) {
-      WriteStream.prototype = Object.create(fs$WriteStream.prototype);
-      WriteStream.prototype.open = WriteStream$open;
-    }
-    Object.defineProperty(fs2, "ReadStream", {
-      get: function() {
-        return ReadStream;
-      },
-      set: function(val) {
-        ReadStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    Object.defineProperty(fs2, "WriteStream", {
-      get: function() {
-        return WriteStream;
-      },
-      set: function(val) {
-        WriteStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    var FileReadStream = ReadStream;
-    Object.defineProperty(fs2, "FileReadStream", {
-      get: function() {
-        return FileReadStream;
-      },
-      set: function(val) {
-        FileReadStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    var FileWriteStream = WriteStream;
-    Object.defineProperty(fs2, "FileWriteStream", {
-      get: function() {
-        return FileWriteStream;
-      },
-      set: function(val) {
-        FileWriteStream = val;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    function ReadStream(path, options) {
-      if (this instanceof ReadStream)
-        return fs$ReadStream.apply(this, arguments), this;
-      else
-        return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
-    }
-    function ReadStream$open() {
-      var that = this;
-      open(that.path, that.flags, that.mode, function(err, fd) {
-        if (err) {
-          if (that.autoClose)
-            that.destroy();
-          that.emit("error", err);
-        } else {
-          that.fd = fd;
-          that.emit("open", fd);
-          that.read();
-        }
-      });
-    }
-    function WriteStream(path, options) {
-      if (this instanceof WriteStream)
-        return fs$WriteStream.apply(this, arguments), this;
-      else
-        return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
-    }
-    function WriteStream$open() {
-      var that = this;
-      open(that.path, that.flags, that.mode, function(err, fd) {
-        if (err) {
-          that.destroy();
-          that.emit("error", err);
-        } else {
-          that.fd = fd;
-          that.emit("open", fd);
-        }
-      });
-    }
-    function createReadStream(path, options) {
-      return new fs2.ReadStream(path, options);
-    }
-    function createWriteStream(path, options) {
-      return new fs2.WriteStream(path, options);
-    }
-    var fs$open = fs2.open;
-    fs2.open = open;
-    function open(path, flags, mode, cb) {
-      if (typeof mode === "function")
-        cb = mode, mode = null;
-      return go$open(path, flags, mode, cb);
-      function go$open(path2, flags2, mode2, cb2, startTime) {
-        return fs$open(path2, flags2, mode2, function(err, fd) {
-          if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
-          else {
-            if (typeof cb2 === "function")
-              cb2.apply(this, arguments);
-          }
-        });
-      }
-    }
-    return fs2;
-  }
-  function enqueue(elem) {
-    debug("ENQUEUE", elem[0].name, elem[1]);
-    fs[gracefulQueue].push(elem);
-    retry();
-  }
-  var retryTimer;
-  function resetQueue() {
-    var now = Date.now();
-    for (var i = 0;i < fs[gracefulQueue].length; ++i) {
-      if (fs[gracefulQueue][i].length > 2) {
-        fs[gracefulQueue][i][3] = now;
-        fs[gracefulQueue][i][4] = now;
-      }
-    }
-    retry();
-  }
-  function retry() {
-    clearTimeout(retryTimer);
-    retryTimer = undefined;
-    if (fs[gracefulQueue].length === 0)
-      return;
-    var elem = fs[gracefulQueue].shift();
-    var fn = elem[0];
-    var args = elem[1];
-    var err = elem[2];
-    var startTime = elem[3];
-    var lastTime = elem[4];
-    if (startTime === undefined) {
-      debug("RETRY", fn.name, args);
-      fn.apply(null, args);
-    } else if (Date.now() - startTime >= 60000) {
-      debug("TIMEOUT", fn.name, args);
-      var cb = args.pop();
-      if (typeof cb === "function")
-        cb.call(null, err);
-    } else {
-      var sinceAttempt = Date.now() - lastTime;
-      var sinceStart = Math.max(lastTime - startTime, 1);
-      var desiredDelay = Math.min(sinceStart * 1.2, 100);
-      if (sinceAttempt >= desiredDelay) {
-        debug("RETRY", fn.name, args);
-        fn.apply(null, args.concat([startTime]));
-      } else {
-        fs[gracefulQueue].push(elem);
-      }
-    }
-    if (retryTimer === undefined) {
-      retryTimer = setTimeout(retry, 0);
-    }
-  }
-});
-
-// node_modules/fs-extra/lib/fs/index.js
-var require_fs = __commonJS((exports) => {
-  var u = require_universalify().fromCallback;
-  var fs = require_graceful_fs();
-  var api = [
-    "access",
-    "appendFile",
-    "chmod",
-    "chown",
-    "close",
-    "copyFile",
-    "cp",
-    "fchmod",
-    "fchown",
-    "fdatasync",
-    "fstat",
-    "fsync",
-    "ftruncate",
-    "futimes",
-    "glob",
-    "lchmod",
-    "lchown",
-    "lutimes",
-    "link",
-    "lstat",
-    "mkdir",
-    "mkdtemp",
-    "open",
-    "opendir",
-    "readdir",
-    "readFile",
-    "readlink",
-    "realpath",
-    "rename",
-    "rm",
-    "rmdir",
-    "stat",
-    "statfs",
-    "symlink",
-    "truncate",
-    "unlink",
-    "utimes",
-    "writeFile"
-  ].filter((key) => {
-    return typeof fs[key] === "function";
-  });
-  Object.assign(exports, fs);
-  api.forEach((method) => {
-    exports[method] = u(fs[method]);
-  });
-  exports.exists = function(filename, callback) {
-    if (typeof callback === "function") {
-      return fs.exists(filename, callback);
-    }
-    return new Promise((resolve) => {
-      return fs.exists(filename, resolve);
-    });
-  };
-  exports.read = function(fd, buffer, offset, length, position, callback) {
-    if (typeof callback === "function") {
-      return fs.read(fd, buffer, offset, length, position, callback);
-    }
-    return new Promise((resolve, reject) => {
-      fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
-        if (err)
-          return reject(err);
-        resolve({ bytesRead, buffer: buffer2 });
-      });
-    });
-  };
-  exports.write = function(fd, buffer, ...args) {
-    if (typeof args[args.length - 1] === "function") {
-      return fs.write(fd, buffer, ...args);
-    }
-    return new Promise((resolve, reject) => {
-      fs.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
-        if (err)
-          return reject(err);
-        resolve({ bytesWritten, buffer: buffer2 });
-      });
-    });
-  };
-  exports.readv = function(fd, buffers, ...args) {
-    if (typeof args[args.length - 1] === "function") {
-      return fs.readv(fd, buffers, ...args);
-    }
-    return new Promise((resolve, reject) => {
-      fs.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
-        if (err)
-          return reject(err);
-        resolve({ bytesRead, buffers: buffers2 });
-      });
-    });
-  };
-  exports.writev = function(fd, buffers, ...args) {
-    if (typeof args[args.length - 1] === "function") {
-      return fs.writev(fd, buffers, ...args);
-    }
-    return new Promise((resolve, reject) => {
-      fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
-        if (err)
-          return reject(err);
-        resolve({ bytesWritten, buffers: buffers2 });
-      });
-    });
-  };
-  if (typeof fs.realpath.native === "function") {
-    exports.realpath.native = u(fs.realpath.native);
-  } else {
-    process.emitWarning("fs.realpath.native is not a function. Is fs being monkey-patched?", "Warning", "fs-extra-WARN0003");
-  }
-});
-
-// node_modules/fs-extra/lib/mkdirs/utils.js
-var require_utils = __commonJS((exports, module) => {
-  var path = __require("path");
-  exports.checkPath = function checkPath(pth) {
-    if (process.platform === "win32") {
-      const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
-      if (pathHasInvalidWinCharacters) {
-        const error = new Error(`Path contains invalid characters: ${pth}`);
-        error.code = "EINVAL";
-        throw error;
-      }
-    }
-  };
-});
-
-// node_modules/fs-extra/lib/mkdirs/make-dir.js
-var require_make_dir = __commonJS((exports, module) => {
-  var fs = require_fs();
-  var { checkPath } = require_utils();
-  var getMode = (options) => {
-    const defaults = { mode: 511 };
-    if (typeof options === "number")
-      return options;
-    return { ...defaults, ...options }.mode;
-  };
-  exports.makeDir = async (dir, options) => {
-    checkPath(dir);
-    return fs.mkdir(dir, {
-      mode: getMode(options),
-      recursive: true
-    });
-  };
-  exports.makeDirSync = (dir, options) => {
-    checkPath(dir);
-    return fs.mkdirSync(dir, {
-      mode: getMode(options),
-      recursive: true
-    });
-  };
-});
-
-// node_modules/fs-extra/lib/mkdirs/index.js
-var require_mkdirs = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var { makeDir: _makeDir, makeDirSync } = require_make_dir();
-  var makeDir = u(_makeDir);
-  module.exports = {
-    mkdirs: makeDir,
-    mkdirsSync: makeDirSync,
-    mkdirp: makeDir,
-    mkdirpSync: makeDirSync,
-    ensureDir: makeDir,
-    ensureDirSync: makeDirSync
-  };
-});
-
-// node_modules/fs-extra/lib/path-exists/index.js
-var require_path_exists = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var fs = require_fs();
-  function pathExists(path) {
-    return fs.access(path).then(() => true).catch(() => false);
-  }
-  module.exports = {
-    pathExists: u(pathExists),
-    pathExistsSync: fs.existsSync
-  };
-});
-
-// node_modules/fs-extra/lib/util/utimes.js
-var require_utimes = __commonJS((exports, module) => {
-  var fs = require_fs();
-  var u = require_universalify().fromPromise;
-  async function utimesMillis(path, atime, mtime) {
-    const fd = await fs.open(path, "r+");
-    let closeErr = null;
-    try {
-      await fs.futimes(fd, atime, mtime);
-    } finally {
-      try {
-        await fs.close(fd);
-      } catch (e) {
-        closeErr = e;
-      }
-    }
-    if (closeErr) {
-      throw closeErr;
-    }
-  }
-  function utimesMillisSync(path, atime, mtime) {
-    const fd = fs.openSync(path, "r+");
-    fs.futimesSync(fd, atime, mtime);
-    return fs.closeSync(fd);
-  }
-  module.exports = {
-    utimesMillis: u(utimesMillis),
-    utimesMillisSync
-  };
-});
-
-// node_modules/fs-extra/lib/util/stat.js
-var require_stat = __commonJS((exports, module) => {
-  var fs = require_fs();
-  var path = __require("path");
-  var u = require_universalify().fromPromise;
-  function getStats(src, dest, opts) {
-    const statFunc = opts.dereference ? (file) => fs.stat(file, { bigint: true }) : (file) => fs.lstat(file, { bigint: true });
-    return Promise.all([
-      statFunc(src),
-      statFunc(dest).catch((err) => {
-        if (err.code === "ENOENT")
-          return null;
-        throw err;
-      })
-    ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
-  }
-  function getStatsSync(src, dest, opts) {
-    let destStat;
-    const statFunc = opts.dereference ? (file) => fs.statSync(file, { bigint: true }) : (file) => fs.lstatSync(file, { bigint: true });
-    const srcStat = statFunc(src);
-    try {
-      destStat = statFunc(dest);
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return { srcStat, destStat: null };
-      throw err;
-    }
-    return { srcStat, destStat };
-  }
-  async function checkPaths(src, dest, funcName, opts) {
-    const { srcStat, destStat } = await getStats(src, dest, opts);
-    if (destStat) {
-      if (areIdentical(srcStat, destStat)) {
-        const srcBaseName = path.basename(src);
-        const destBaseName = path.basename(dest);
-        if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-          return { srcStat, destStat, isChangingCase: true };
-        }
-        throw new Error("Source and destination must not be the same.");
-      }
-      if (srcStat.isDirectory() && !destStat.isDirectory()) {
-        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
-      }
-      if (!srcStat.isDirectory() && destStat.isDirectory()) {
-        throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
-      }
-    }
-    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-      throw new Error(errMsg(src, dest, funcName));
-    }
-    return { srcStat, destStat };
-  }
-  function checkPathsSync(src, dest, funcName, opts) {
-    const { srcStat, destStat } = getStatsSync(src, dest, opts);
-    if (destStat) {
-      if (areIdentical(srcStat, destStat)) {
-        const srcBaseName = path.basename(src);
-        const destBaseName = path.basename(dest);
-        if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-          return { srcStat, destStat, isChangingCase: true };
-        }
-        throw new Error("Source and destination must not be the same.");
-      }
-      if (srcStat.isDirectory() && !destStat.isDirectory()) {
-        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
-      }
-      if (!srcStat.isDirectory() && destStat.isDirectory()) {
-        throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
-      }
-    }
-    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-      throw new Error(errMsg(src, dest, funcName));
-    }
-    return { srcStat, destStat };
-  }
-  async function checkParentPaths(src, srcStat, dest, funcName) {
-    const srcParent = path.resolve(path.dirname(src));
-    const destParent = path.resolve(path.dirname(dest));
-    if (destParent === srcParent || destParent === path.parse(destParent).root)
-      return;
-    let destStat;
-    try {
-      destStat = await fs.stat(destParent, { bigint: true });
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return;
-      throw err;
-    }
-    if (areIdentical(srcStat, destStat)) {
-      throw new Error(errMsg(src, dest, funcName));
-    }
-    return checkParentPaths(src, srcStat, destParent, funcName);
-  }
-  function checkParentPathsSync(src, srcStat, dest, funcName) {
-    const srcParent = path.resolve(path.dirname(src));
-    const destParent = path.resolve(path.dirname(dest));
-    if (destParent === srcParent || destParent === path.parse(destParent).root)
-      return;
-    let destStat;
-    try {
-      destStat = fs.statSync(destParent, { bigint: true });
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return;
-      throw err;
-    }
-    if (areIdentical(srcStat, destStat)) {
-      throw new Error(errMsg(src, dest, funcName));
-    }
-    return checkParentPathsSync(src, srcStat, destParent, funcName);
-  }
-  function areIdentical(srcStat, destStat) {
-    return destStat.ino !== undefined && destStat.dev !== undefined && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
-  }
-  function isSrcSubdir(src, dest) {
-    const srcArr = path.resolve(src).split(path.sep).filter((i) => i);
-    const destArr = path.resolve(dest).split(path.sep).filter((i) => i);
-    return srcArr.every((cur, i) => destArr[i] === cur);
-  }
-  function errMsg(src, dest, funcName) {
-    return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
-  }
-  module.exports = {
-    checkPaths: u(checkPaths),
-    checkPathsSync,
-    checkParentPaths: u(checkParentPaths),
-    checkParentPathsSync,
-    isSrcSubdir,
-    areIdentical
-  };
-});
-
-// node_modules/fs-extra/lib/copy/copy.js
-var require_copy = __commonJS((exports, module) => {
-  var fs = require_fs();
-  var path = __require("path");
-  var { mkdirs } = require_mkdirs();
-  var { pathExists } = require_path_exists();
-  var { utimesMillis } = require_utimes();
-  var stat = require_stat();
-  async function copy(src, dest, opts = {}) {
-    if (typeof opts === "function") {
-      opts = { filter: opts };
-    }
-    opts.clobber = "clobber" in opts ? !!opts.clobber : true;
-    opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
-    if (opts.preserveTimestamps && process.arch === "ia32") {
-      process.emitWarning(`Using the preserveTimestamps option in 32-bit node is not recommended;
-
-` + "\tsee https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0001");
-    }
-    const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
-    await stat.checkParentPaths(src, srcStat, dest, "copy");
-    const include = await runFilter(src, dest, opts);
-    if (!include)
-      return;
-    const destParent = path.dirname(dest);
-    const dirExists = await pathExists(destParent);
-    if (!dirExists) {
-      await mkdirs(destParent);
-    }
-    await getStatsAndPerformCopy(destStat, src, dest, opts);
-  }
-  async function runFilter(src, dest, opts) {
-    if (!opts.filter)
-      return true;
-    return opts.filter(src, dest);
-  }
-  async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-    const statFn = opts.dereference ? fs.stat : fs.lstat;
-    const srcStat = await statFn(src);
-    if (srcStat.isDirectory())
-      return onDir(srcStat, destStat, src, dest, opts);
-    if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
-      return onFile(srcStat, destStat, src, dest, opts);
-    if (srcStat.isSymbolicLink())
-      return onLink(destStat, src, dest, opts);
-    if (srcStat.isSocket())
-      throw new Error(`Cannot copy a socket file: ${src}`);
-    if (srcStat.isFIFO())
-      throw new Error(`Cannot copy a FIFO pipe: ${src}`);
-    throw new Error(`Unknown file: ${src}`);
-  }
-  async function onFile(srcStat, destStat, src, dest, opts) {
-    if (!destStat)
-      return copyFile(srcStat, src, dest, opts);
-    if (opts.overwrite) {
-      await fs.unlink(dest);
-      return copyFile(srcStat, src, dest, opts);
-    }
-    if (opts.errorOnExist) {
-      throw new Error(`'${dest}' already exists`);
-    }
-  }
-  async function copyFile(srcStat, src, dest, opts) {
-    await fs.copyFile(src, dest);
-    if (opts.preserveTimestamps) {
-      if (fileIsNotWritable(srcStat.mode)) {
-        await makeFileWritable(dest, srcStat.mode);
-      }
-      const updatedSrcStat = await fs.stat(src);
-      await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
-    }
-    return fs.chmod(dest, srcStat.mode);
-  }
-  function fileIsNotWritable(srcMode) {
-    return (srcMode & 128) === 0;
-  }
-  function makeFileWritable(dest, srcMode) {
-    return fs.chmod(dest, srcMode | 128);
-  }
-  async function onDir(srcStat, destStat, src, dest, opts) {
-    if (!destStat) {
-      await fs.mkdir(dest);
-    }
-    const promises = [];
-    for await (const item of await fs.opendir(src)) {
-      const srcItem = path.join(src, item.name);
-      const destItem = path.join(dest, item.name);
-      promises.push(runFilter(srcItem, destItem, opts).then((include) => {
-        if (include) {
-          return stat.checkPaths(srcItem, destItem, "copy", opts).then(({ destStat: destStat2 }) => {
-            return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
-          });
-        }
-      }));
-    }
-    await Promise.all(promises);
-    if (!destStat) {
-      await fs.chmod(dest, srcStat.mode);
-    }
-  }
-  async function onLink(destStat, src, dest, opts) {
-    let resolvedSrc = await fs.readlink(src);
-    if (opts.dereference) {
-      resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
-    }
-    if (!destStat) {
-      return fs.symlink(resolvedSrc, dest);
-    }
-    let resolvedDest = null;
-    try {
-      resolvedDest = await fs.readlink(dest);
-    } catch (e) {
-      if (e.code === "EINVAL" || e.code === "UNKNOWN")
-        return fs.symlink(resolvedSrc, dest);
-      throw e;
-    }
-    if (opts.dereference) {
-      resolvedDest = path.resolve(process.cwd(), resolvedDest);
-    }
-    if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
-      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
-    }
-    if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
-      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
-    }
-    await fs.unlink(dest);
-    return fs.symlink(resolvedSrc, dest);
-  }
-  module.exports = copy;
-});
-
-// node_modules/fs-extra/lib/copy/copy-sync.js
-var require_copy_sync = __commonJS((exports, module) => {
-  var fs = require_graceful_fs();
-  var path = __require("path");
-  var mkdirsSync = require_mkdirs().mkdirsSync;
-  var utimesMillisSync = require_utimes().utimesMillisSync;
-  var stat = require_stat();
-  function copySync(src, dest, opts) {
-    if (typeof opts === "function") {
-      opts = { filter: opts };
-    }
-    opts = opts || {};
-    opts.clobber = "clobber" in opts ? !!opts.clobber : true;
-    opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
-    if (opts.preserveTimestamps && process.arch === "ia32") {
-      process.emitWarning(`Using the preserveTimestamps option in 32-bit node is not recommended;
-
-` + "\tsee https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0002");
-    }
-    const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
-    stat.checkParentPathsSync(src, srcStat, dest, "copy");
-    if (opts.filter && !opts.filter(src, dest))
-      return;
-    const destParent = path.dirname(dest);
-    if (!fs.existsSync(destParent))
-      mkdirsSync(destParent);
-    return getStats(destStat, src, dest, opts);
-  }
-  function getStats(destStat, src, dest, opts) {
-    const statSync = opts.dereference ? fs.statSync : fs.lstatSync;
-    const srcStat = statSync(src);
-    if (srcStat.isDirectory())
-      return onDir(srcStat, destStat, src, dest, opts);
-    else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
-      return onFile(srcStat, destStat, src, dest, opts);
-    else if (srcStat.isSymbolicLink())
-      return onLink(destStat, src, dest, opts);
-    else if (srcStat.isSocket())
-      throw new Error(`Cannot copy a socket file: ${src}`);
-    else if (srcStat.isFIFO())
-      throw new Error(`Cannot copy a FIFO pipe: ${src}`);
-    throw new Error(`Unknown file: ${src}`);
-  }
-  function onFile(srcStat, destStat, src, dest, opts) {
-    if (!destStat)
-      return copyFile(srcStat, src, dest, opts);
-    return mayCopyFile(srcStat, src, dest, opts);
-  }
-  function mayCopyFile(srcStat, src, dest, opts) {
-    if (opts.overwrite) {
-      fs.unlinkSync(dest);
-      return copyFile(srcStat, src, dest, opts);
-    } else if (opts.errorOnExist) {
-      throw new Error(`'${dest}' already exists`);
-    }
-  }
-  function copyFile(srcStat, src, dest, opts) {
-    fs.copyFileSync(src, dest);
-    if (opts.preserveTimestamps)
-      handleTimestamps(srcStat.mode, src, dest);
-    return setDestMode(dest, srcStat.mode);
-  }
-  function handleTimestamps(srcMode, src, dest) {
-    if (fileIsNotWritable(srcMode))
-      makeFileWritable(dest, srcMode);
-    return setDestTimestamps(src, dest);
-  }
-  function fileIsNotWritable(srcMode) {
-    return (srcMode & 128) === 0;
-  }
-  function makeFileWritable(dest, srcMode) {
-    return setDestMode(dest, srcMode | 128);
-  }
-  function setDestMode(dest, srcMode) {
-    return fs.chmodSync(dest, srcMode);
-  }
-  function setDestTimestamps(src, dest) {
-    const updatedSrcStat = fs.statSync(src);
-    return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
-  }
-  function onDir(srcStat, destStat, src, dest, opts) {
-    if (!destStat)
-      return mkDirAndCopy(srcStat.mode, src, dest, opts);
-    return copyDir(src, dest, opts);
-  }
-  function mkDirAndCopy(srcMode, src, dest, opts) {
-    fs.mkdirSync(dest);
-    copyDir(src, dest, opts);
-    return setDestMode(dest, srcMode);
-  }
-  function copyDir(src, dest, opts) {
-    const dir = fs.opendirSync(src);
-    try {
-      let dirent;
-      while ((dirent = dir.readSync()) !== null) {
-        copyDirItem(dirent.name, src, dest, opts);
-      }
-    } finally {
-      dir.closeSync();
-    }
-  }
-  function copyDirItem(item, src, dest, opts) {
-    const srcItem = path.join(src, item);
-    const destItem = path.join(dest, item);
-    if (opts.filter && !opts.filter(srcItem, destItem))
-      return;
-    const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
-    return getStats(destStat, srcItem, destItem, opts);
-  }
-  function onLink(destStat, src, dest, opts) {
-    let resolvedSrc = fs.readlinkSync(src);
-    if (opts.dereference) {
-      resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
-    }
-    if (!destStat) {
-      return fs.symlinkSync(resolvedSrc, dest);
-    } else {
-      let resolvedDest;
-      try {
-        resolvedDest = fs.readlinkSync(dest);
-      } catch (err) {
-        if (err.code === "EINVAL" || err.code === "UNKNOWN")
-          return fs.symlinkSync(resolvedSrc, dest);
-        throw err;
-      }
-      if (opts.dereference) {
-        resolvedDest = path.resolve(process.cwd(), resolvedDest);
-      }
-      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
-        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
-      }
-      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
-        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
-      }
-      return copyLink(resolvedSrc, dest);
-    }
-  }
-  function copyLink(resolvedSrc, dest) {
-    fs.unlinkSync(dest);
-    return fs.symlinkSync(resolvedSrc, dest);
-  }
-  module.exports = copySync;
-});
-
-// node_modules/fs-extra/lib/copy/index.js
-var require_copy2 = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  module.exports = {
-    copy: u(require_copy()),
-    copySync: require_copy_sync()
-  };
-});
-
-// node_modules/fs-extra/lib/remove/index.js
-var require_remove = __commonJS((exports, module) => {
-  var fs = require_graceful_fs();
-  var u = require_universalify().fromCallback;
-  function remove(path, callback) {
-    fs.rm(path, { recursive: true, force: true }, callback);
-  }
-  function removeSync(path) {
-    fs.rmSync(path, { recursive: true, force: true });
-  }
-  module.exports = {
-    remove: u(remove),
-    removeSync
-  };
-});
-
-// node_modules/fs-extra/lib/empty/index.js
-var require_empty = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var fs = require_fs();
-  var path = __require("path");
-  var mkdir = require_mkdirs();
-  var remove = require_remove();
-  var emptyDir = u(async function emptyDir(dir) {
-    let items;
-    try {
-      items = await fs.readdir(dir);
-    } catch {
-      return mkdir.mkdirs(dir);
-    }
-    return Promise.all(items.map((item) => remove.remove(path.join(dir, item))));
-  });
-  function emptyDirSync(dir) {
-    let items;
-    try {
-      items = fs.readdirSync(dir);
-    } catch {
-      return mkdir.mkdirsSync(dir);
-    }
-    items.forEach((item) => {
-      item = path.join(dir, item);
-      remove.removeSync(item);
-    });
-  }
-  module.exports = {
-    emptyDirSync,
-    emptydirSync: emptyDirSync,
-    emptyDir,
-    emptydir: emptyDir
-  };
-});
-
-// node_modules/fs-extra/lib/ensure/file.js
-var require_file = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var path = __require("path");
-  var fs = require_fs();
-  var mkdir = require_mkdirs();
-  async function createFile(file) {
-    let stats;
-    try {
-      stats = await fs.stat(file);
-    } catch {}
-    if (stats && stats.isFile())
-      return;
-    const dir = path.dirname(file);
-    let dirStats = null;
-    try {
-      dirStats = await fs.stat(dir);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        await mkdir.mkdirs(dir);
-        await fs.writeFile(file, "");
-        return;
-      } else {
-        throw err;
-      }
-    }
-    if (dirStats.isDirectory()) {
-      await fs.writeFile(file, "");
-    } else {
-      await fs.readdir(dir);
-    }
-  }
-  function createFileSync(file) {
-    let stats;
-    try {
-      stats = fs.statSync(file);
-    } catch {}
-    if (stats && stats.isFile())
-      return;
-    const dir = path.dirname(file);
-    try {
-      if (!fs.statSync(dir).isDirectory()) {
-        fs.readdirSync(dir);
-      }
-    } catch (err) {
-      if (err && err.code === "ENOENT")
-        mkdir.mkdirsSync(dir);
-      else
-        throw err;
-    }
-    fs.writeFileSync(file, "");
-  }
-  module.exports = {
-    createFile: u(createFile),
-    createFileSync
-  };
-});
-
-// node_modules/fs-extra/lib/ensure/link.js
-var require_link = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var path = __require("path");
-  var fs = require_fs();
-  var mkdir = require_mkdirs();
-  var { pathExists } = require_path_exists();
-  var { areIdentical } = require_stat();
-  async function createLink(srcpath, dstpath) {
-    let dstStat;
-    try {
-      dstStat = await fs.lstat(dstpath);
-    } catch {}
-    let srcStat;
-    try {
-      srcStat = await fs.lstat(srcpath);
-    } catch (err) {
-      err.message = err.message.replace("lstat", "ensureLink");
-      throw err;
-    }
-    if (dstStat && areIdentical(srcStat, dstStat))
-      return;
-    const dir = path.dirname(dstpath);
-    const dirExists = await pathExists(dir);
-    if (!dirExists) {
-      await mkdir.mkdirs(dir);
-    }
-    await fs.link(srcpath, dstpath);
-  }
-  function createLinkSync(srcpath, dstpath) {
-    let dstStat;
-    try {
-      dstStat = fs.lstatSync(dstpath);
-    } catch {}
-    try {
-      const srcStat = fs.lstatSync(srcpath);
-      if (dstStat && areIdentical(srcStat, dstStat))
-        return;
-    } catch (err) {
-      err.message = err.message.replace("lstat", "ensureLink");
-      throw err;
-    }
-    const dir = path.dirname(dstpath);
-    const dirExists = fs.existsSync(dir);
-    if (dirExists)
-      return fs.linkSync(srcpath, dstpath);
-    mkdir.mkdirsSync(dir);
-    return fs.linkSync(srcpath, dstpath);
-  }
-  module.exports = {
-    createLink: u(createLink),
-    createLinkSync
-  };
-});
-
-// node_modules/fs-extra/lib/ensure/symlink-paths.js
-var require_symlink_paths = __commonJS((exports, module) => {
-  var path = __require("path");
-  var fs = require_fs();
-  var { pathExists } = require_path_exists();
-  var u = require_universalify().fromPromise;
-  async function symlinkPaths(srcpath, dstpath) {
-    if (path.isAbsolute(srcpath)) {
-      try {
-        await fs.lstat(srcpath);
-      } catch (err) {
-        err.message = err.message.replace("lstat", "ensureSymlink");
-        throw err;
-      }
-      return {
-        toCwd: srcpath,
-        toDst: srcpath
-      };
-    }
-    const dstdir = path.dirname(dstpath);
-    const relativeToDst = path.join(dstdir, srcpath);
-    const exists = await pathExists(relativeToDst);
-    if (exists) {
-      return {
-        toCwd: relativeToDst,
-        toDst: srcpath
-      };
-    }
-    try {
-      await fs.lstat(srcpath);
-    } catch (err) {
-      err.message = err.message.replace("lstat", "ensureSymlink");
-      throw err;
-    }
-    return {
-      toCwd: srcpath,
-      toDst: path.relative(dstdir, srcpath)
-    };
-  }
-  function symlinkPathsSync(srcpath, dstpath) {
-    if (path.isAbsolute(srcpath)) {
-      const exists2 = fs.existsSync(srcpath);
-      if (!exists2)
-        throw new Error("absolute srcpath does not exist");
-      return {
-        toCwd: srcpath,
-        toDst: srcpath
-      };
-    }
-    const dstdir = path.dirname(dstpath);
-    const relativeToDst = path.join(dstdir, srcpath);
-    const exists = fs.existsSync(relativeToDst);
-    if (exists) {
-      return {
-        toCwd: relativeToDst,
-        toDst: srcpath
-      };
-    }
-    const srcExists = fs.existsSync(srcpath);
-    if (!srcExists)
-      throw new Error("relative srcpath does not exist");
-    return {
-      toCwd: srcpath,
-      toDst: path.relative(dstdir, srcpath)
-    };
-  }
-  module.exports = {
-    symlinkPaths: u(symlinkPaths),
-    symlinkPathsSync
-  };
-});
-
-// node_modules/fs-extra/lib/ensure/symlink-type.js
-var require_symlink_type = __commonJS((exports, module) => {
-  var fs = require_fs();
-  var u = require_universalify().fromPromise;
-  async function symlinkType(srcpath, type) {
-    if (type)
-      return type;
-    let stats;
-    try {
-      stats = await fs.lstat(srcpath);
-    } catch {
-      return "file";
-    }
-    return stats && stats.isDirectory() ? "dir" : "file";
-  }
-  function symlinkTypeSync(srcpath, type) {
-    if (type)
-      return type;
-    let stats;
-    try {
-      stats = fs.lstatSync(srcpath);
-    } catch {
-      return "file";
-    }
-    return stats && stats.isDirectory() ? "dir" : "file";
-  }
-  module.exports = {
-    symlinkType: u(symlinkType),
-    symlinkTypeSync
-  };
-});
-
-// node_modules/fs-extra/lib/ensure/symlink.js
-var require_symlink = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var path = __require("path");
-  var fs = require_fs();
-  var { mkdirs, mkdirsSync } = require_mkdirs();
-  var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
-  var { symlinkType, symlinkTypeSync } = require_symlink_type();
-  var { pathExists } = require_path_exists();
-  var { areIdentical } = require_stat();
-  async function createSymlink(srcpath, dstpath, type) {
-    let stats;
-    try {
-      stats = await fs.lstat(dstpath);
-    } catch {}
-    if (stats && stats.isSymbolicLink()) {
-      const [srcStat, dstStat] = await Promise.all([
-        fs.stat(srcpath),
-        fs.stat(dstpath)
-      ]);
-      if (areIdentical(srcStat, dstStat))
-        return;
-    }
-    const relative = await symlinkPaths(srcpath, dstpath);
-    srcpath = relative.toDst;
-    const toType = await symlinkType(relative.toCwd, type);
-    const dir = path.dirname(dstpath);
-    if (!await pathExists(dir)) {
-      await mkdirs(dir);
-    }
-    return fs.symlink(srcpath, dstpath, toType);
-  }
-  function createSymlinkSync(srcpath, dstpath, type) {
-    let stats;
-    try {
-      stats = fs.lstatSync(dstpath);
-    } catch {}
-    if (stats && stats.isSymbolicLink()) {
-      const srcStat = fs.statSync(srcpath);
-      const dstStat = fs.statSync(dstpath);
-      if (areIdentical(srcStat, dstStat))
-        return;
-    }
-    const relative = symlinkPathsSync(srcpath, dstpath);
-    srcpath = relative.toDst;
-    type = symlinkTypeSync(relative.toCwd, type);
-    const dir = path.dirname(dstpath);
-    const exists = fs.existsSync(dir);
-    if (exists)
-      return fs.symlinkSync(srcpath, dstpath, type);
-    mkdirsSync(dir);
-    return fs.symlinkSync(srcpath, dstpath, type);
-  }
-  module.exports = {
-    createSymlink: u(createSymlink),
-    createSymlinkSync
-  };
-});
-
-// node_modules/fs-extra/lib/ensure/index.js
-var require_ensure = __commonJS((exports, module) => {
-  var { createFile, createFileSync } = require_file();
-  var { createLink, createLinkSync } = require_link();
-  var { createSymlink, createSymlinkSync } = require_symlink();
-  module.exports = {
-    createFile,
-    createFileSync,
-    ensureFile: createFile,
-    ensureFileSync: createFileSync,
-    createLink,
-    createLinkSync,
-    ensureLink: createLink,
-    ensureLinkSync: createLinkSync,
-    createSymlink,
-    createSymlinkSync,
-    ensureSymlink: createSymlink,
-    ensureSymlinkSync: createSymlinkSync
-  };
-});
-
-// node_modules/jsonfile/utils.js
-var require_utils2 = __commonJS((exports, module) => {
-  function stringify(obj, { EOL = `
-`, finalEOL = true, replacer = null, spaces } = {}) {
-    const EOF = finalEOL ? EOL : "";
-    const str = JSON.stringify(obj, replacer, spaces);
-    return str.replace(/\n/g, EOL) + EOF;
-  }
-  function stripBom(content) {
-    if (Buffer.isBuffer(content))
-      content = content.toString("utf8");
-    return content.replace(/^\uFEFF/, "");
-  }
-  module.exports = { stringify, stripBom };
-});
-
-// node_modules/jsonfile/index.js
-var require_jsonfile = __commonJS((exports, module) => {
-  var _fs;
-  try {
-    _fs = require_graceful_fs();
-  } catch (_) {
-    _fs = __require("fs");
-  }
-  var universalify = require_universalify();
-  var { stringify, stripBom } = require_utils2();
-  async function _readFile(file, options = {}) {
-    if (typeof options === "string") {
-      options = { encoding: options };
-    }
-    const fs = options.fs || _fs;
-    const shouldThrow = "throws" in options ? options.throws : true;
-    let data = await universalify.fromCallback(fs.readFile)(file, options);
-    data = stripBom(data);
-    let obj;
-    try {
-      obj = JSON.parse(data, options ? options.reviver : null);
-    } catch (err) {
-      if (shouldThrow) {
-        err.message = `${file}: ${err.message}`;
-        throw err;
-      } else {
-        return null;
-      }
-    }
-    return obj;
-  }
-  var readFile = universalify.fromPromise(_readFile);
-  function readFileSync(file, options = {}) {
-    if (typeof options === "string") {
-      options = { encoding: options };
-    }
-    const fs = options.fs || _fs;
-    const shouldThrow = "throws" in options ? options.throws : true;
-    try {
-      let content = fs.readFileSync(file, options);
-      content = stripBom(content);
-      return JSON.parse(content, options.reviver);
-    } catch (err) {
-      if (shouldThrow) {
-        err.message = `${file}: ${err.message}`;
-        throw err;
-      } else {
-        return null;
-      }
-    }
-  }
-  async function _writeFile(file, obj, options = {}) {
-    const fs = options.fs || _fs;
-    const str = stringify(obj, options);
-    await universalify.fromCallback(fs.writeFile)(file, str, options);
-  }
-  var writeFile = universalify.fromPromise(_writeFile);
-  function writeFileSync(file, obj, options = {}) {
-    const fs = options.fs || _fs;
-    const str = stringify(obj, options);
-    return fs.writeFileSync(file, str, options);
-  }
-  module.exports = {
-    readFile,
-    readFileSync,
-    writeFile,
-    writeFileSync
-  };
-});
-
-// node_modules/fs-extra/lib/json/jsonfile.js
-var require_jsonfile2 = __commonJS((exports, module) => {
-  var jsonFile = require_jsonfile();
-  module.exports = {
-    readJson: jsonFile.readFile,
-    readJsonSync: jsonFile.readFileSync,
-    writeJson: jsonFile.writeFile,
-    writeJsonSync: jsonFile.writeFileSync
-  };
-});
-
-// node_modules/fs-extra/lib/output-file/index.js
-var require_output_file = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var fs = require_fs();
-  var path = __require("path");
-  var mkdir = require_mkdirs();
-  var pathExists = require_path_exists().pathExists;
-  async function outputFile(file, data, encoding = "utf-8") {
-    const dir = path.dirname(file);
-    if (!await pathExists(dir)) {
-      await mkdir.mkdirs(dir);
-    }
-    return fs.writeFile(file, data, encoding);
-  }
-  function outputFileSync(file, ...args) {
-    const dir = path.dirname(file);
-    if (!fs.existsSync(dir)) {
-      mkdir.mkdirsSync(dir);
-    }
-    fs.writeFileSync(file, ...args);
-  }
-  module.exports = {
-    outputFile: u(outputFile),
-    outputFileSync
-  };
-});
-
-// node_modules/fs-extra/lib/json/output-json.js
-var require_output_json = __commonJS((exports, module) => {
-  var { stringify } = require_utils2();
-  var { outputFile } = require_output_file();
-  async function outputJson(file, data, options = {}) {
-    const str = stringify(data, options);
-    await outputFile(file, str, options);
-  }
-  module.exports = outputJson;
-});
-
-// node_modules/fs-extra/lib/json/output-json-sync.js
-var require_output_json_sync = __commonJS((exports, module) => {
-  var { stringify } = require_utils2();
-  var { outputFileSync } = require_output_file();
-  function outputJsonSync(file, data, options) {
-    const str = stringify(data, options);
-    outputFileSync(file, str, options);
-  }
-  module.exports = outputJsonSync;
-});
-
-// node_modules/fs-extra/lib/json/index.js
-var require_json = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  var jsonFile = require_jsonfile2();
-  jsonFile.outputJson = u(require_output_json());
-  jsonFile.outputJsonSync = require_output_json_sync();
-  jsonFile.outputJSON = jsonFile.outputJson;
-  jsonFile.outputJSONSync = jsonFile.outputJsonSync;
-  jsonFile.writeJSON = jsonFile.writeJson;
-  jsonFile.writeJSONSync = jsonFile.writeJsonSync;
-  jsonFile.readJSON = jsonFile.readJson;
-  jsonFile.readJSONSync = jsonFile.readJsonSync;
-  module.exports = jsonFile;
-});
-
-// node_modules/fs-extra/lib/move/move.js
-var require_move = __commonJS((exports, module) => {
-  var fs = require_fs();
-  var path = __require("path");
-  var { copy } = require_copy2();
-  var { remove } = require_remove();
-  var { mkdirp } = require_mkdirs();
-  var { pathExists } = require_path_exists();
-  var stat = require_stat();
-  async function move(src, dest, opts = {}) {
-    const overwrite = opts.overwrite || opts.clobber || false;
-    const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
-    await stat.checkParentPaths(src, srcStat, dest, "move");
-    const destParent = path.dirname(dest);
-    const parsedParentPath = path.parse(destParent);
-    if (parsedParentPath.root !== destParent) {
-      await mkdirp(destParent);
-    }
-    return doRename(src, dest, overwrite, isChangingCase);
-  }
-  async function doRename(src, dest, overwrite, isChangingCase) {
-    if (!isChangingCase) {
-      if (overwrite) {
-        await remove(dest);
-      } else if (await pathExists(dest)) {
-        throw new Error("dest already exists.");
-      }
-    }
-    try {
-      await fs.rename(src, dest);
-    } catch (err) {
-      if (err.code !== "EXDEV") {
-        throw err;
-      }
-      await moveAcrossDevice(src, dest, overwrite);
-    }
-  }
-  async function moveAcrossDevice(src, dest, overwrite) {
-    const opts = {
-      overwrite,
-      errorOnExist: true,
-      preserveTimestamps: true
-    };
-    await copy(src, dest, opts);
-    return remove(src);
-  }
-  module.exports = move;
-});
-
-// node_modules/fs-extra/lib/move/move-sync.js
-var require_move_sync = __commonJS((exports, module) => {
-  var fs = require_graceful_fs();
-  var path = __require("path");
-  var copySync = require_copy2().copySync;
-  var removeSync = require_remove().removeSync;
-  var mkdirpSync = require_mkdirs().mkdirpSync;
-  var stat = require_stat();
-  function moveSync(src, dest, opts) {
-    opts = opts || {};
-    const overwrite = opts.overwrite || opts.clobber || false;
-    const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
-    stat.checkParentPathsSync(src, srcStat, dest, "move");
-    if (!isParentRoot(dest))
-      mkdirpSync(path.dirname(dest));
-    return doRename(src, dest, overwrite, isChangingCase);
-  }
-  function isParentRoot(dest) {
-    const parent = path.dirname(dest);
-    const parsedPath = path.parse(parent);
-    return parsedPath.root === parent;
-  }
-  function doRename(src, dest, overwrite, isChangingCase) {
-    if (isChangingCase)
-      return rename(src, dest, overwrite);
-    if (overwrite) {
-      removeSync(dest);
-      return rename(src, dest, overwrite);
-    }
-    if (fs.existsSync(dest))
-      throw new Error("dest already exists.");
-    return rename(src, dest, overwrite);
-  }
-  function rename(src, dest, overwrite) {
-    try {
-      fs.renameSync(src, dest);
-    } catch (err) {
-      if (err.code !== "EXDEV")
-        throw err;
-      return moveAcrossDevice(src, dest, overwrite);
-    }
-  }
-  function moveAcrossDevice(src, dest, overwrite) {
-    const opts = {
-      overwrite,
-      errorOnExist: true,
-      preserveTimestamps: true
-    };
-    copySync(src, dest, opts);
-    return removeSync(src);
-  }
-  module.exports = moveSync;
-});
-
-// node_modules/fs-extra/lib/move/index.js
-var require_move2 = __commonJS((exports, module) => {
-  var u = require_universalify().fromPromise;
-  module.exports = {
-    move: u(require_move()),
-    moveSync: require_move_sync()
-  };
-});
-
-// node_modules/fs-extra/lib/index.js
-var require_lib = __commonJS((exports, module) => {
-  module.exports = {
-    ...require_fs(),
-    ...require_copy2(),
-    ...require_empty(),
-    ...require_ensure(),
-    ...require_json(),
-    ...require_mkdirs(),
-    ...require_move2(),
-    ...require_output_file(),
-    ...require_path_exists(),
-    ...require_remove()
-  };
-});
-
-// src/bb-functions-build.ts
-import { spawn } from "child_process";
-
-// node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
-
-// src/bb-functions-build.ts
-var import_fs_extra = __toESM(require_lib(), 1);
-import os from "os";
-import path3 from "path";
-
-// src/functions/acquireCustomFunctionsProject.ts
-import fs from "fs";
-import path from "path";
-var acquireCustomFunctionsProject = (dir) => {
-  const expected = ["functions.json", "package.json", "src"];
-  const intersection = fs.readdirSync(dir).filter((file) => expected.includes(file));
-  if (intersection.length === expected.length) {
-    return path.basename(dir);
-  }
-  console.log("The current directory is not a custom functions project. Abort.");
-  process.exit();
-};
-var acquireCustomFunctionsProject_default = acquireCustomFunctionsProject;
-
-// src/utils/rootDir.ts
-import path2 from "path";
-var rootDir = () => path2.join(process.mainModule.filename, "..", "..");
-var rootDir_default = rootDir;
-
-// src/bb-functions-build.ts
-var program2 = new Command;
-program2.name("bb functions build").parse(process.argv);
-var workingDir = process.cwd();
-var identifier = acquireCustomFunctionsProject_default(workingDir);
-console.log(`Building ${identifier}.bettyblocks.com bundle (this can take a while) ...`);
-new Promise((resolve) => {
-  const packerDir = path3.join(rootDir_default(), "assets", "functions", "packer");
-  const buildDir = path3.join(os.tmpdir(), identifier);
-  const sourceSrc = path3.join(workingDir, "src");
-  const targetSrc = path3.join(buildDir, "src");
-  const sourcePackage = path3.join(workingDir, "package.json");
-  const targetPackage = path3.join(buildDir, "package.json");
-  const sourceConfig = path3.join(workingDir, "webpack.config.js");
-  const targetConfig = path3.join(buildDir, "webpack.config.js");
-  if (!import_fs_extra.default.pathExistsSync(sourceConfig)) {
-    import_fs_extra.default.copySync(path3.join(packerDir, "webpack.config.js"), sourceConfig);
-  }
-  import_fs_extra.default.emptyDir(buildDir, (err) => {
-    if (err) {
-      console.log(`${err.message}. Abort.`);
-    }
-    import_fs_extra.default.copySync(packerDir, buildDir);
-    import_fs_extra.default.copySync(sourceSrc, targetSrc);
-    import_fs_extra.default.copySync(sourceConfig, targetConfig);
-    const sourceJson = import_fs_extra.default.readJsonSync(sourcePackage);
-    const targetJson = import_fs_extra.default.readJsonSync(targetPackage);
-    targetJson.dependencies = {
-      ...targetJson.dependencies,
-      ...sourceJson.dependencies
-    };
-    import_fs_extra.default.writeFileSync(targetPackage, JSON.stringify(targetJson, null, 2));
-    const build = spawn(`cd ${buildDir} && npm install && npm run build`, {
-      shell: true
-    });
-    build.stdout.pipe(process.stdout);
-    build.stderr.pipe(process.stderr);
-    build.on("close", resolve);
-  });
-}).then(() => {
-  console.log("Done.");
-}).catch((err) => {
-  console.log(`${err}
-Abort.`);
-  process.exit();
-});