@kecan0406/ttheme 0.1.0

package/bin/ttheme.js

@@ -0,0 +1,4473 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var ESC2 = "\x1B";
+  var CSI2 = `${ESC2}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x, y) {
+      if (!y)
+        return `${CSI2}${x + 1}G`;
+      return `${CSI2}${y + 1};${x + 1}H`;
+    },
+    move(x, y) {
+      let ret = "";
+      if (x < 0)
+        ret += `${CSI2}${-x}D`;
+      else if (x > 0)
+        ret += `${CSI2}${x}C`;
+      if (y < 0)
+        ret += `${CSI2}${-y}A`;
+      else if (y > 0)
+        ret += `${CSI2}${y}B`;
+      return ret;
+    },
+    up: (count = 1) => `${CSI2}${count}A`,
+    down: (count = 1) => `${CSI2}${count}B`,
+    forward: (count = 1) => `${CSI2}${count}C`,
+    backward: (count = 1) => `${CSI2}${count}D`,
+    nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+    left: `${CSI2}G`,
+    hide: `${CSI2}?25l`,
+    show: `${CSI2}?25h`,
+    save: `${ESC2}7`,
+    restore: `${ESC2}8`
+  };
+  var scroll = {
+    up: (count = 1) => `${CSI2}S`.repeat(count),
+    down: (count = 1) => `${CSI2}T`.repeat(count)
+  };
+  var erase = {
+    screen: `${CSI2}2J`,
+    up: (count = 1) => `${CSI2}1J`.repeat(count),
+    down: (count = 1) => `${CSI2}J`.repeat(count),
+    line: `${CSI2}2K`,
+    lineEnd: `${CSI2}K`,
+    lineStart: `${CSI2}1K`,
+    lines(count) {
+      let clear = "";
+      for (let i = 0;i < count; i++)
+        clear += this.line + (i < count - 1 ? cursor.up() : "");
+      if (count)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
+
+// node_modules/commander/lib/error.js
+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;
+  }
+}
+
+// node_modules/commander/lib/argument.js
+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.endsWith("...")) {
+      this.variadic = true;
+      this._name = this._name.slice(0, -3);
+    }
+  }
+  name() {
+    return this._name;
+  }
+  _collectValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+    previous.push(value);
+    return previous;
+  }
+  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._collectValue(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 + "]";
+}
+
+// node_modules/commander/lib/command.js
+import { EventEmitter } from "node:events";
+import childProcess from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import process2 from "node:process";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+
+// node_modules/commander/lib/help.js
+import { stripVTControlCharacters } from "node:util";
+
+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 stripVTControlCharacters(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(`
+`);
+  }
+}
+
+// node_modules/commander/lib/option.js
+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;
+  }
+  _collectValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+    previous.push(value);
+    return previous;
+  }
+  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._collectValue(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 };
+}
+
+// node_modules/commander/lib/suggestSimilar.js
+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;
+      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 "";
+}
+
+// node_modules/commander/lib/command.js
+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) => stripVTControlCharacters2(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 = {
+      ...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?.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;
+        }
+      };
+    }
+    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.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._collectValue(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.options.filter((option) => option.negate && option.defaultValue === undefined && this.getOptionValue(option.attributeName()) === undefined).forEach((option) => {
+        const positiveLongFlag = option.long.replace(/^--no-/, "--");
+        if (!this._findOption(positiveLongFlag)) {
+          this.setOptionValueWithSource(option.attributeName(), true, "default");
+        }
+      });
+      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();
+    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;
+    }
+    const 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?.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?.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(args) {
+    const operands = [];
+    const unknown = [];
+    let dest = operands;
+    function maybeOption(arg) {
+      return arg.length > 1 && arg[0] === "-";
+    }
+    const negativeNumberArg = (arg) => {
+      if (!/^-(\d+|\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;
+    let activeGroup = null;
+    let i = 0;
+    while (i < args.length || activeGroup) {
+      const arg = activeGroup ?? args[i++];
+      activeGroup = null;
+      if (arg === "--") {
+        if (dest === unknown)
+          dest.push(arg);
+        dest.push(...args.slice(i));
+        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[i++];
+            if (value === undefined)
+              this.optionMissingArgument(option);
+            this.emit(`option:${option.name()}`, value);
+          } else if (option.optional) {
+            let value = null;
+            if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+              value = args[i++];
+            }
+            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()}`);
+            activeGroup = `-${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);
+          unknown.push(...args.slice(i));
+          break;
+        } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
+          operands.push(arg, ...args.slice(i));
+          break;
+        } else if (this._defaultCommandName) {
+          unknown.push(arg, ...args.slice(i));
+          break;
+        }
+      }
+      if (this._passThroughOptions) {
+        dest.push(arg, ...args.slice(i));
+        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 received = receivedArgs.length;
+    const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
+    const details = receivedArgs.join(", ");
+    const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${received}: ${details}.`;
+    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;
+}
+
+// node_modules/commander/index.js
+var program = new Command;
+// package.json
+var package_default = {
+  name: "@kecan0406/ttheme",
+  version: "0.1.0",
+  type: "module",
+  bin: {
+    ttheme: "bin/ttheme.js"
+  },
+  files: [
+    "bin",
+    "dist",
+    "shell",
+    "ghostty/shaders"
+  ],
+  description: "Character terminal palettes for ghostty, kitty, alacritty, wezterm and iTerm2",
+  license: "MIT",
+  author: "kecan0406",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/kecan0406/ttheme.git"
+  },
+  homepage: "https://github.com/kecan0406/ttheme#readme",
+  bugs: "https://github.com/kecan0406/ttheme/issues",
+  keywords: [
+    "terminal",
+    "theme",
+    "ghostty",
+    "kitty",
+    "alacritty",
+    "wezterm",
+    "iterm2"
+  ],
+  devDependencies: {
+    "@biomejs/biome": "^2.3.0",
+    "@clack/prompts": "^1.7.0",
+    "@types/bun": "^1.3.0",
+    commander: "^15.0.0",
+    typescript: "^5.8.2"
+  },
+  engines: {
+    bun: ">=1.3",
+    node: ">=20.11"
+  }
+};
+
+// src/build.ts
+import { rmSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/color.ts
+var HEX = /^#[0-9a-f]{6}$/;
+function isHex(value) {
+  return HEX.test(value);
+}
+function rgb(hex) {
+  const n = Number.parseInt(hex.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function luminance(hex) {
+  const [r, g, b] = rgb(hex).map((c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrast(a, b) {
+  const la = luminance(a);
+  const lb = luminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function ratio(a, b) {
+  return Math.round(contrast(a, b) * 100) / 100;
+}
+
+// src/contrast.ts
+var BODY_MIN = 7;
+var ACCENT_MIN = 3;
+var ANSI0_MAX_LUMINANCE = 0.15;
+var ANSI8_MIN = 1.6;
+function at(theme, index) {
+  const color = theme.ansi[index];
+  if (color === undefined)
+    throw new Error(`${theme.name}: missing ANSI ${index}`);
+  return color;
+}
+function belowMin(theme, indices, min) {
+  const bg = theme.background;
+  return indices.flatMap((i) => {
+    const color = at(theme, i);
+    return contrast(color, bg) < min ? [`ANSI ${i} ${color} on ${bg} is ${ratio(color, bg)}:1, needs ${min}:1`] : [];
+  });
+}
+var CHECKS = [
+  {
+    rule: "foreground",
+    check: ({ foreground, background }) => contrast(foreground, background) < BODY_MIN ? [`foreground ${foreground} on ${background} is ${ratio(foreground, background)}:1, needs ${BODY_MIN}:1`] : []
+  },
+  {
+    rule: "accents",
+    check: (theme) => belowMin(theme, [1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14], ACCENT_MIN)
+  },
+  {
+    rule: "ansi0-dark",
+    check: (theme) => {
+      const ansi0 = at(theme, 0);
+      return luminance(ansi0) > ANSI0_MAX_LUMINANCE ? [`ANSI 0 ${ansi0} has luminance ${luminance(ansi0).toFixed(3)}, needs <= ${ANSI0_MAX_LUMINANCE}`] : [];
+    }
+  },
+  {
+    rule: "light-ansi",
+    check: (theme) => belowMin(theme, [7, 15], BODY_MIN)
+  },
+  {
+    rule: "ansi8-visible",
+    check: (theme) => belowMin(theme, [8], ANSI8_MIN)
+  }
+];
+var RULES = CHECKS.map((c) => c.rule);
+function check(theme) {
+  return CHECKS.filter((c) => !theme.waive.includes(c.rule)).flatMap((c) => c.check(theme).map((detail) => ({ theme: theme.name, rule: c.rule, detail })));
+}
+function checkAll(themes) {
+  return themes.flatMap(check);
+}
+
+// src/emit/alacritty.ts
+var NAMES = ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
+function block(header, colors) {
+  return [header, ...NAMES.map((name, i) => `${name} = '${colors[i]}'`), ""].join(`
+`);
+}
+var alacritty = {
+  id: "alacritty",
+  limits: "no shaders, no runtime color API (OSC only)",
+  emit(theme) {
+    const colors = [
+      ...banner(theme),
+      "",
+      "[colors.primary]",
+      `background = '${theme.background}'`,
+      `foreground = '${theme.foreground}'`,
+      "",
+      "[colors.cursor]",
+      `cursor = '${theme.cursor}'`,
+      `text = '${theme.background}'`,
+      "",
+      "[colors.selection]",
+      `background = '${theme.selectionBackground}'`,
+      `text = '${theme.foreground}'`,
+      "",
+      block("[colors.normal]", theme.ansi.slice(0, 8)),
+      block("[colors.bright]", theme.ansi.slice(8, 16))
+    ].join(`
+`);
+    const config = [
+      `# ${theme.name} — font settings.`,
+      `# Pair with the palette:  import = ["~/.config/alacritty/themes/${theme.name}.toml"]`,
+      "",
+      "[font]",
+      `size = ${theme.font.size}`,
+      "",
+      "[font.normal]",
+      `family = '${theme.font.family}'`,
+      ""
+    ].join(`
+`);
+    return [
+      { path: `alacritty/themes/${theme.name}.toml`, content: colors },
+      { path: `alacritty/config/${theme.name}.toml`, content: config }
+    ];
+  }
+};
+// src/emit/ghostty.ts
+import { isDeepStrictEqual } from "node:util";
+var ghostty = {
+  id: "ghostty",
+  emit(theme) {
+    const colors = [
+      ...banner(theme),
+      `background = ${theme.background}`,
+      `foreground = ${theme.foreground}`,
+      `cursor-color = ${theme.cursor}`,
+      `selection-background = ${theme.selectionBackground}`,
+      `selection-foreground = ${theme.foreground}`,
+      ...theme.ansi.map((c, i) => `palette = ${i}=${c}`),
+      "palette-generate = true",
+      "",
+      "macos-icon = custom-style",
+      `macos-icon-ghost-color = ${theme.ghostty.iconGhost}`,
+      `macos-icon-screen-color = ${theme.ghostty.iconScreen.join(",")}`,
+      "macos-icon-frame = chrome",
+      ""
+    ].join(`
+`);
+    return [{ path: `ghostty/themes/${theme.name}`, content: colors }];
+  },
+  emitShared(themes) {
+    const [first] = themes;
+    if (!first)
+      return [];
+    for (const t of themes) {
+      if (!isDeepStrictEqual(t.font, first.font) || t.ghostty.shader !== first.ghostty.shader) {
+        throw new Error(`${t.name}: per-theme font/shader overrides cannot be expressed in the shared ghostty/ttheme.conf`);
+      }
+    }
+    const config = [
+      "# ttheme — shared font and shader, identical for every palette.",
+      "# Pick colors with:  theme = <palette>",
+      `font-family = ${first.font.family}`,
+      `font-size = ${first.font.size}`,
+      ...first.font.codepointMap.map((m) => `font-codepoint-map = ${m.range}=${m.family}`),
+      ...first.ghostty.shader ? ["", `custom-shader = ~/.config/ghostty/shaders/${first.ghostty.shader}`, "custom-shader-animation = true"] : [],
+      ""
+    ].join(`
+`);
+    return [{ path: "ghostty/ttheme.conf", content: config }];
+  }
+};
+// src/emit/iterm2.ts
+function color(key, hex) {
+  const [r, g, b] = rgb(hex);
+  const real = (c) => (c / 255).toFixed(4);
+  return [
+    `	<key>${key}</key>`,
+    "\t<dict>",
+    "\t\t<key>Alpha Component</key>",
+    "\t\t<real>1</real>",
+    "\t\t<key>Blue Component</key>",
+    `		<real>${real(b)}</real>`,
+    "\t\t<key>Color Space</key>",
+    "\t\t<string>sRGB</string>",
+    "\t\t<key>Green Component</key>",
+    `		<real>${real(g)}</real>`,
+    "\t\t<key>Red Component</key>",
+    `		<real>${real(r)}</real>`,
+    "\t</dict>"
+  ].join(`
+`);
+}
+var iterm2 = {
+  id: "iterm2",
+  limits: "colors only — font lives in the profile; ignores OSC 12, so the cursor keeps its profile color at runtime",
+  emit(theme) {
+    const entries = [
+      ...theme.ansi.map((c, i) => color(`Ansi ${i} Color`, c)),
+      color("Background Color", theme.background),
+      color("Bold Color", theme.foreground),
+      color("Cursor Color", theme.cursor),
+      color("Cursor Text Color", theme.background),
+      color("Foreground Color", theme.foreground),
+      color("Selected Text Color", theme.foreground),
+      color("Selection Color", theme.selectionBackground)
+    ];
+    const content = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+      '<plist version="1.0">',
+      "<dict>",
+      ...entries,
+      "</dict>",
+      "</plist>",
+      ""
+    ].join(`
+`);
+    return [{ path: `iterm2/${theme.name}.itermcolors`, content }];
+  }
+};
+// src/emit/kitty.ts
+var kitty = {
+  id: "kitty",
+  limits: "no GLSL shaders, no per-codepoint font mapping",
+  emit(theme) {
+    const colors = [
+      ...banner(theme),
+      `background ${theme.background}`,
+      `foreground ${theme.foreground}`,
+      `cursor ${theme.cursor}`,
+      `cursor_text_color ${theme.background}`,
+      `selection_background ${theme.selectionBackground}`,
+      `selection_foreground ${theme.foreground}`,
+      ...theme.ansi.map((c, i) => `color${i} ${c}`),
+      ""
+    ].join(`
+`);
+    const config = [
+      `# ${theme.name} — font settings.`,
+      `# Pair with the palette:  include themes/${theme.name}.conf`,
+      `font_family ${theme.font.family}`,
+      `font_size ${theme.font.size}`,
+      ""
+    ].join(`
+`);
+    return [
+      { path: `kitty/themes/${theme.name}.conf`, content: colors },
+      { path: `kitty/config/${theme.name}.conf`, content: config }
+    ];
+  }
+};
+// src/emit/wezterm.ts
+var list = (colors) => `[${colors.map((c) => `"${c}"`).join(", ")}]`;
+var wezterm = {
+  id: "wezterm",
+  limits: "no shaders; runtime overrides are per-window, never per-pane",
+  emit(theme) {
+    const colors = [
+      "[metadata]",
+      `name = "${theme.name}"`,
+      `origin_url = "${theme.ansiSource}"`,
+      "",
+      "[colors]",
+      `foreground = "${theme.foreground}"`,
+      `background = "${theme.background}"`,
+      `cursor_bg = "${theme.cursor}"`,
+      `cursor_border = "${theme.cursor}"`,
+      `cursor_fg = "${theme.background}"`,
+      `selection_bg = "${theme.selectionBackground}"`,
+      `selection_fg = "${theme.foreground}"`,
+      "",
+      `ansi = ${list(theme.ansi.slice(0, 8))}`,
+      `brights = ${list(theme.ansi.slice(8, 16))}`,
+      ""
+    ].join(`
+`);
+    const config = [
+      `-- ${theme.name} — font settings.`,
+      `-- Merge into your wezterm.lua config table:`,
+      `--   local t = require("ttheme.${theme.name}")`,
+      `--   config.color_scheme = "${theme.name}"`,
+      `--   config.font = t.font`,
+      `--   config.font_size = t.font_size`,
+      "return {",
+      `  font = require("wezterm").font("${theme.font.family}"),`,
+      `  font_size = ${theme.font.size},`,
+      "}",
+      ""
+    ].join(`
+`);
+    return [
+      { path: `wezterm/colors/${theme.name}.toml`, content: colors },
+      { path: `wezterm/config/${theme.name}.lua`, content: config }
+    ];
+  }
+};
+
+// src/emit/index.ts
+function banner(theme) {
+  return [`# ${theme.name} — ${theme.group}${theme.native ? ` (${theme.native})` : ""}`, `# ANSI: ${theme.ansiSource}`];
+}
+
+// src/theme.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+var DEFAULTS_FILE = "_defaults.toml";
+var RESERVED_NAMES = new Set(["next", "current", "help", "preview"]);
+function fail(file, message) {
+  throw new Error(`${file}: ${message}`);
+}
+function hex(file, field, value) {
+  if (typeof value !== "string" || !isHex(value)) {
+    fail(file, `${field} must be "#rrggbb" (lowercase), got ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function str(file, field, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    fail(file, `${field} must be a non-empty string`);
+  }
+  return value;
+}
+function table(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function readFont(file, own, base) {
+  const font = { ...table(base), ...table(own) };
+  const raw = font.codepoint_map ?? [];
+  if (!Array.isArray(raw))
+    fail(file, "font.codepoint_map must be an array");
+  return {
+    family: str(file, "font.family", font.family),
+    size: Number(font.size),
+    codepointMap: raw.map((entry) => {
+      const e = table(entry);
+      return {
+        range: str(file, "font.codepoint_map[].range", e.range),
+        family: str(file, "font.codepoint_map[].family", e.family)
+      };
+    })
+  };
+}
+function readIconScreen(file, value, colors) {
+  if (value === undefined) {
+    return [colors.cursor, colors.selectionBackground, colors.background];
+  }
+  const raw = Array.isArray(value) ? value : [value];
+  if (raw.length === 0)
+    fail(file, "ghostty.icon_screen must not be empty");
+  return raw.map((c, i) => hex(file, `ghostty.icon_screen[${i}]`, c));
+}
+function readGhostty(file, own, base, colors) {
+  const g = { ...table(base), ...table(own) };
+  return {
+    shader: g.shader === undefined ? undefined : str(file, "ghostty.shader", g.shader),
+    iconGhost: g.icon_ghost === undefined ? colors.cursor : hex(file, "ghostty.icon_ghost", g.icon_ghost),
+    iconScreen: readIconScreen(file, g.icon_screen, colors)
+  };
+}
+function readTheme(file, source, defaults) {
+  const doc = Bun.TOML.parse(source);
+  const meta = table(doc.meta);
+  const colors = table(doc.colors);
+  const contrastRules = table(doc.contrast);
+  const ansiRaw = colors.ansi;
+  if (!Array.isArray(ansiRaw) || ansiRaw.length !== 16) {
+    fail(file, `colors.ansi must hold exactly 16 colors, got ${Array.isArray(ansiRaw) ? ansiRaw.length : typeof ansiRaw}`);
+  }
+  const name = str(file, "meta.name", meta.name);
+  if (name !== basename(file, ".toml")) {
+    fail(file, `meta.name "${name}" does not match the filename`);
+  }
+  if (RESERVED_NAMES.has(name)) {
+    fail(file, `meta.name "${name}" collides with a ttheme subcommand`);
+  }
+  if (name.startsWith("-")) {
+    fail(file, `meta.name "${name}" would be read as a flag by the ttheme CLI`);
+  }
+  const role = meta.role;
+  if (role !== undefined && role !== "default") {
+    fail(file, `meta.role must be "default", got ${JSON.stringify(role)}`);
+  }
+  const background = hex(file, "colors.background", colors.background);
+  const cursor = hex(file, "colors.cursor", colors.cursor);
+  const selectionBackground = hex(file, "colors.selection_background", colors.selection_background);
+  const waive = Array.isArray(contrastRules.waive) ? contrastRules.waive.map(String) : [];
+  if (waive.length > 0 && typeof contrastRules.reason !== "string") {
+    fail(file, "contrast.waive needs a contrast.reason explaining why");
+  }
+  return {
+    name,
+    group: str(file, "meta.group", meta.group),
+    native: meta.native === undefined ? undefined : str(file, "meta.native", meta.native),
+    order: Number(meta.order),
+    role,
+    ansiSource: str(file, "meta.ansi_source", meta.ansi_source),
+    background,
+    foreground: hex(file, "colors.foreground", colors.foreground),
+    cursor,
+    selectionBackground,
+    ansi: ansiRaw.map((c, i) => hex(file, `colors.ansi[${i}]`, c)),
+    font: readFont(file, doc.font, defaults.font),
+    ghostty: readGhostty(file, doc.ghostty, defaults.ghostty, {
+      background,
+      cursor,
+      selectionBackground
+    }),
+    waive,
+    waiveReason: typeof contrastRules.reason === "string" ? contrastRules.reason : undefined
+  };
+}
+function loadThemes(dir) {
+  const defaults = Bun.TOML.parse(readFileSync(join(dir, DEFAULTS_FILE), "utf8"));
+  const themes = readdirSync(dir).filter((f) => f.endsWith(".toml") && f !== DEFAULTS_FILE).map((f) => readTheme(f, readFileSync(join(dir, f), "utf8"), defaults)).sort((a, b) => a.order - b.order);
+  const orders = new Set(themes.map((t) => t.order));
+  if (orders.size !== themes.length) {
+    throw new Error("themes: meta.order must be unique across all themes");
+  }
+  return themes;
+}
+function rotation(themes) {
+  return themes.filter((t) => t.role === undefined);
+}
+
+// src/build.ts
+var root = join2(import.meta.dirname, "..");
+var THEMES = join2(root, "themes");
+var DIST = join2(root, "dist");
+var EMITTERS = [ghostty, kitty, alacritty, wezterm, iterm2];
+var TERMINALS = EMITTERS.map((e) => e.id);
+function shellPalettes(themes) {
+  for (const t of themes) {
+    for (const field of [t.name, t.group, t.native ?? "", t.ansiSource]) {
+      if (/["$`\\]/.test(field)) {
+        throw new Error(`${t.name}: "${field}" contains a character that breaks zsh quoting`);
+      }
+    }
+  }
+  const pad = Math.max(...themes.map((t) => t.name.length));
+  const entry = (t, value) => `  ${t.name.padEnd(pad)} "${value}"`;
+  return [
+    "# Generated by `mise run build` — do not edit.",
+    "# Source of truth: themes/*.toml in the ttheme repo.",
+    "",
+    "typeset -gA TTHEME_PALETTE=(",
+    ...themes.map((t) => entry(t, [t.background, t.foreground, t.cursor, t.selectionBackground, ...t.ansi].join(" "))),
+    ")",
+    "",
+    "# display order for `ttheme`, and the order new tabs are assigned in",
+    `typeset -ga TTHEME_ORDER=(${themes.map((t) => t.name).join(" ")})`,
+    "",
+    "# themes new tabs cycle through (the default role sits out)",
+    `typeset -ga TTHEME_ROTATION=(${rotation(themes).map((t) => t.name).join(" ")})`,
+    "",
+    "typeset -gA TTHEME_GROUP=(",
+    ...themes.map((t) => entry(t, t.group)),
+    ")",
+    "",
+    "# original-language title, rendered dim next to the group",
+    "typeset -gA TTHEME_NATIVE=(",
+    ...themes.filter((t) => t.native).map((t) => entry(t, t.native ?? "")),
+    ")",
+    "",
+    "# where each palette's 16 ANSI colors came from",
+    "typeset -gA TTHEME_SRC=(",
+    ...themes.map((t) => entry(t, t.ansiSource)),
+    ")",
+    ""
+  ].join(`
+`);
+}
+async function build({ only } = {}) {
+  if (typeof Bun === "undefined") {
+    throw new Error("ttheme build needs bun — run it from a checkout: bun src/bin.ts build");
+  }
+  const emitters = only && only.length > 0 ? EMITTERS.filter((e) => only.includes(e.id)) : EMITTERS;
+  const themes = loadThemes(THEMES);
+  const violations = checkAll(themes);
+  if (violations.length > 0) {
+    for (const v of violations) {
+      console.error(`  ✗ ${v.theme} [${v.rule}] ${v.detail}`);
+    }
+    throw new Error(`${violations.length} contrast violation(s). Fix the palette, or waive the rule in its [contrast] section with a reason.`);
+  }
+  if (emitters.length === EMITTERS.length) {
+    rmSync(DIST, { recursive: true, force: true });
+  } else {
+    for (const e of emitters) {
+      rmSync(join2(DIST, e.id), { recursive: true, force: true });
+    }
+  }
+  let count = 0;
+  const write = async (out) => {
+    await Bun.write(join2(DIST, out.path), out.content);
+    count++;
+  };
+  for (const emitter of emitters) {
+    for (const theme of themes) {
+      for (const out of emitter.emit(theme)) {
+        await write(out);
+      }
+    }
+    for (const out of emitter.emitShared?.(themes) ?? []) {
+      await write(out);
+    }
+    console.log(`  ${emitter.id.padEnd(10)} ${themes.length} themes${emitter.limits ? `  (${emitter.limits})` : ""}`);
+  }
+  await Bun.write(join2(DIST, "shell", "palettes.zsh"), shellPalettes(themes));
+  count++;
+  console.log(`  ${"shell".padEnd(10)} palettes.zsh`);
+  console.log(`
+${themes.length} themes (${rotation(themes).length} in the new-tab rotation) -> ${count} files in dist/`);
+}
+
+// src/init.ts
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  rmSync as rmSync2,
+  symlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join3 } from "node:path";
+
+// node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import l__default from "node:readline";
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+function findCursor(s, o, l) {
+  if (!l.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
+}
+function findTextCursor(s, o, l, i) {
+  const t = i.split(`
+`);
+  let n = 0, e = s;
+  for (const r of t) {
+    if (e <= r.length)
+      break;
+    e -= r.length + 1, n++;
+  }
+  for (n = Math.max(0, Math.min(t.length - 1, n + l)), e = Math.min(e, t[n].length) + o;e < 0 && n > 0; )
+    n--, e += t[n].length + 1;
+  for (;e > t[n].length && n < t.length - 1; )
+    e -= t[n].length + 1, n++;
+  e = Math.max(0, Math.min(t[n].length, e));
+  let h = 0;
+  for (let r = 0;r < n; r++)
+    h += t[r].length + 1;
+  return h + e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== undefined && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i, s) {
+  if (i === s)
+    return;
+  const e = i.split(`
+`), t2 = s.split(`
+`), r = Math.max(e.length, t2.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t2[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+var getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, t2 = o, s = o, n) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i, m) => {
+    const d = n ? n(c, i) : c;
+    return i === 0 ? `${t2}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, n) {
+  if ("~standard" in e) {
+    const a = e["~standard"].validate(n);
+    if (a instanceof Promise)
+      throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+    return a.issues?.at(0)?.message;
+  }
+  return e(n);
+}
+
+class V {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i = stdin, output: n = stdout, render: s, signal: r, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t2, e) {
+    const i = this._subscribers.get(t2) ?? [];
+    i.push(e), this._subscribers.set(t2, i);
+  }
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  emit(t2, ...e) {
+    const i = this._subscribers.get(t2) ?? [], n = [];
+    for (const s of i)
+      s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+    for (const s of n)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== undefined && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "\t";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i = runValidation(this.opts.validate, this.value);
+        i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = undefined, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+          let r = e.lines.find((o) => o >= n);
+          if (r === undefined) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[r]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - r - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n < s)
+              r = n;
+            else {
+              const h = r - s;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+}
+function p$1(l, e) {
+  if (l === undefined || e.length === 0)
+    return 0;
+  const i = e.findIndex((s) => s.value === l);
+  return i !== -1 ? i : 0;
+}
+function g(l, e) {
+  return (e.label ?? String(e.value)).toLowerCase().includes(l.toLowerCase());
+}
+function m(l, e) {
+  if (e)
+    return l ? e : e[0];
+}
+var T$1 = class T extends V {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #e = 0;
+  #s = "";
+  #t;
+  #i;
+  #n;
+  get cursor() {
+    return this.#e;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput)
+      return styleText(["inverse", "hidden"], "_");
+    if (this._cursor >= this.userInput.length)
+      return `${this.userInput}█`;
+    const e = this.userInput.slice(0, this.cursor), t2 = this.userInput.slice(this.cursor, this.cursor + 1), i = this.userInput.slice(this.cursor + 1);
+    return `${e}${styleText("inverse", t2)}${i}`;
+  }
+  get options() {
+    return typeof this.#i == "function" ? this.#i() : this.#i;
+  }
+  constructor(e) {
+    super(e), this.#i = e.options, this.#n = e.placeholder;
+    const t2 = this.options;
+    this.filteredOptions = [...t2], this.multiple = e.multiple === true, this.#t = typeof e.options == "function" ? e.filter : e.filter ?? g;
+    let i;
+    if (e.initialValue && Array.isArray(e.initialValue) ? this.multiple ? i = e.initialValue : i = e.initialValue.slice(0, 1) : !this.multiple && this.options.length > 0 && (i = [this.options[0]?.value]), i)
+      for (const s of i) {
+        const n = t2.findIndex((o) => o.value === s);
+        n !== -1 && (this.toggleSelected(s), this.#e = n);
+      }
+    this.focusedValue = this.options[this.#e]?.value, this.on("key", (s, n) => this.#l(s, n)), this.on("userInput", (s) => this.#u(s));
+  }
+  _isActionKey(e, t2) {
+    return e === "\t" || this.multiple && this.isNavigating && t2.name === "space" && e !== undefined && e !== "";
+  }
+  #l(e, t2) {
+    const i = t2.name === "up", s = t2.name === "down", n = t2.name === "return", o = this.userInput === "" || this.userInput === "\t", u = this.#n, a = this.options, f = u !== undefined && u !== "" && a.some((r) => !r.disabled && (this.#t ? this.#t(u, r) : true));
+    if (t2.name === "tab" && o && f) {
+      this.userInput === "\t" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
+      return;
+    }
+    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t2.name === "tab" || this.isNavigating && t2.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
+  }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(e) {
+    this.filteredOptions.length !== 0 && (this.multiple ? this.selectedValues.includes(e) ? this.selectedValues = this.selectedValues.filter((t2) => t2 !== e) : this.selectedValues = [...this.selectedValues, e] : this.selectedValues = [e]);
+  }
+  #u(e) {
+    if (e !== this.#s) {
+      this.#s = e;
+      const t2 = this.options;
+      e && this.#t ? this.filteredOptions = t2.filter((n) => this.#t?.(e, n)) : this.filteredOptions = [...t2];
+      const i = p$1(this.focusedValue, this.filteredOptions);
+      this.#e = findCursor(i, 0, this.filteredOptions);
+      const s = this.filteredOptions[this.#e];
+      s && !s.disabled ? this.focusedValue = s.value : this.focusedValue = undefined, this.multiple || (this.focusedValue !== undefined ? this.toggleSelected(this.focusedValue) : this.deselectAll());
+    }
+  }
+};
+
+class r extends V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+var _ = {
+  Y: { type: "year", len: 4 },
+  M: { type: "month", len: 2 },
+  D: { type: "day", len: 2 }
+};
+function M(r2) {
+  return [...r2].map((t2) => _[t2]);
+}
+function P(r2) {
+  const i = new Intl.DateTimeFormat(r2, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(2000, 0, 15)), s = [];
+  let n = "/";
+  for (const e of i)
+    e.type === "literal" ? n = e.value.trim() || e.value : (e.type === "year" || e.type === "month" || e.type === "day") && s.push({ type: e.type, len: e.type === "year" ? 4 : 2 });
+  return { segments: s, separator: n };
+}
+function p(r2) {
+  return Number.parseInt((r2 || "0").replace(/_/g, "0"), 10) || 0;
+}
+function f(r2) {
+  return {
+    year: p(r2.year),
+    month: p(r2.month),
+    day: p(r2.day)
+  };
+}
+function c(r2, t2) {
+  return new Date(r2 || 2001, t2 || 1, 0).getDate();
+}
+function b(r2) {
+  const { year: t2, month: i, day: s } = f(r2);
+  if (!t2 || t2 < 0 || t2 > 9999 || !i || i < 1 || i > 12 || !s || s < 1)
+    return;
+  const n = new Date(Date.UTC(t2, i - 1, s));
+  if (!(n.getUTCFullYear() !== t2 || n.getUTCMonth() !== i - 1 || n.getUTCDate() !== s))
+    return { year: t2, month: i, day: s };
+}
+function C(r2) {
+  const t2 = b(r2);
+  return t2 ? new Date(Date.UTC(t2.year, t2.month - 1, t2.day)) : undefined;
+}
+function T2(r2, t2, i, s) {
+  const n = i ? {
+    year: i.getUTCFullYear(),
+    month: i.getUTCMonth() + 1,
+    day: i.getUTCDate()
+  } : null, e = s ? {
+    year: s.getUTCFullYear(),
+    month: s.getUTCMonth() + 1,
+    day: s.getUTCDate()
+  } : null;
+  return r2 === "year" ? { min: n?.year ?? 1, max: e?.year ?? 9999 } : r2 === "month" ? {
+    min: n && t2.year === n.year ? n.month : 1,
+    max: e && t2.year === e.year ? e.month : 12
+  } : {
+    min: n && t2.year === n.year && t2.month === n.month ? n.day : 1,
+    max: e && t2.year === e.year && t2.month === e.month ? e.day : c(t2.year, t2.month)
+  };
+}
+
+class U extends V {
+  #i;
+  #o;
+  #t;
+  #h;
+  #u;
+  #e = { segmentIndex: 0, positionInSegment: 0 };
+  #n = true;
+  #s = null;
+  inlineError = "";
+  get segmentCursor() {
+    return { ...this.#e };
+  }
+  get segmentValues() {
+    return { ...this.#t };
+  }
+  get segments() {
+    return this.#i;
+  }
+  get separator() {
+    return this.#o;
+  }
+  get formattedValue() {
+    return this.#l(this.#t);
+  }
+  #l(t2) {
+    return this.#i.map((i) => t2[i.type]).join(this.#o);
+  }
+  #r() {
+    this._setUserInput(this.#l(this.#t)), this._setValue(C(this.#t) ?? undefined);
+  }
+  constructor(t2) {
+    const i = t2.format ? { segments: M(t2.format), separator: t2.separator ?? "/" } : P(t2.locale), s = t2.separator ?? i.separator, n = t2.format ? M(t2.format) : i.segments, e = t2.initialValue ?? t2.defaultValue, m2 = e ? {
+      year: String(e.getUTCFullYear()).padStart(4, "0"),
+      month: String(e.getUTCMonth() + 1).padStart(2, "0"),
+      day: String(e.getUTCDate()).padStart(2, "0")
+    } : { year: "____", month: "__", day: "__" }, o = n.map((a) => m2[a.type]).join(s);
+    super({ ...t2, initialUserInput: o }, false), this.#i = n, this.#o = s, this.#t = m2, this.#h = t2.minDate, this.#u = t2.maxDate, this.#r(), this.on("cursor", (a) => this.#f(a)), this.on("key", (a, u) => this.#y(a, u)), this.on("finalize", () => this.#p(t2));
+  }
+  #a() {
+    const t2 = Math.max(0, Math.min(this.#e.segmentIndex, this.#i.length - 1)), i = this.#i[t2];
+    if (i)
+      return this.#e.positionInSegment = Math.max(0, Math.min(this.#e.positionInSegment, i.len - 1)), { segment: i, index: t2 };
+  }
+  #m(t2) {
+    this.inlineError = "", this.#s = null;
+    const i = this.#a();
+    i && (this.#e.segmentIndex = Math.max(0, Math.min(this.#i.length - 1, i.index + t2)), this.#e.positionInSegment = 0, this.#n = true);
+  }
+  #d(t2) {
+    const i = this.#a();
+    if (!i)
+      return;
+    const { segment: s } = i, n = this.#t[s.type], e = !n || n.replace(/_/g, "") === "", m2 = Number.parseInt((n || "0").replace(/_/g, "0"), 10) || 0, o = T2(s.type, f(this.#t), this.#h, this.#u);
+    let a;
+    e ? a = t2 === 1 ? o.min : o.max : a = Math.max(Math.min(o.max, m2 + t2), o.min), this.#t = {
+      ...this.#t,
+      [s.type]: a.toString().padStart(s.len, "0")
+    }, this.#n = true, this.#s = null, this.#r();
+  }
+  #f(t2) {
+    if (t2)
+      switch (t2) {
+        case "right":
+          return this.#m(1);
+        case "left":
+          return this.#m(-1);
+        case "up":
+          return this.#d(1);
+        case "down":
+          return this.#d(-1);
+      }
+  }
+  #y(t2, i) {
+    if (i?.name === "backspace" || i?.sequence === "" || i?.sequence === "\b" || t2 === "" || t2 === "\b") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      if (!this.#t[n.segment.type].replace(/_/g, "")) {
+        this.#m(-1);
+        return;
+      }
+      this.#t[n.segment.type] = "_".repeat(n.segment.len), this.#n = true, this.#e.positionInSegment = 0, this.#r();
+      return;
+    }
+    if (i?.name === "tab") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      const e = i.shift ? -1 : 1, m2 = n.index + e;
+      m2 >= 0 && m2 < this.#i.length && (this.#e.segmentIndex = m2, this.#e.positionInSegment = 0, this.#n = true);
+      return;
+    }
+    if (t2 && /^[0-9]$/.test(t2)) {
+      const n = this.#a();
+      if (!n)
+        return;
+      const { segment: e } = n, m2 = !this.#t[e.type].replace(/_/g, "");
+      if (this.#n && this.#s !== null && !m2) {
+        const h = this.#s + t2, d = { ...this.#t, [e.type]: h }, g2 = this.#g(d, e);
+        if (g2) {
+          this.inlineError = g2, this.#s = null, this.#n = false;
+          return;
+        }
+        this.inlineError = "", this.#t[e.type] = h, this.#s = null, this.#n = false, this.#r(), n.index < this.#i.length - 1 && (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true);
+        return;
+      }
+      this.#n && !m2 && (this.#t[e.type] = "_".repeat(e.len), this.#e.positionInSegment = 0), this.#n = false, this.#s = null;
+      const o = this.#t[e.type], a = o.indexOf("_"), u = a >= 0 ? a : Math.min(this.#e.positionInSegment, e.len - 1);
+      if (u < 0 || u >= e.len)
+        return;
+      let l = o.slice(0, u) + t2 + o.slice(u + 1), D = false;
+      if (u === 0 && o === "__" && (e.type === "month" || e.type === "day")) {
+        const h = Number.parseInt(t2, 10);
+        l = `0${t2}`, D = h <= (e.type === "month" ? 1 : 2);
+      }
+      if (e.type === "year" && (l = (o.replace(/_/g, "") + t2).padStart(e.len, "_")), !l.includes("_")) {
+        const h = { ...this.#t, [e.type]: l }, d = this.#g(h, e);
+        if (d) {
+          this.inlineError = d;
+          return;
+        }
+      }
+      this.inlineError = "", this.#t[e.type] = l;
+      const y = l.includes("_") ? undefined : b(this.#t);
+      if (y) {
+        const { year: h, month: d } = y, g2 = c(h, d);
+        this.#t = {
+          year: String(Math.max(0, Math.min(9999, h))).padStart(4, "0"),
+          month: String(Math.max(1, Math.min(12, d))).padStart(2, "0"),
+          day: String(Math.max(1, Math.min(g2, y.day))).padStart(2, "0")
+        };
+      }
+      this.#r();
+      const S = l.indexOf("_");
+      D ? (this.#n = true, this.#s = t2) : S >= 0 ? this.#e.positionInSegment = S : a >= 0 && n.index < this.#i.length - 1 ? (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true) : this.#e.positionInSegment = Math.min(u + 1, e.len - 1);
+    }
+  }
+  #g(t2, i) {
+    const { month: s, day: n } = f(t2);
+    if (i.type === "month" && (s < 0 || s > 12))
+      return settings.date.messages.invalidMonth;
+    if (i.type === "day" && (n < 0 || n > 31))
+      return settings.date.messages.invalidDay(31, "any month");
+  }
+  #p(t2) {
+    const { year: i, month: s, day: n } = f(this.#t);
+    if (i && s && n) {
+      const e = c(i, s);
+      this.#t = {
+        ...this.#t,
+        day: String(Math.min(n, e)).padStart(2, "0")
+      };
+    }
+    this.value = C(this.#t) ?? t2.defaultValue ?? undefined;
+  }
+}
+var u$2 = class u extends V {
+  options;
+  cursor = 0;
+  #t;
+  getGroupItems(t2) {
+    return this.options.filter((r2) => r2.group === t2);
+  }
+  isGroupSelected(t2) {
+    const r2 = this.getGroupItems(t2), e = this.value;
+    return e === undefined ? false : r2.every((s) => e.includes(s.value));
+  }
+  toggleValue() {
+    const t2 = this.options[this.cursor];
+    if (t2 !== undefined)
+      if (this.value === undefined && (this.value = []), t2.group === true) {
+        const r2 = t2.value, e = this.getGroupItems(r2);
+        this.isGroupSelected(r2) ? this.value = this.value.filter((s) => e.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
+      } else {
+        const r2 = this.value.includes(t2.value);
+        this.value = r2 ? this.value.filter((e) => e !== t2.value) : [...this.value, t2.value];
+      }
+  }
+  constructor(t2) {
+    super(t2, false);
+    const { options: r2 } = t2;
+    this.#t = t2.selectableGroups !== false, this.options = Object.entries(r2).flatMap(([e, s]) => [
+      { value: e, group: true, label: e },
+      ...s.map((i) => ({ ...i, group: e }))
+    ]), this.value = [...t2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: e }) => e === t2.cursorAt), this.#t ? 0 : 1), this.on("cursor", (e) => {
+      switch (e) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var o = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+
+class h extends V {
+  #t = false;
+  #s;
+  focused = "editor";
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${t2}█`;
+    const s = t2.slice(0, this.cursor), r2 = t2.slice(this.cursor, this.cursor + 1), i = t2.slice(this.cursor + 1);
+    return r2 === `
+` ? `${s}█
+${i}` : `${s}${styleText("inverse", r2)}${i}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  #r(t2) {
+    if (this.userInput.length === 0) {
+      this._setUserInput(t2);
+      return;
+    }
+    this._setUserInput(this.userInput.slice(0, this.cursor) + t2 + this.userInput.slice(this.cursor));
+  }
+  #i(t2) {
+    const s = this.value ?? "";
+    switch (t2) {
+      case "up":
+        this._cursor = findTextCursor(this._cursor, 0, -1, s);
+        return;
+      case "down":
+        this._cursor = findTextCursor(this._cursor, 0, 1, s);
+        return;
+      case "left":
+        this._cursor = findTextCursor(this._cursor, -1, 0, s);
+        return;
+      case "right":
+        this._cursor = findTextCursor(this._cursor, 1, 0, s);
+        return;
+    }
+  }
+  _shouldSubmit(t2, s) {
+    if (this.#s)
+      return this.focused === "submit" ? true : (this.#r(`
+`), this._cursor++, false);
+    const r2 = this.#t;
+    return this.#t = true, r2 && this.cursor === this.userInput.length ? (this.userInput[this.cursor - 1] === `
+` && (this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--), true) : (this.#r(`
+`), this._cursor++, false);
+  }
+  constructor(t2) {
+    const s = t2.initialUserInput ?? t2.initialValue;
+    super({
+      ...t2,
+      initialUserInput: s
+    }, false), s !== undefined && (this._cursor = s.length), this.#s = t2.showSubmit ?? false, this.on("key", (r2, i) => {
+      if (i?.name && o.has(i.name)) {
+        this.#t = false, this.#i(i.name);
+        return;
+      }
+      if (r2 === "\t" && this.#s) {
+        this.focused = this.focused === "editor" ? "submit" : "editor";
+        return;
+      }
+      if (i?.name !== "return") {
+        if (this.#t = false, i?.name === "backspace" && this.cursor > 0) {
+          this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--;
+          return;
+        }
+        if (i?.name === "delete" && this.cursor < this.userInput.length) {
+          this._setUserInput(this.userInput.slice(0, this.cursor) + this.userInput.slice(this.cursor + 1));
+          return;
+        }
+        r2 && (this.#s && this.focused === "submit" && (this.focused = "editor"), this.#r(r2 ?? ""), this._cursor++);
+      }
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+class a extends V {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor]?.value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e) => e.disabled !== true);
+  }
+  toggleAll() {
+    const e = this._enabledOptions, i = this.value !== undefined && this.value.length === e.length;
+    this.value = i ? [] : e.map((t2) => t2.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i.map((t2) => t2.value);
+  }
+  toggleValue() {
+    this.value === undefined && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i) => i !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i = Math.max(this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt), 0);
+    this.cursor = this.options[i]?.disabled ? findCursor(i, 1, this.options) : i, this.on("key", (t2, l) => {
+      l.name === "a" && this.toggleAll(), l.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t2) => {
+      switch (t2) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+}
+var n$1 = class n extends V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === undefined ? undefined : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o2 = this.options.findIndex(({ value: s }) => s === e.initialValue), t2 = o2 === -1 ? 0 : o2;
+    this.cursor = this.options[t2]?.disabled ? findCursor(t2, 1, this.options) : t2, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+
+// node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters as stripVTControlCharacters3 } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var unicodeOr = (o2, e) => unicode ? o2 : e;
+var S_STEP_ACTIVE = unicodeOr("◆", "*");
+var S_STEP_CANCEL = unicodeOr("■", "x");
+var S_STEP_ERROR = unicodeOr("▲", "x");
+var S_STEP_SUBMIT = unicodeOr("◇", "o");
+var S_BAR_START = unicodeOr("┌", "T");
+var S_BAR = unicodeOr("│", "|");
+var S_BAR_END = unicodeOr("└", "—");
+var S_BAR_START_RIGHT = unicodeOr("┐", "T");
+var S_BAR_END_RIGHT = unicodeOr("┘", "—");
+var S_RADIO_ACTIVE = unicodeOr("●", ">");
+var S_RADIO_INACTIVE = unicodeOr("○", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+var S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("▪", "•");
+var S_BAR_H = unicodeOr("─", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+var S_CONNECT_LEFT = unicodeOr("├", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+var S_INFO = unicodeOr("●", "•");
+var S_SUCCESS = unicodeOr("◆", "*");
+var S_WARN = unicodeOr("▲", "!");
+var S_ERROR = unicodeOr("■", "x");
+var symbol = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+  }
+};
+var symbolBar = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_BAR);
+    case "cancel":
+      return styleText2("red", S_BAR);
+    case "error":
+      return styleText2("yellow", S_BAR);
+    case "submit":
+      return styleText2("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o2, e) {
+  const r2 = [`${e ? `${styleText2("cyan", S_BAR)}  ` : ""}${o2.join(" • ")}`];
+  return e && r2.push(styleText2("cyan", S_BAR_END)), r2;
+}
+var I = (l, e, w, p2, b2, C2 = false) => {
+  let r2 = e, O = 0;
+  if (C2)
+    for (let i = p2 - 1;i >= w; i--) {
+      const m2 = l[i];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b2)
+        break;
+    }
+  else
+    for (let i = w;i < p2; i++) {
+      const m2 = l[i];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b2)
+        break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l,
+  options: e,
+  style: w,
+  output: p2 = process.stdout,
+  maxItems: b2 = Number.POSITIVE_INFINITY,
+  columnPadding: C2 = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i = getColumns(p2) - C2, m2 = getRows(p2), M2 = styleText2("dim", "..."), v = Math.max(m2 - r2, 0), a2 = Math.max(Math.min(b2, v), 5);
+  let f2 = 0;
+  l >= a2 - 3 && (f2 = Math.max(Math.min(l - a2 + 3, e.length - a2), 0));
+  let d = a2 < e.length && f2 > 0, c2 = a2 < e.length && f2 + a2 < e.length;
+  const W = Math.min(f2 + a2, e.length), s = [];
+  let g2 = 0;
+  d && g2++, c2 && g2++;
+  const T3 = f2 + (d ? 1 : 0), y = W - (c2 ? 1 : 0);
+  for (let t2 = T3;t2 < y; t2++) {
+    const n3 = e[t2], o2 = n3 ? w(n3, t2 === l) : "", h2 = wrapAnsi(o2, i, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g2 += h2.length;
+  }
+  if (g2 > v) {
+    let t2 = 0, n3 = 0, o2 = g2;
+    const h2 = l - T3;
+    let u3 = v;
+    const L = () => I(s, o2, 0, h2, u3), E = () => I(s, o2, h2 + 1, s.length, u3, true);
+    d ? ({ lineCount: o2, removals: t2 } = L(), o2 > u3 && (c2 || (u3 -= 1), { lineCount: o2, removals: n3 } = E())) : (c2 || (u3 -= 1), { lineCount: o2, removals: n3 } = E(), o2 > u3 && (u3 -= 1, { lineCount: o2, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n3 > 0 && (c2 = true, s.splice(s.length - n3, n3));
+  }
+  const x = [];
+  d && x.push(M2);
+  for (const t2 of s)
+    for (const n3 of t2)
+      x.push(n3);
+  return c2 && x.push(M2), x;
+};
+var confirm = (i) => {
+  const a2 = i.active ?? "Yes", s = i.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValue: i.initialValue ?? true,
+    render() {
+      const e = i.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l = e ? `${styleText2("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(i.output, i.message, l, u3), o2 = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${f2}
+`, c2 = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2(["strikethrough", "dim"], c2)}${e ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g2 = e ? styleText2("cyan", S_BAR_END) : "";
+          return `${o2}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a2)}`}${i.vertical ? e ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s}`}
+${g2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var m2 = (i, u3) => i.split(`
+`).map((d) => u3(d)).join(`
+`);
+var multiselect = (i) => {
+  const u3 = (t2, a2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return a2 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${m2(r2, (o2) => styleText2(["strikethrough", "gray"], o2))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${m2(r2, (o2) => styleText2("dim", o2))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m2(r2, (o2) => styleText2(["strikethrough", "dim"], o2))}` : a2 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m2(r2, (o2) => styleText2("dim", o2))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${m2(r2, (o2) => styleText2("dim", o2))}`;
+  }, d = i.required ?? true, v = i.showInstructions ?? true;
+  return new a({
+    options: i.options,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValues: i.initialValues,
+    required: d,
+    cursorAt: i.cursorAt,
+    validate(t2) {
+      if (d && (t2 === undefined || t2.length === 0))
+        return `Please select at least one option.
+${styleText2("reset", styleText2("dim", `Press ${styleText2(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText2("gray", styleText2("bgWhite", styleText2("inverse", " enter ")))} to submit`))}`;
+    },
+    render() {
+      const t2 = i.withGuide ?? settings.withGuide, a2 = wrapTextWithPrefix(i.output, i.message, t2 ? `${symbolBar(this.state)}  ` : "", `${symbol(this.state)}  `), r2 = `${t2 ? `${styleText2("gray", S_BAR)}
+` : ""}${a2}
+`, o2 = this.value ?? [], p2 = (n3, l) => {
+        if (n3.disabled)
+          return u3(n3, "disabled");
+        const s = o2.includes(n3.value);
+        return l && s ? u3(n3, "active-selected") : s ? u3(n3, "selected") : u3(n3, l ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u3(s, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), l = wrapTextWithPrefix(i.output, n3, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
+          return `${r2}${l}`;
+        }
+        case "cancel": {
+          const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u3(s, "cancelled")).join(styleText2("dim", ", "));
+          if (n3.trim() === "")
+            return `${r2}${styleText2("gray", S_BAR)}`;
+          const l = wrapTextWithPrefix(i.output, n3, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
+          return `${r2}${l}${t2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const n3 = t2 ? `${styleText2("yellow", S_BAR)}  ` : "", l = this.error.split(`
+`).map(($, C2) => C2 === 0 ? `${t2 ? `${styleText2("yellow", S_BAR_END)}  ` : ""}${styleText2("yellow", $)}` : `   ${$}`).join(`
+`), s = r2.split(`
+`).length, h2 = l.split(`
+`).length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i.maxItems,
+            columnPadding: n3.length,
+            rowPadding: s + h2,
+            style: p2
+          }).join(`
+${n3}`)}
+${l}
+`;
+        }
+        default: {
+          const n3 = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", l = r2.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2) : t2 ? [styleText2("cyan", S_BAR_END)] : [], h2 = s.join(`
+`), $ = s.length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i.maxItems,
+            columnPadding: n3.length,
+            rowPadding: l + $,
+            style: p2
+          }).join(`
+${n3}`)}
+${h2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var cancel = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${styleText2("red", o2)}
+
+`);
+};
+var intro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o2}
+`);
+};
+var outro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o2}
+
+`);
+};
+var W$1 = (o2) => o2;
+var C2 = (o2, e, s) => {
+  const a2 = {
+    hard: true,
+    trim: false
+  }, i = wrapAnsi(o2, e, a2).split(`
+`), c2 = i.reduce((n3, t2) => Math.max(dist_default2(t2), n3), 0), u3 = i.map(s).reduce((n3, t2) => Math.max(dist_default2(t2), n3), 0), g2 = e - (u3 - c2);
+  return wrapAnsi(o2, g2, a2);
+};
+var note = (o2 = "", e = "", s) => {
+  const a2 = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c2 = s?.format ?? W$1, g2 = ["", ...C2(o2, getColumns(a2) - 6, c2).split(`
+`).map(c2), ""], n3 = dist_default2(e), t2 = Math.max(g2.reduce((m3, F) => {
+    const O = dist_default2(F);
+    return O > m3 ? O : m3;
+  }, 0), n3) + 2, h2 = g2.map((m3) => `${styleText2("gray", S_BAR)}  ${m3}${" ".repeat(t2 - dist_default2(m3))}${styleText2("gray", S_BAR)}`).join(`
+`), T3 = i ? `${styleText2("gray", S_BAR)}
+` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a2.write(`${T3}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2("gray", S_BAR_H.repeat(Math.max(t2 - n3 - 1, 1)) + S_CORNER_TOP_RIGHT)}
+${h2}
+${styleText2("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+`);
+};
+var u3 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c2 = (t2, o2) => t2.includes(`
+`) ? t2.split(`
+`).map((d) => o2(d)).join(`
+`) : o2(t2);
+var select = (t2) => {
+  const o2 = (n3, m3) => {
+    if (n3 === undefined)
+      return "";
+    const s = n3.label ?? String(n3.value);
+    switch (m3) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c2(s, (i) => styleText2("gray", i))}${n3.hint ? ` ${styleText2("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c2(s, (i) => styleText2("dim", i))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${styleText2("dim", `(${n3.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c2(s, (i) => styleText2(["strikethrough", "dim"], i))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c2(s, (i) => styleText2("dim", i))}`;
+    }
+  }, d = t2.showInstructions ?? true;
+  return new n$1({
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
+    render() {
+      const n3 = t2.withGuide ?? settings.withGuide, m3 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i = wrapTextWithPrefix(t2.output, t2.message, s, m3), u4 = `${n3 ? `${styleText2("gray", S_BAR)}
+` : ""}${i}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(t2.output, o2(this.options[this.cursor], "selected"), r2);
+          return `${u4}${a2}`;
+        }
+        case "cancel": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(t2.output, o2(this.options[this.cursor], "cancelled"), r2);
+          return `${u4}${a2}${n3 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = n3 ? `${styleText2("cyan", S_BAR)}  ` : "", a2 = u4.split(`
+`).length, p2 = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [styleText2("cyan", S_BAR_END)] : [], b2 = p2.join(`
+`), f2 = p2.length + 1;
+          return `${u4}${r2}${limitOptions({
+            output: t2.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t2.maxItems,
+            columnPadding: r2.length,
+            rowPadding: a2 + f2,
+            style: (g2, x) => o2(g2, g2.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${b2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+
+// src/wiring.ts
+var INIT_TERMINALS = ["ghostty", "kitty", "alacritty"];
+var BEGIN = "# ttheme begin";
+var END = "# ttheme end";
+var BLOCK = /# ttheme begin\n[\s\S]*?# ttheme end\n?/;
+function upsertBlock(content, body) {
+  const block3 = `${BEGIN}
+${body}
+${END}
+`;
+  if (BLOCK.test(content)) {
+    return content.replace(BLOCK, block3);
+  }
+  if (content === "") {
+    return block3;
+  }
+  return `${content.replace(/\n*$/, `
+`)}
+${block3}`;
+}
+function detectTerminal(env) {
+  if (env.GHOSTTY_RESOURCES_DIR || env.TERM_PROGRAM === "ghostty") {
+    return "ghostty";
+  }
+  if (env.KITTY_WINDOW_ID) {
+    return "kitty";
+  }
+  if (env.WEZTERM_PANE) {
+    return "wezterm";
+  }
+  if (env.ALACRITTY_WINDOW_ID) {
+    return "alacritty";
+  }
+  if (env.ITERM_SESSION_ID || env.TERM_PROGRAM === "iTerm.app") {
+    return "iterm2";
+  }
+  if (env.TERM?.startsWith("foot")) {
+    return "foot";
+  }
+  return "unknown";
+}
+function ghosttyBlock(tthemeDir, palette, tabPalette) {
+  const lines = tabPalette === "seq" ? [`command = ${tthemeDir}/launch-tab.zsh`, "shell-integration = zsh"] : [];
+  lines.push(`theme = ${palette}`, `config-file = ${tthemeDir}/ttheme.conf`);
+  return lines.join(`
+`);
+}
+function zshrcBlock(tthemeDir, opts) {
+  const lines = [];
+  if (opts.tabPalette === "off") {
+    lines.push("export TTHEME_TAB_PALETTE=off");
+  }
+  if (!opts.announce) {
+    lines.push("export TTHEME_ANNOUNCE=0");
+  }
+  lines.push(`source ${tthemeDir}/ttheme.zsh`);
+  return lines.join(`
+`);
+}
+function kittyBlock(palette) {
+  return `include themes/${palette}.conf`;
+}
+function alacrittyBlock(themePath) {
+  return `[general]
+import = ["${themePath}"]`;
+}
+function weztermSnippet(palette) {
+  return `config.color_scheme = "${palette}"`;
+}
+
+// src/init.ts
+function listPalettes(root2) {
+  return readdirSync2(join3(root2, "dist", "ghostty", "themes")).sort();
+}
+function copyDir(copies, from, to) {
+  for (const f2 of readdirSync2(from)) {
+    copies.push({ from: join3(from, f2), to: join3(to, f2) });
+  }
+}
+function planInit(opts, paths) {
+  const dist = join3(paths.root, "dist");
+  const home = join3(paths.configHome, "ttheme");
+  const copies = [
+    { from: join3(paths.root, "shell", "ttheme.zsh"), to: join3(home, "ttheme.zsh") },
+    { from: join3(paths.root, "shell", "launch-tab.zsh"), to: join3(home, "launch-tab.zsh"), executable: true },
+    { from: join3(dist, "shell", "palettes.zsh"), to: join3(home, "palettes.zsh") },
+    { from: join3(dist, "ghostty", "ttheme.conf"), to: join3(home, "ttheme.conf") }
+  ];
+  copyDir(copies, join3(paths.root, "shell", "adapters"), join3(home, "adapters"));
+  const edits = [{ file: join3(paths.zdotdir, ".zshrc"), block: zshrcBlock(home, opts) }];
+  const notes = [];
+  if (opts.terminals.includes("ghostty")) {
+    copyDir(copies, join3(dist, "ghostty", "themes"), join3(paths.configHome, "ghostty", "themes"));
+    copyDir(copies, join3(paths.root, "ghostty", "shaders"), join3(paths.configHome, "ghostty", "shaders"));
+    edits.push({
+      file: join3(paths.configHome, "ghostty", "config"),
+      block: ghosttyBlock(home, opts.palette, opts.tabPalette)
+    });
+  }
+  if (opts.terminals.includes("kitty")) {
+    copyDir(copies, join3(dist, "kitty", "themes"), join3(paths.configHome, "kitty", "themes"));
+    edits.push({ file: join3(paths.configHome, "kitty", "kitty.conf"), block: kittyBlock(opts.palette) });
+  }
+  if (opts.terminals.includes("alacritty")) {
+    copyDir(copies, join3(dist, "alacritty", "themes"), join3(paths.configHome, "alacritty", "themes"));
+    const config = join3(paths.configHome, "alacritty", "alacritty.toml");
+    const block3 = alacrittyBlock(join3(paths.configHome, "alacritty", "themes", `${opts.palette}.toml`));
+    if (!existsSync(config) || readFileSync2(config, "utf8").includes("# ttheme begin")) {
+      edits.push({ file: config, block: block3 });
+    } else {
+      notes.push(`alacritty.toml already exists — add this to it yourself:
+${block3}`);
+    }
+  }
+  notes.push(`wezterm: copy colors/ from the release archive, then ${weztermSnippet(opts.palette)}`);
+  notes.push("iterm2: import the .itermcolors files from the release archive");
+  return { copies, edits, notes };
+}
+function applyInit(plan, link) {
+  for (const c3 of plan.copies) {
+    mkdirSync(dirname(c3.to), { recursive: true });
+    rmSync2(c3.to, { force: true });
+    if (link) {
+      symlinkSync(c3.from, c3.to);
+    } else {
+      copyFileSync(c3.from, c3.to);
+      if (c3.executable) {
+        chmodSync(c3.to, 493);
+      }
+    }
+  }
+  for (const e of plan.edits) {
+    mkdirSync(dirname(e.file), { recursive: true });
+    const current = existsSync(e.file) ? readFileSync2(e.file, "utf8") : "";
+    writeFileSync(e.file, upsertBlock(current, e.block));
+  }
+}
+function accepted(value) {
+  if (isCancel(value)) {
+    cancel("nothing changed");
+    process.exit(1);
+  }
+  return value;
+}
+async function ask(root2, detected, preselected, link) {
+  intro("ttheme init");
+  const terminals = accepted(await multiselect({
+    message: "wire which terminals?",
+    options: INIT_TERMINALS.map((t2) => ({ value: t2, hint: t2 === detected ? "detected" : undefined })),
+    initialValues: preselected,
+    required: true
+  }));
+  const palette = accepted(await select({
+    message: "startup palette",
+    options: listPalettes(root2).map((v) => ({ value: v })),
+    initialValue: "neutral",
+    maxItems: 12
+  }));
+  const tabPalette = accepted(await select({
+    message: "new tabs",
+    options: [
+      { value: "seq", label: "rotate through the palettes", hint: "default" },
+      { value: "off", label: "inherit the window colors" }
+    ],
+    initialValue: "seq"
+  }));
+  const announce = accepted(await confirm({ message: 'show the palette name under "Last login:"?', initialValue: true }));
+  return { terminals, palette, tabPalette, announce, link };
+}
+function report(plan, opts, interactive) {
+  const missing = [
+    ...plan.copies.filter((c3) => !existsSync(c3.to)).map((c3) => c3.to),
+    ...plan.edits.filter((e) => !readFileSync2(e.file, "utf8").includes("# ttheme begin")).map((e) => e.file)
+  ];
+  if (missing.length > 0) {
+    throw new Error(`init left gaps:
+${missing.join(`
+`)}`);
+  }
+  const lines = [`placed ${plan.copies.length} files`, ...plan.edits.map((e) => `wired ${e.file}`)];
+  if (opts.terminals.includes("ghostty")) {
+    lines.push("restart ghostty to pick up its config");
+  }
+  if (opts.terminals.includes("kitty")) {
+    lines.push("open a new kitty window to pick up its config");
+  }
+  lines.push(...plan.notes);
+  if (interactive) {
+    note(lines.join(`
+`), "done");
+    outro("open a new tab and run `ttheme`");
+  } else {
+    console.log(lines.join(`
+`));
+    console.log("open a new tab and run `ttheme`");
+  }
+}
+async function runInit(flags = {}) {
+  const root2 = join3(import.meta.dirname, "..");
+  const link = flags.link === true;
+  if (link && !existsSync(join3(root2, "src"))) {
+    throw new Error("--link needs a repo checkout");
+  }
+  if (!existsSync(join3(root2, "dist"))) {
+    if (typeof Bun === "undefined") {
+      throw new Error("this package is missing dist/ — reinstall @kecan0406/ttheme");
+    }
+    await build();
+  }
+  const home = homedir();
+  const configHome = process.env.XDG_CONFIG_HOME ?? join3(home, ".config");
+  const zdotdir = process.env.ZDOTDIR ?? home;
+  const paths = { root: root2, home, configHome, zdotdir };
+  const detected = detectTerminal(process.env);
+  const preselected = INIT_TERMINALS.filter((t2) => t2 === detected || existsSync(join3(configHome, t2)));
+  const interactive = !flags.yes && process.stdin.isTTY === true && process.stdout.isTTY === true;
+  let opts;
+  if (interactive) {
+    opts = await ask(root2, detected, preselected, link);
+  } else {
+    if (preselected.length === 0) {
+      throw new Error("no supported terminal detected — run this inside ghostty, kitty or alacritty");
+    }
+    opts = { terminals: preselected, palette: "neutral", tabPalette: "seq", announce: true, link };
+  }
+  const plan = planInit(opts, paths);
+  if (interactive) {
+    note([`copy ${plan.copies.length} files under ${configHome}`, ...plan.edits.map((e) => `edit ${e.file}`)].join(`
+`), `wiring ${opts.terminals.join(", ")}`);
+    const go = accepted(await confirm({ message: "apply these changes?" }));
+    if (!go) {
+      cancel("nothing changed");
+      process.exit(1);
+    }
+  }
+  applyInit(plan, opts.link);
+  report(plan, opts, interactive);
+}
+
+// src/cli.ts
+function createProgram() {
+  const program2 = new Command;
+  program2.name("ttheme").description(package_default.description).version(package_default.version).showHelpAfterError().exitOverride();
+  program2.command("build").description("emit dist/ for every terminal, plus the zsh palette table").addOption(new Option("--only <terminal...>", "rebuild just these terminals").choices(TERMINALS)).action((opts) => build(opts));
+  program2.command("init").description("install the palettes and wire your terminal configs").option("--yes", "accept every default without prompting").option("--link", "symlink from this checkout instead of copying").action((opts) => runInit(opts));
+  return program2;
+}
+async function runCli(argv) {
+  try {
+    await createProgram().parseAsync(argv);
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      return error.exitCode;
+    }
+    console.error(`
+${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+}
+
+// src/bin.ts
+process.exitCode = await runCli(process.argv);