@tfl-inc/cli 0.0.1 → 0.0.2

package/dist/index.js

@@ -129,14 +129,10 @@ var require_help = __commonJS((exports) => {
   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();
@@ -211,22 +207,22 @@ var require_help = __commonJS((exports) => {
     }
     longestSubcommandTermLength(cmd, helper) {
       return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
+        return Math.max(max, helper.subcommandTerm(command).length);
       }, 0);
     }
     longestOptionTermLength(cmd, helper) {
       return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+        return Math.max(max, helper.optionTerm(option).length);
       }, 0);
     }
     longestGlobalOptionTermLength(cmd, helper) {
       return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+        return Math.max(max, helper.optionTerm(option).length);
       }, 0);
     }
     longestArgumentTermLength(cmd, helper) {
       return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
+        return Math.max(max, helper.argumentTerm(argument).length);
       }, 0);
     }
     commandUsage(cmd) {
@@ -277,199 +273,102 @@ var require_help = __commonJS((exports) => {
         extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
       }
       if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
+        const extraDescripton = `(${extraInfo.join(", ")})`;
         if (argument.description) {
-          return `${argument.description} ${extraDescription}`;
+          return `${argument.description} ${extraDescripton}`;
         }
-        return extraDescription;
+        return extraDescripton;
       }
       return argument.description;
     }
     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 helpWidth = helper.helpWidth || 80;
+      const itemIndentWidth = 2;
+      const itemSeparatorWidth = 2;
+      function formatItem(term, description) {
+        if (description) {
+          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+        }
+        return term;
+      }
+      function formatList(textArray) {
+        return textArray.join(`
+`).replace(/^/gm, " ".repeat(itemIndentWidth));
+      }
+      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
       const commandDescription = helper.commandDescription(cmd);
       if (commandDescription.length > 0) {
         output = output.concat([
-          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
+          helper.wrap(commandDescription, helpWidth, 0),
           ""
         ]);
       }
       const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
+        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
       });
       if (argumentList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Arguments:"),
-          ...argumentList,
-          ""
-        ]);
+        output = output.concat(["Arguments:", formatList(argumentList), ""]);
       }
       const optionList = helper.visibleOptions(cmd).map((option) => {
-        return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
       });
       if (optionList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Options:"),
-          ...optionList,
-          ""
-        ]);
+        output = output.concat(["Options:", formatList(optionList), ""]);
       }
-      if (helper.showGlobalOptions) {
+      if (this.showGlobalOptions) {
         const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
         });
         if (globalOptionList.length > 0) {
           output = output.concat([
-            helper.styleTitle("Global Options:"),
-            ...globalOptionList,
+            "Global Options:",
+            formatList(globalOptionList),
             ""
           ]);
         }
       }
       const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd2)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd2)));
+        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
       });
       if (commandList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Commands:"),
-          ...commandList,
-          ""
-        ]);
+        output = output.concat(["Commands:", formatList(commandList), ""]);
       }
       return output.join(`
 `);
     }
-    displayWidth(str) {
-      return stripColor(str).length;
-    }
-    styleTitle(str) {
-      return str;
-    }
-    styleUsage(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word === "[command]")
-          return this.styleSubcommandText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleCommandText(word);
-      }).join(" ");
-    }
-    styleCommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleOptionDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleSubcommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleArgumentDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleDescriptionText(str) {
-      return str;
-    }
-    styleOptionTerm(str) {
-      return this.styleOptionText(str);
-    }
-    styleSubcommandTerm(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleSubcommandText(word);
-      }).join(" ");
-    }
-    styleArgumentTerm(str) {
-      return this.styleArgumentText(str);
-    }
-    styleOptionText(str) {
-      return str;
-    }
-    styleArgumentText(str) {
-      return str;
-    }
-    styleSubcommandText(str) {
-      return str;
-    }
-    styleCommandText(str) {
-      return str;
-    }
     padWidth(cmd, helper) {
       return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
     }
-    preformatted(str) {
-      return /\n[^\S\r\n]/.test(str);
-    }
-    formatItem(term, termWidth, description, helper) {
-      const itemIndent = 2;
-      const itemIndentStr = " ".repeat(itemIndent);
-      if (!description)
-        return itemIndentStr + term;
-      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
-      const spacerWidth = 2;
-      const helpWidth = this.helpWidth ?? 80;
-      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
-      let formattedDescription;
-      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
-        formattedDescription = description;
-      } else {
-        const wrappedDescription = helper.boxWrap(description, remainingWidth);
-        formattedDescription = wrappedDescription.replace(/\n/g, `
-` + " ".repeat(termWidth + spacerWidth));
-      }
-      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
-${itemIndentStr}`);
-    }
-    boxWrap(str, width) {
-      if (width < this.minWidthToWrap)
+    wrap(str, width, indent, minColumnWidth = 40) {
+      const indents = " \\f\\t\\v   -   　\uFEFF";
+      const manualIndent = new RegExp(`[\\n][${indents}]+`);
+      if (str.match(manualIndent))
         return str;
-      const 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(`
+      const columnWidth = width - indent;
+      if (columnWidth < minColumnWidth)
+        return str;
+      const leadingStr = str.slice(0, indent);
+      const columnText = str.slice(indent).replace(`\r
+`, `
+`);
+      const indentString = " ".repeat(indent);
+      const zeroWidthSpace = "​";
+      const breaks = `\\s${zeroWidthSpace}`;
+      const regex = new RegExp(`
+|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
+      const lines = columnText.match(regex) || [];
+      return leadingStr + lines.map((line, i) => {
+        if (line === `
+`)
+          return "";
+        return (i > 0 ? indentString : "") + line.trimEnd();
+      }).join(`
 `);
     }
   }
-  function stripColor(str) {
-    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str.replace(sgrPattern, "");
-  }
   exports.Help = Help;
-  exports.stripColor = stripColor;
 });
 
 // ../../node_modules/commander/lib/option.js
@@ -564,10 +463,7 @@ var require_option = __commonJS((exports) => {
       return this.short.replace(/^-/, "");
     }
     attributeName() {
-      if (this.negate) {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      return camelcase(this.name());
+      return camelcase(this.name().replace(/^no-/, ""));
     }
     is(arg) {
       return this.short === arg || this.long === arg;
@@ -612,38 +508,14 @@ var require_option = __commonJS((exports) => {
   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]))
+    const flagParts = flags.split(/[ |,]+/);
+    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
       shortFlag = flagParts.shift();
-    if (!shortFlag && longFlagExp.test(flagParts[0])) {
+    longFlag = flagParts.shift();
+    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
       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}'.`);
+      longFlag = undefined;
+    }
     return { shortFlag, longFlag };
   }
   exports.Option = Option;
@@ -732,7 +604,7 @@ var require_command = __commonJS((exports) => {
   var process2 = __require("node:process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
-  var { Help, stripColor } = require_help();
+  var { Help } = require_help();
   var { Option, DualOptions } = require_option();
   var { suggestSimilar } = require_suggestSimilar();
 
@@ -743,7 +615,7 @@ var require_command = __commonJS((exports) => {
       this.options = [];
       this.parent = null;
       this._allowUnknownOption = false;
-      this._allowExcessArguments = false;
+      this._allowExcessArguments = true;
       this.registeredArguments = [];
       this._args = this.registeredArguments;
       this.args = [];
@@ -770,16 +642,12 @@ var require_command = __commonJS((exports) => {
       this._lifeCycleHooks = {};
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
-      this._savedState = null;
       this._outputConfiguration = {
         writeOut: (str) => process2.stdout.write(str),
         writeErr: (str) => process2.stderr.write(str),
-        outputError: (str, write) => write(str),
         getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
         getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
-        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
-        stripColor: (str) => stripColor(str)
+        outputError: (str, write) => write(str)
       };
       this._hidden = false;
       this._helpOption = undefined;
@@ -1211,53 +1079,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return userArgs;
     }
     parse(argv, parseOptions) {
-      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       this._parseCommand([], userArgs);
       return this;
     }
     async parseAsync(argv, parseOptions) {
-      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       await this._parseCommand([], userArgs);
       return this;
     }
-    _prepareForParse() {
-      if (this._savedState === null) {
-        this.saveStateBeforeParse();
-      } else {
-        this.restoreStateBeforeParse();
-      }
-    }
-    saveStateBeforeParse() {
-      this._savedState = {
-        _name: this._name,
-        _optionValues: { ...this._optionValues },
-        _optionValueSources: { ...this._optionValueSources }
-      };
-    }
-    restoreStateBeforeParse() {
-      if (this._storeOptionsAsProperties)
-        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
-- either make a new Command for each call to parse, or stop storing options as properties`);
-      this._name = this._savedState._name;
-      this._scriptPath = null;
-      this.rawArgs = [];
-      this._optionValues = { ...this._savedState._optionValues };
-      this._optionValueSources = { ...this._savedState._optionValueSources };
-      this.args = [];
-      this.processedArgs = [];
-    }
-    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs.existsSync(executableFile))
-        return;
-      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-      const executableMissing = `'${executableFile}' does not exist
- - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-      throw new Error(executableMissing);
-    }
     _executeSubCommand(subcommand, args) {
       args = args.slice();
       let launchWithNode = false;
@@ -1281,7 +1111,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let resolvedScriptPath;
         try {
           resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch {
+        } catch (err) {
           resolvedScriptPath = this._scriptPath;
         }
         executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
@@ -1307,7 +1137,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
           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" });
@@ -1333,7 +1162,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       proc.on("error", (err) => {
         if (err.code === "ENOENT") {
-          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
+          const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+          const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+          throw new Error(executableMissing);
         } else if (err.code === "EACCES") {
           throw new Error(`'${executableFile}' not executable`);
         }
@@ -1351,7 +1185,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
       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, () => {
@@ -1870,38 +1703,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     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);
+      if (helper.helpWidth === undefined) {
+        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
+      }
+      return helper.formatHelp(this, helper);
     }
-    _getOutputContext(contextOptions) {
+    _getHelpContext(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();
+      const context = { error: !!contextOptions.error };
+      let write;
+      if (context.error) {
+        write = (arg) => this._outputConfiguration.writeErr(arg);
       } 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 };
+        write = (arg) => this._outputConfiguration.writeOut(arg);
+      }
+      context.write = contextOptions.write || write;
+      context.command = this;
+      return context;
     }
     outputHelp(contextOptions) {
       let deprecatedCallback;
@@ -1909,27 +1727,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
         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 });
+      const context = this._getHelpContext(contextOptions);
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
+      this.emit("beforeHelp", context);
+      let helpInformation = this.helpInformation(context);
       if (deprecatedCallback) {
         helpInformation = deprecatedCallback(helpInformation);
         if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
           throw new Error("outputHelp callback must return a string or a Buffer");
         }
       }
-      outputContext.write(helpInformation);
+      context.write(helpInformation);
       if (this._getHelpOption()?.long) {
         this.emit(this._getHelpOption().long);
       }
-      this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
+      this.emit("afterHelp", context);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
     }
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
@@ -1957,7 +1770,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
+      let exitCode = process2.exitCode || 0;
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -2022,15 +1835,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return arg;
     });
   }
-  function useColor() {
-    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
-      return false;
-    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
-      return true;
-    return;
-  }
   exports.Command = Command;
-  exports.useColor = useColor;
 });
 
 // ../../node_modules/commander/index.js
@@ -2053,6 +1858,1523 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// ../../node_modules/color-name/index.js
+var require_color_name = __commonJS((exports, module) => {
+  module.exports = {
+    aliceblue: [240, 248, 255],
+    antiquewhite: [250, 235, 215],
+    aqua: [0, 255, 255],
+    aquamarine: [127, 255, 212],
+    azure: [240, 255, 255],
+    beige: [245, 245, 220],
+    bisque: [255, 228, 196],
+    black: [0, 0, 0],
+    blanchedalmond: [255, 235, 205],
+    blue: [0, 0, 255],
+    blueviolet: [138, 43, 226],
+    brown: [165, 42, 42],
+    burlywood: [222, 184, 135],
+    cadetblue: [95, 158, 160],
+    chartreuse: [127, 255, 0],
+    chocolate: [210, 105, 30],
+    coral: [255, 127, 80],
+    cornflowerblue: [100, 149, 237],
+    cornsilk: [255, 248, 220],
+    crimson: [220, 20, 60],
+    cyan: [0, 255, 255],
+    darkblue: [0, 0, 139],
+    darkcyan: [0, 139, 139],
+    darkgoldenrod: [184, 134, 11],
+    darkgray: [169, 169, 169],
+    darkgreen: [0, 100, 0],
+    darkgrey: [169, 169, 169],
+    darkkhaki: [189, 183, 107],
+    darkmagenta: [139, 0, 139],
+    darkolivegreen: [85, 107, 47],
+    darkorange: [255, 140, 0],
+    darkorchid: [153, 50, 204],
+    darkred: [139, 0, 0],
+    darksalmon: [233, 150, 122],
+    darkseagreen: [143, 188, 143],
+    darkslateblue: [72, 61, 139],
+    darkslategray: [47, 79, 79],
+    darkslategrey: [47, 79, 79],
+    darkturquoise: [0, 206, 209],
+    darkviolet: [148, 0, 211],
+    deeppink: [255, 20, 147],
+    deepskyblue: [0, 191, 255],
+    dimgray: [105, 105, 105],
+    dimgrey: [105, 105, 105],
+    dodgerblue: [30, 144, 255],
+    firebrick: [178, 34, 34],
+    floralwhite: [255, 250, 240],
+    forestgreen: [34, 139, 34],
+    fuchsia: [255, 0, 255],
+    gainsboro: [220, 220, 220],
+    ghostwhite: [248, 248, 255],
+    gold: [255, 215, 0],
+    goldenrod: [218, 165, 32],
+    gray: [128, 128, 128],
+    green: [0, 128, 0],
+    greenyellow: [173, 255, 47],
+    grey: [128, 128, 128],
+    honeydew: [240, 255, 240],
+    hotpink: [255, 105, 180],
+    indianred: [205, 92, 92],
+    indigo: [75, 0, 130],
+    ivory: [255, 255, 240],
+    khaki: [240, 230, 140],
+    lavender: [230, 230, 250],
+    lavenderblush: [255, 240, 245],
+    lawngreen: [124, 252, 0],
+    lemonchiffon: [255, 250, 205],
+    lightblue: [173, 216, 230],
+    lightcoral: [240, 128, 128],
+    lightcyan: [224, 255, 255],
+    lightgoldenrodyellow: [250, 250, 210],
+    lightgray: [211, 211, 211],
+    lightgreen: [144, 238, 144],
+    lightgrey: [211, 211, 211],
+    lightpink: [255, 182, 193],
+    lightsalmon: [255, 160, 122],
+    lightseagreen: [32, 178, 170],
+    lightskyblue: [135, 206, 250],
+    lightslategray: [119, 136, 153],
+    lightslategrey: [119, 136, 153],
+    lightsteelblue: [176, 196, 222],
+    lightyellow: [255, 255, 224],
+    lime: [0, 255, 0],
+    limegreen: [50, 205, 50],
+    linen: [250, 240, 230],
+    magenta: [255, 0, 255],
+    maroon: [128, 0, 0],
+    mediumaquamarine: [102, 205, 170],
+    mediumblue: [0, 0, 205],
+    mediumorchid: [186, 85, 211],
+    mediumpurple: [147, 112, 219],
+    mediumseagreen: [60, 179, 113],
+    mediumslateblue: [123, 104, 238],
+    mediumspringgreen: [0, 250, 154],
+    mediumturquoise: [72, 209, 204],
+    mediumvioletred: [199, 21, 133],
+    midnightblue: [25, 25, 112],
+    mintcream: [245, 255, 250],
+    mistyrose: [255, 228, 225],
+    moccasin: [255, 228, 181],
+    navajowhite: [255, 222, 173],
+    navy: [0, 0, 128],
+    oldlace: [253, 245, 230],
+    olive: [128, 128, 0],
+    olivedrab: [107, 142, 35],
+    orange: [255, 165, 0],
+    orangered: [255, 69, 0],
+    orchid: [218, 112, 214],
+    palegoldenrod: [238, 232, 170],
+    palegreen: [152, 251, 152],
+    paleturquoise: [175, 238, 238],
+    palevioletred: [219, 112, 147],
+    papayawhip: [255, 239, 213],
+    peachpuff: [255, 218, 185],
+    peru: [205, 133, 63],
+    pink: [255, 192, 203],
+    plum: [221, 160, 221],
+    powderblue: [176, 224, 230],
+    purple: [128, 0, 128],
+    rebeccapurple: [102, 51, 153],
+    red: [255, 0, 0],
+    rosybrown: [188, 143, 143],
+    royalblue: [65, 105, 225],
+    saddlebrown: [139, 69, 19],
+    salmon: [250, 128, 114],
+    sandybrown: [244, 164, 96],
+    seagreen: [46, 139, 87],
+    seashell: [255, 245, 238],
+    sienna: [160, 82, 45],
+    silver: [192, 192, 192],
+    skyblue: [135, 206, 235],
+    slateblue: [106, 90, 205],
+    slategray: [112, 128, 144],
+    slategrey: [112, 128, 144],
+    snow: [255, 250, 250],
+    springgreen: [0, 255, 127],
+    steelblue: [70, 130, 180],
+    tan: [210, 180, 140],
+    teal: [0, 128, 128],
+    thistle: [216, 191, 216],
+    tomato: [255, 99, 71],
+    turquoise: [64, 224, 208],
+    violet: [238, 130, 238],
+    wheat: [245, 222, 179],
+    white: [255, 255, 255],
+    whitesmoke: [245, 245, 245],
+    yellow: [255, 255, 0],
+    yellowgreen: [154, 205, 50]
+  };
+});
+
+// ../../node_modules/color-convert/conversions.js
+var require_conversions = __commonJS((exports, module) => {
+  var cssKeywords = require_color_name();
+  var reverseKeywords = {};
+  for (const key of Object.keys(cssKeywords)) {
+    reverseKeywords[cssKeywords[key]] = key;
+  }
+  var convert = {
+    rgb: { channels: 3, labels: "rgb" },
+    hsl: { channels: 3, labels: "hsl" },
+    hsv: { channels: 3, labels: "hsv" },
+    hwb: { channels: 3, labels: "hwb" },
+    cmyk: { channels: 4, labels: "cmyk" },
+    xyz: { channels: 3, labels: "xyz" },
+    lab: { channels: 3, labels: "lab" },
+    lch: { channels: 3, labels: "lch" },
+    hex: { channels: 1, labels: ["hex"] },
+    keyword: { channels: 1, labels: ["keyword"] },
+    ansi16: { channels: 1, labels: ["ansi16"] },
+    ansi256: { channels: 1, labels: ["ansi256"] },
+    hcg: { channels: 3, labels: ["h", "c", "g"] },
+    apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+    gray: { channels: 1, labels: ["gray"] }
+  };
+  module.exports = convert;
+  for (const model of Object.keys(convert)) {
+    if (!("channels" in convert[model])) {
+      throw new Error("missing channels property: " + model);
+    }
+    if (!("labels" in convert[model])) {
+      throw new Error("missing channel labels property: " + model);
+    }
+    if (convert[model].labels.length !== convert[model].channels) {
+      throw new Error("channel and label counts mismatch: " + model);
+    }
+    const { channels, labels } = convert[model];
+    delete convert[model].channels;
+    delete convert[model].labels;
+    Object.defineProperty(convert[model], "channels", { value: channels });
+    Object.defineProperty(convert[model], "labels", { value: labels });
+  }
+  convert.rgb.hsl = function(rgb) {
+    const r = rgb[0] / 255;
+    const g = rgb[1] / 255;
+    const b = rgb[2] / 255;
+    const min = Math.min(r, g, b);
+    const max = Math.max(r, g, b);
+    const delta = max - min;
+    let h;
+    let s;
+    if (max === min) {
+      h = 0;
+    } else if (r === max) {
+      h = (g - b) / delta;
+    } else if (g === max) {
+      h = 2 + (b - r) / delta;
+    } else if (b === max) {
+      h = 4 + (r - g) / delta;
+    }
+    h = Math.min(h * 60, 360);
+    if (h < 0) {
+      h += 360;
+    }
+    const l = (min + max) / 2;
+    if (max === min) {
+      s = 0;
+    } else if (l <= 0.5) {
+      s = delta / (max + min);
+    } else {
+      s = delta / (2 - max - min);
+    }
+    return [h, s * 100, l * 100];
+  };
+  convert.rgb.hsv = function(rgb) {
+    let rdif;
+    let gdif;
+    let bdif;
+    let h;
+    let s;
+    const r = rgb[0] / 255;
+    const g = rgb[1] / 255;
+    const b = rgb[2] / 255;
+    const v = Math.max(r, g, b);
+    const diff = v - Math.min(r, g, b);
+    const diffc = function(c) {
+      return (v - c) / 6 / diff + 1 / 2;
+    };
+    if (diff === 0) {
+      h = 0;
+      s = 0;
+    } else {
+      s = diff / v;
+      rdif = diffc(r);
+      gdif = diffc(g);
+      bdif = diffc(b);
+      if (r === v) {
+        h = bdif - gdif;
+      } else if (g === v) {
+        h = 1 / 3 + rdif - bdif;
+      } else if (b === v) {
+        h = 2 / 3 + gdif - rdif;
+      }
+      if (h < 0) {
+        h += 1;
+      } else if (h > 1) {
+        h -= 1;
+      }
+    }
+    return [
+      h * 360,
+      s * 100,
+      v * 100
+    ];
+  };
+  convert.rgb.hwb = function(rgb) {
+    const r = rgb[0];
+    const g = rgb[1];
+    let b = rgb[2];
+    const h = convert.rgb.hsl(rgb)[0];
+    const w = 1 / 255 * Math.min(r, Math.min(g, b));
+    b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+    return [h, w * 100, b * 100];
+  };
+  convert.rgb.cmyk = function(rgb) {
+    const r = rgb[0] / 255;
+    const g = rgb[1] / 255;
+    const b = rgb[2] / 255;
+    const k = Math.min(1 - r, 1 - g, 1 - b);
+    const c = (1 - r - k) / (1 - k) || 0;
+    const m = (1 - g - k) / (1 - k) || 0;
+    const y = (1 - b - k) / (1 - k) || 0;
+    return [c * 100, m * 100, y * 100, k * 100];
+  };
+  function comparativeDistance(x, y) {
+    return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+  }
+  convert.rgb.keyword = function(rgb) {
+    const reversed = reverseKeywords[rgb];
+    if (reversed) {
+      return reversed;
+    }
+    let currentClosestDistance = Infinity;
+    let currentClosestKeyword;
+    for (const keyword of Object.keys(cssKeywords)) {
+      const value = cssKeywords[keyword];
+      const distance = comparativeDistance(rgb, value);
+      if (distance < currentClosestDistance) {
+        currentClosestDistance = distance;
+        currentClosestKeyword = keyword;
+      }
+    }
+    return currentClosestKeyword;
+  };
+  convert.keyword.rgb = function(keyword) {
+    return cssKeywords[keyword];
+  };
+  convert.rgb.xyz = function(rgb) {
+    let r = rgb[0] / 255;
+    let g = rgb[1] / 255;
+    let b = rgb[2] / 255;
+    r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+    g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+    b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+    const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+    const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+    const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+    return [x * 100, y * 100, z * 100];
+  };
+  convert.rgb.lab = function(rgb) {
+    const xyz = convert.rgb.xyz(rgb);
+    let x = xyz[0];
+    let y = xyz[1];
+    let z = xyz[2];
+    x /= 95.047;
+    y /= 100;
+    z /= 108.883;
+    x = x > 0.008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+    y = y > 0.008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+    z = z > 0.008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+    const l = 116 * y - 16;
+    const a = 500 * (x - y);
+    const b = 200 * (y - z);
+    return [l, a, b];
+  };
+  convert.hsl.rgb = function(hsl) {
+    const h = hsl[0] / 360;
+    const s = hsl[1] / 100;
+    const l = hsl[2] / 100;
+    let t2;
+    let t3;
+    let val;
+    if (s === 0) {
+      val = l * 255;
+      return [val, val, val];
+    }
+    if (l < 0.5) {
+      t2 = l * (1 + s);
+    } else {
+      t2 = l + s - l * s;
+    }
+    const t1 = 2 * l - t2;
+    const rgb = [0, 0, 0];
+    for (let i = 0;i < 3; i++) {
+      t3 = h + 1 / 3 * -(i - 1);
+      if (t3 < 0) {
+        t3++;
+      }
+      if (t3 > 1) {
+        t3--;
+      }
+      if (6 * t3 < 1) {
+        val = t1 + (t2 - t1) * 6 * t3;
+      } else if (2 * t3 < 1) {
+        val = t2;
+      } else if (3 * t3 < 2) {
+        val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+      } else {
+        val = t1;
+      }
+      rgb[i] = val * 255;
+    }
+    return rgb;
+  };
+  convert.hsl.hsv = function(hsl) {
+    const h = hsl[0];
+    let s = hsl[1] / 100;
+    let l = hsl[2] / 100;
+    let smin = s;
+    const lmin = Math.max(l, 0.01);
+    l *= 2;
+    s *= l <= 1 ? l : 2 - l;
+    smin *= lmin <= 1 ? lmin : 2 - lmin;
+    const v = (l + s) / 2;
+    const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+    return [h, sv * 100, v * 100];
+  };
+  convert.hsv.rgb = function(hsv) {
+    const h = hsv[0] / 60;
+    const s = hsv[1] / 100;
+    let v = hsv[2] / 100;
+    const hi = Math.floor(h) % 6;
+    const f = h - Math.floor(h);
+    const p = 255 * v * (1 - s);
+    const q = 255 * v * (1 - s * f);
+    const t = 255 * v * (1 - s * (1 - f));
+    v *= 255;
+    switch (hi) {
+      case 0:
+        return [v, t, p];
+      case 1:
+        return [q, v, p];
+      case 2:
+        return [p, v, t];
+      case 3:
+        return [p, q, v];
+      case 4:
+        return [t, p, v];
+      case 5:
+        return [v, p, q];
+    }
+  };
+  convert.hsv.hsl = function(hsv) {
+    const h = hsv[0];
+    const s = hsv[1] / 100;
+    const v = hsv[2] / 100;
+    const vmin = Math.max(v, 0.01);
+    let sl;
+    let l;
+    l = (2 - s) * v;
+    const lmin = (2 - s) * vmin;
+    sl = s * vmin;
+    sl /= lmin <= 1 ? lmin : 2 - lmin;
+    sl = sl || 0;
+    l /= 2;
+    return [h, sl * 100, l * 100];
+  };
+  convert.hwb.rgb = function(hwb) {
+    const h = hwb[0] / 360;
+    let wh = hwb[1] / 100;
+    let bl = hwb[2] / 100;
+    const ratio = wh + bl;
+    let f;
+    if (ratio > 1) {
+      wh /= ratio;
+      bl /= ratio;
+    }
+    const i = Math.floor(6 * h);
+    const v = 1 - bl;
+    f = 6 * h - i;
+    if ((i & 1) !== 0) {
+      f = 1 - f;
+    }
+    const n = wh + f * (v - wh);
+    let r;
+    let g;
+    let b;
+    switch (i) {
+      default:
+      case 6:
+      case 0:
+        r = v;
+        g = n;
+        b = wh;
+        break;
+      case 1:
+        r = n;
+        g = v;
+        b = wh;
+        break;
+      case 2:
+        r = wh;
+        g = v;
+        b = n;
+        break;
+      case 3:
+        r = wh;
+        g = n;
+        b = v;
+        break;
+      case 4:
+        r = n;
+        g = wh;
+        b = v;
+        break;
+      case 5:
+        r = v;
+        g = wh;
+        b = n;
+        break;
+    }
+    return [r * 255, g * 255, b * 255];
+  };
+  convert.cmyk.rgb = function(cmyk) {
+    const c = cmyk[0] / 100;
+    const m = cmyk[1] / 100;
+    const y = cmyk[2] / 100;
+    const k = cmyk[3] / 100;
+    const r = 1 - Math.min(1, c * (1 - k) + k);
+    const g = 1 - Math.min(1, m * (1 - k) + k);
+    const b = 1 - Math.min(1, y * (1 - k) + k);
+    return [r * 255, g * 255, b * 255];
+  };
+  convert.xyz.rgb = function(xyz) {
+    const x = xyz[0] / 100;
+    const y = xyz[1] / 100;
+    const z = xyz[2] / 100;
+    let r;
+    let g;
+    let b;
+    r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+    g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+    b = x * 0.0557 + y * -0.204 + z * 1.057;
+    r = r > 0.0031308 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
+    g = g > 0.0031308 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
+    b = b > 0.0031308 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
+    r = Math.min(Math.max(0, r), 1);
+    g = Math.min(Math.max(0, g), 1);
+    b = Math.min(Math.max(0, b), 1);
+    return [r * 255, g * 255, b * 255];
+  };
+  convert.xyz.lab = function(xyz) {
+    let x = xyz[0];
+    let y = xyz[1];
+    let z = xyz[2];
+    x /= 95.047;
+    y /= 100;
+    z /= 108.883;
+    x = x > 0.008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+    y = y > 0.008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+    z = z > 0.008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+    const l = 116 * y - 16;
+    const a = 500 * (x - y);
+    const b = 200 * (y - z);
+    return [l, a, b];
+  };
+  convert.lab.xyz = function(lab) {
+    const l = lab[0];
+    const a = lab[1];
+    const b = lab[2];
+    let x;
+    let y;
+    let z;
+    y = (l + 16) / 116;
+    x = a / 500 + y;
+    z = y - b / 200;
+    const y2 = y ** 3;
+    const x2 = x ** 3;
+    const z2 = z ** 3;
+    y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+    x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+    z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+    x *= 95.047;
+    y *= 100;
+    z *= 108.883;
+    return [x, y, z];
+  };
+  convert.lab.lch = function(lab) {
+    const l = lab[0];
+    const a = lab[1];
+    const b = lab[2];
+    let h;
+    const hr = Math.atan2(b, a);
+    h = hr * 360 / 2 / Math.PI;
+    if (h < 0) {
+      h += 360;
+    }
+    const c = Math.sqrt(a * a + b * b);
+    return [l, c, h];
+  };
+  convert.lch.lab = function(lch) {
+    const l = lch[0];
+    const c = lch[1];
+    const h = lch[2];
+    const hr = h / 360 * 2 * Math.PI;
+    const a = c * Math.cos(hr);
+    const b = c * Math.sin(hr);
+    return [l, a, b];
+  };
+  convert.rgb.ansi16 = function(args, saturation = null) {
+    const [r, g, b] = args;
+    let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
+    value = Math.round(value / 50);
+    if (value === 0) {
+      return 30;
+    }
+    let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+    if (value === 2) {
+      ansi += 60;
+    }
+    return ansi;
+  };
+  convert.hsv.ansi16 = function(args) {
+    return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+  };
+  convert.rgb.ansi256 = function(args) {
+    const r = args[0];
+    const g = args[1];
+    const b = args[2];
+    if (r === g && g === b) {
+      if (r < 8) {
+        return 16;
+      }
+      if (r > 248) {
+        return 231;
+      }
+      return Math.round((r - 8) / 247 * 24) + 232;
+    }
+    const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+    return ansi;
+  };
+  convert.ansi16.rgb = function(args) {
+    let color = args % 10;
+    if (color === 0 || color === 7) {
+      if (args > 50) {
+        color += 3.5;
+      }
+      color = color / 10.5 * 255;
+      return [color, color, color];
+    }
+    const mult = (~~(args > 50) + 1) * 0.5;
+    const r = (color & 1) * mult * 255;
+    const g = (color >> 1 & 1) * mult * 255;
+    const b = (color >> 2 & 1) * mult * 255;
+    return [r, g, b];
+  };
+  convert.ansi256.rgb = function(args) {
+    if (args >= 232) {
+      const c = (args - 232) * 10 + 8;
+      return [c, c, c];
+    }
+    args -= 16;
+    let rem;
+    const r = Math.floor(args / 36) / 5 * 255;
+    const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+    const b = rem % 6 / 5 * 255;
+    return [r, g, b];
+  };
+  convert.rgb.hex = function(args) {
+    const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+    const string = integer.toString(16).toUpperCase();
+    return "000000".substring(string.length) + string;
+  };
+  convert.hex.rgb = function(args) {
+    const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+    if (!match) {
+      return [0, 0, 0];
+    }
+    let colorString = match[0];
+    if (match[0].length === 3) {
+      colorString = colorString.split("").map((char) => {
+        return char + char;
+      }).join("");
+    }
+    const integer = parseInt(colorString, 16);
+    const r = integer >> 16 & 255;
+    const g = integer >> 8 & 255;
+    const b = integer & 255;
+    return [r, g, b];
+  };
+  convert.rgb.hcg = function(rgb) {
+    const r = rgb[0] / 255;
+    const g = rgb[1] / 255;
+    const b = rgb[2] / 255;
+    const max = Math.max(Math.max(r, g), b);
+    const min = Math.min(Math.min(r, g), b);
+    const chroma = max - min;
+    let grayscale;
+    let hue;
+    if (chroma < 1) {
+      grayscale = min / (1 - chroma);
+    } else {
+      grayscale = 0;
+    }
+    if (chroma <= 0) {
+      hue = 0;
+    } else if (max === r) {
+      hue = (g - b) / chroma % 6;
+    } else if (max === g) {
+      hue = 2 + (b - r) / chroma;
+    } else {
+      hue = 4 + (r - g) / chroma;
+    }
+    hue /= 6;
+    hue %= 1;
+    return [hue * 360, chroma * 100, grayscale * 100];
+  };
+  convert.hsl.hcg = function(hsl) {
+    const s = hsl[1] / 100;
+    const l = hsl[2] / 100;
+    const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+    let f = 0;
+    if (c < 1) {
+      f = (l - 0.5 * c) / (1 - c);
+    }
+    return [hsl[0], c * 100, f * 100];
+  };
+  convert.hsv.hcg = function(hsv) {
+    const s = hsv[1] / 100;
+    const v = hsv[2] / 100;
+    const c = s * v;
+    let f = 0;
+    if (c < 1) {
+      f = (v - c) / (1 - c);
+    }
+    return [hsv[0], c * 100, f * 100];
+  };
+  convert.hcg.rgb = function(hcg) {
+    const h = hcg[0] / 360;
+    const c = hcg[1] / 100;
+    const g = hcg[2] / 100;
+    if (c === 0) {
+      return [g * 255, g * 255, g * 255];
+    }
+    const pure = [0, 0, 0];
+    const hi = h % 1 * 6;
+    const v = hi % 1;
+    const w = 1 - v;
+    let mg = 0;
+    switch (Math.floor(hi)) {
+      case 0:
+        pure[0] = 1;
+        pure[1] = v;
+        pure[2] = 0;
+        break;
+      case 1:
+        pure[0] = w;
+        pure[1] = 1;
+        pure[2] = 0;
+        break;
+      case 2:
+        pure[0] = 0;
+        pure[1] = 1;
+        pure[2] = v;
+        break;
+      case 3:
+        pure[0] = 0;
+        pure[1] = w;
+        pure[2] = 1;
+        break;
+      case 4:
+        pure[0] = v;
+        pure[1] = 0;
+        pure[2] = 1;
+        break;
+      default:
+        pure[0] = 1;
+        pure[1] = 0;
+        pure[2] = w;
+    }
+    mg = (1 - c) * g;
+    return [
+      (c * pure[0] + mg) * 255,
+      (c * pure[1] + mg) * 255,
+      (c * pure[2] + mg) * 255
+    ];
+  };
+  convert.hcg.hsv = function(hcg) {
+    const c = hcg[1] / 100;
+    const g = hcg[2] / 100;
+    const v = c + g * (1 - c);
+    let f = 0;
+    if (v > 0) {
+      f = c / v;
+    }
+    return [hcg[0], f * 100, v * 100];
+  };
+  convert.hcg.hsl = function(hcg) {
+    const c = hcg[1] / 100;
+    const g = hcg[2] / 100;
+    const l = g * (1 - c) + 0.5 * c;
+    let s = 0;
+    if (l > 0 && l < 0.5) {
+      s = c / (2 * l);
+    } else if (l >= 0.5 && l < 1) {
+      s = c / (2 * (1 - l));
+    }
+    return [hcg[0], s * 100, l * 100];
+  };
+  convert.hcg.hwb = function(hcg) {
+    const c = hcg[1] / 100;
+    const g = hcg[2] / 100;
+    const v = c + g * (1 - c);
+    return [hcg[0], (v - c) * 100, (1 - v) * 100];
+  };
+  convert.hwb.hcg = function(hwb) {
+    const w = hwb[1] / 100;
+    const b = hwb[2] / 100;
+    const v = 1 - b;
+    const c = v - w;
+    let g = 0;
+    if (c < 1) {
+      g = (v - c) / (1 - c);
+    }
+    return [hwb[0], c * 100, g * 100];
+  };
+  convert.apple.rgb = function(apple) {
+    return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+  };
+  convert.rgb.apple = function(rgb) {
+    return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+  };
+  convert.gray.rgb = function(args) {
+    return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+  };
+  convert.gray.hsl = function(args) {
+    return [0, 0, args[0]];
+  };
+  convert.gray.hsv = convert.gray.hsl;
+  convert.gray.hwb = function(gray) {
+    return [0, 100, gray[0]];
+  };
+  convert.gray.cmyk = function(gray) {
+    return [0, 0, 0, gray[0]];
+  };
+  convert.gray.lab = function(gray) {
+    return [gray[0], 0, 0];
+  };
+  convert.gray.hex = function(gray) {
+    const val = Math.round(gray[0] / 100 * 255) & 255;
+    const integer = (val << 16) + (val << 8) + val;
+    const string = integer.toString(16).toUpperCase();
+    return "000000".substring(string.length) + string;
+  };
+  convert.rgb.gray = function(rgb) {
+    const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+    return [val / 255 * 100];
+  };
+});
+
+// ../../node_modules/color-convert/route.js
+var require_route = __commonJS((exports, module) => {
+  var conversions = require_conversions();
+  function buildGraph() {
+    const graph = {};
+    const models = Object.keys(conversions);
+    for (let len = models.length, i = 0;i < len; i++) {
+      graph[models[i]] = {
+        distance: -1,
+        parent: null
+      };
+    }
+    return graph;
+  }
+  function deriveBFS(fromModel) {
+    const graph = buildGraph();
+    const queue = [fromModel];
+    graph[fromModel].distance = 0;
+    while (queue.length) {
+      const current = queue.pop();
+      const adjacents = Object.keys(conversions[current]);
+      for (let len = adjacents.length, i = 0;i < len; i++) {
+        const adjacent = adjacents[i];
+        const node = graph[adjacent];
+        if (node.distance === -1) {
+          node.distance = graph[current].distance + 1;
+          node.parent = current;
+          queue.unshift(adjacent);
+        }
+      }
+    }
+    return graph;
+  }
+  function link(from, to) {
+    return function(args) {
+      return to(from(args));
+    };
+  }
+  function wrapConversion(toModel, graph) {
+    const path2 = [graph[toModel].parent, toModel];
+    let fn = conversions[graph[toModel].parent][toModel];
+    let cur = graph[toModel].parent;
+    while (graph[cur].parent) {
+      path2.unshift(graph[cur].parent);
+      fn = link(conversions[graph[cur].parent][cur], fn);
+      cur = graph[cur].parent;
+    }
+    fn.conversion = path2;
+    return fn;
+  }
+  module.exports = function(fromModel) {
+    const graph = deriveBFS(fromModel);
+    const conversion = {};
+    const models = Object.keys(graph);
+    for (let len = models.length, i = 0;i < len; i++) {
+      const toModel = models[i];
+      const node = graph[toModel];
+      if (node.parent === null) {
+        continue;
+      }
+      conversion[toModel] = wrapConversion(toModel, graph);
+    }
+    return conversion;
+  };
+});
+
+// ../../node_modules/color-convert/index.js
+var require_color_convert = __commonJS((exports, module) => {
+  var conversions = require_conversions();
+  var route = require_route();
+  var convert = {};
+  var models = Object.keys(conversions);
+  function wrapRaw(fn) {
+    const wrappedFn = function(...args) {
+      const arg0 = args[0];
+      if (arg0 === undefined || arg0 === null) {
+        return arg0;
+      }
+      if (arg0.length > 1) {
+        args = arg0;
+      }
+      return fn(args);
+    };
+    if ("conversion" in fn) {
+      wrappedFn.conversion = fn.conversion;
+    }
+    return wrappedFn;
+  }
+  function wrapRounded(fn) {
+    const wrappedFn = function(...args) {
+      const arg0 = args[0];
+      if (arg0 === undefined || arg0 === null) {
+        return arg0;
+      }
+      if (arg0.length > 1) {
+        args = arg0;
+      }
+      const result = fn(args);
+      if (typeof result === "object") {
+        for (let len = result.length, i = 0;i < len; i++) {
+          result[i] = Math.round(result[i]);
+        }
+      }
+      return result;
+    };
+    if ("conversion" in fn) {
+      wrappedFn.conversion = fn.conversion;
+    }
+    return wrappedFn;
+  }
+  models.forEach((fromModel) => {
+    convert[fromModel] = {};
+    Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+    Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+    const routes = route(fromModel);
+    const routeModels = Object.keys(routes);
+    routeModels.forEach((toModel) => {
+      const fn = routes[toModel];
+      convert[fromModel][toModel] = wrapRounded(fn);
+      convert[fromModel][toModel].raw = wrapRaw(fn);
+    });
+  });
+  module.exports = convert;
+});
+
+// ../../node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS((exports, module) => {
+  var wrapAnsi16 = (fn, offset) => (...args) => {
+    const code = fn(...args);
+    return `\x1B[${code + offset}m`;
+  };
+  var wrapAnsi256 = (fn, offset) => (...args) => {
+    const code = fn(...args);
+    return `\x1B[${38 + offset};5;${code}m`;
+  };
+  var wrapAnsi16m = (fn, offset) => (...args) => {
+    const rgb = fn(...args);
+    return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+  };
+  var ansi2ansi = (n) => n;
+  var rgb2rgb = (r, g, b) => [r, g, b];
+  var setLazyProperty = (object, property, get) => {
+    Object.defineProperty(object, property, {
+      get: () => {
+        const value = get();
+        Object.defineProperty(object, property, {
+          value,
+          enumerable: true,
+          configurable: true
+        });
+        return value;
+      },
+      enumerable: true,
+      configurable: true
+    });
+  };
+  var colorConvert;
+  var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+    if (colorConvert === undefined) {
+      colorConvert = require_color_convert();
+    }
+    const offset = isBackground ? 10 : 0;
+    const styles = {};
+    for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+      const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+      if (sourceSpace === targetSpace) {
+        styles[name] = wrap(identity, offset);
+      } else if (typeof suite === "object") {
+        styles[name] = wrap(suite[targetSpace], offset);
+      }
+    }
+    return styles;
+  };
+  function assembleStyles() {
+    const codes = new Map;
+    const styles = {
+      modifier: {
+        reset: [0, 0],
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        blackBright: [90, 39],
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        bgBlackBright: [100, 49],
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    styles.color.gray = styles.color.blackBright;
+    styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+    styles.color.grey = styles.color.blackBright;
+    styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+    for (const [groupName, group] of Object.entries(styles)) {
+      for (const [styleName, style] of Object.entries(group)) {
+        styles[styleName] = {
+          open: `\x1B[${style[0]}m`,
+          close: `\x1B[${style[1]}m`
+        };
+        group[styleName] = styles[styleName];
+        codes.set(style[0], style[1]);
+      }
+      Object.defineProperty(styles, groupName, {
+        value: group,
+        enumerable: false
+      });
+    }
+    Object.defineProperty(styles, "codes", {
+      value: codes,
+      enumerable: false
+    });
+    styles.color.close = "\x1B[39m";
+    styles.bgColor.close = "\x1B[49m";
+    setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+    setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+    setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+    setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+    setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+    setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+    return styles;
+  }
+  Object.defineProperty(module, "exports", {
+    enumerable: true,
+    get: assembleStyles
+  });
+});
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS((exports, module) => {
+  module.exports = (flag, argv = process.argv) => {
+    const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf("--");
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+  };
+});
+
+// ../../node_modules/chalk/node_modules/supports-color/index.js
+var require_supports_color = __commonJS((exports, module) => {
+  var os2 = __require("os");
+  var tty = __require("tty");
+  var hasFlag = require_has_flag();
+  var { env: env2 } = process;
+  var forceColor;
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    forceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    forceColor = 1;
+  }
+  if ("FORCE_COLOR" in env2) {
+    if (env2.FORCE_COLOR === "true") {
+      forceColor = 1;
+    } else if (env2.FORCE_COLOR === "false") {
+      forceColor = 0;
+    } else {
+      forceColor = env2.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env2.FORCE_COLOR, 10), 3);
+    }
+  }
+  function translateLevel(level) {
+    if (level === 0) {
+      return false;
+    }
+    return {
+      level,
+      hasBasic: true,
+      has256: level >= 2,
+      has16m: level >= 3
+    };
+  }
+  function supportsColor(haveStream, streamIsTTY) {
+    if (forceColor === 0) {
+      return 0;
+    }
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+      return 0;
+    }
+    const min = forceColor || 0;
+    if (env2.TERM === "dumb") {
+      return min;
+    }
+    if (process.platform === "win32") {
+      const osRelease = os2.release().split(".");
+      if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        return Number(osRelease[2]) >= 14931 ? 3 : 2;
+      }
+      return 1;
+    }
+    if ("CI" in env2) {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
+        return 1;
+      }
+      return min;
+    }
+    if ("TEAMCITY_VERSION" in env2) {
+      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env2.COLORTERM === "truecolor") {
+      return 3;
+    }
+    if ("TERM_PROGRAM" in env2) {
+      const version = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      switch (env2.TERM_PROGRAM) {
+        case "iTerm.app":
+          return version >= 3 ? 3 : 2;
+        case "Apple_Terminal":
+          return 2;
+      }
+    }
+    if (/-256(color)?$/i.test(env2.TERM)) {
+      return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
+      return 1;
+    }
+    if ("COLORTERM" in env2) {
+      return 1;
+    }
+    return min;
+  }
+  function getSupportLevel(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+  }
+  module.exports = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+  };
+});
+
+// ../../node_modules/chalk/source/util.js
+var require_util = __commonJS((exports, module) => {
+  var stringReplaceAll = (string, substring, replacer) => {
+    let index = string.indexOf(substring);
+    if (index === -1) {
+      return string;
+    }
+    const substringLength = substring.length;
+    let endIndex = 0;
+    let returnValue = "";
+    do {
+      returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+      endIndex = index + substringLength;
+      index = string.indexOf(substring, endIndex);
+    } while (index !== -1);
+    returnValue += string.substr(endIndex);
+    return returnValue;
+  };
+  var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+    let endIndex = 0;
+    let returnValue = "";
+    do {
+      const gotCR = string[index - 1] === "\r";
+      returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+      endIndex = index + 1;
+      index = string.indexOf(`
+`, endIndex);
+    } while (index !== -1);
+    returnValue += string.substr(endIndex);
+    return returnValue;
+  };
+  module.exports = {
+    stringReplaceAll,
+    stringEncaseCRLFWithFirstIndex
+  };
+});
+
+// ../../node_modules/chalk/source/templates.js
+var require_templates = __commonJS((exports, module) => {
+  var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+  var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+  var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+  var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+  var ESCAPES = new Map([
+    ["n", `
+`],
+    ["r", "\r"],
+    ["t", "\t"],
+    ["b", "\b"],
+    ["f", "\f"],
+    ["v", "\v"],
+    ["0", "\x00"],
+    ["\\", "\\"],
+    ["e", "\x1B"],
+    ["a", "\x07"]
+  ]);
+  function unescape(c) {
+    const u = c[0] === "u";
+    const bracket = c[1] === "{";
+    if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
+      return String.fromCharCode(parseInt(c.slice(1), 16));
+    }
+    if (u && bracket) {
+      return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+    }
+    return ESCAPES.get(c) || c;
+  }
+  function parseArguments(name, arguments_) {
+    const results = [];
+    const chunks = arguments_.trim().split(/\s*,\s*/g);
+    let matches;
+    for (const chunk of chunks) {
+      const number = Number(chunk);
+      if (!Number.isNaN(number)) {
+        results.push(number);
+      } else if (matches = chunk.match(STRING_REGEX)) {
+        results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+      } else {
+        throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+      }
+    }
+    return results;
+  }
+  function parseStyle(style) {
+    STYLE_REGEX.lastIndex = 0;
+    const results = [];
+    let matches;
+    while ((matches = STYLE_REGEX.exec(style)) !== null) {
+      const name = matches[1];
+      if (matches[2]) {
+        const args = parseArguments(name, matches[2]);
+        results.push([name].concat(args));
+      } else {
+        results.push([name]);
+      }
+    }
+    return results;
+  }
+  function buildStyle(chalk, styles) {
+    const enabled = {};
+    for (const layer of styles) {
+      for (const style of layer.styles) {
+        enabled[style[0]] = layer.inverse ? null : style.slice(1);
+      }
+    }
+    let current = chalk;
+    for (const [styleName, styles2] of Object.entries(enabled)) {
+      if (!Array.isArray(styles2)) {
+        continue;
+      }
+      if (!(styleName in current)) {
+        throw new Error(`Unknown Chalk style: ${styleName}`);
+      }
+      current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
+    }
+    return current;
+  }
+  module.exports = (chalk, temporary) => {
+    const styles = [];
+    const chunks = [];
+    let chunk = [];
+    temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+      if (escapeCharacter) {
+        chunk.push(unescape(escapeCharacter));
+      } else if (style) {
+        const string = chunk.join("");
+        chunk = [];
+        chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
+        styles.push({ inverse, styles: parseStyle(style) });
+      } else if (close) {
+        if (styles.length === 0) {
+          throw new Error("Found extraneous } in Chalk template literal");
+        }
+        chunks.push(buildStyle(chalk, styles)(chunk.join("")));
+        chunk = [];
+        styles.pop();
+      } else {
+        chunk.push(character);
+      }
+    });
+    chunks.push(chunk.join(""));
+    if (styles.length > 0) {
+      const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+      throw new Error(errMessage);
+    }
+    return chunks.join("");
+  };
+});
+
+// ../../node_modules/chalk/source/index.js
+var require_source = __commonJS((exports, module) => {
+  var ansiStyles = require_ansi_styles();
+  var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+  var {
+    stringReplaceAll,
+    stringEncaseCRLFWithFirstIndex
+  } = require_util();
+  var { isArray } = Array;
+  var levelMapping = [
+    "ansi",
+    "ansi",
+    "ansi256",
+    "ansi16m"
+  ];
+  var styles = Object.create(null);
+  var applyOptions = (object, options = {}) => {
+    if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+      throw new Error("The `level` option should be an integer from 0 to 3");
+    }
+    const colorLevel = stdoutColor ? stdoutColor.level : 0;
+    object.level = options.level === undefined ? colorLevel : options.level;
+  };
+
+  class ChalkClass {
+    constructor(options) {
+      return chalkFactory(options);
+    }
+  }
+  var chalkFactory = (options) => {
+    const chalk2 = {};
+    applyOptions(chalk2, options);
+    chalk2.template = (...arguments_) => chalkTag(chalk2.template, ...arguments_);
+    Object.setPrototypeOf(chalk2, Chalk.prototype);
+    Object.setPrototypeOf(chalk2.template, chalk2);
+    chalk2.template.constructor = () => {
+      throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+    };
+    chalk2.template.Instance = ChalkClass;
+    return chalk2.template;
+  };
+  function Chalk(options) {
+    return chalkFactory(options);
+  }
+  for (const [styleName, style] of Object.entries(ansiStyles)) {
+    styles[styleName] = {
+      get() {
+        const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+        Object.defineProperty(this, styleName, { value: builder });
+        return builder;
+      }
+    };
+  }
+  styles.visible = {
+    get() {
+      const builder = createBuilder(this, this._styler, true);
+      Object.defineProperty(this, "visible", { value: builder });
+      return builder;
+    }
+  };
+  var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+  for (const model of usedModels) {
+    styles[model] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+          return createBuilder(this, styler, this._isEmpty);
+        };
+      }
+    };
+  }
+  for (const model of usedModels) {
+    const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+    styles[bgModel] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+          return createBuilder(this, styler, this._isEmpty);
+        };
+      }
+    };
+  }
+  var proto = Object.defineProperties(() => {}, {
+    ...styles,
+    level: {
+      enumerable: true,
+      get() {
+        return this._generator.level;
+      },
+      set(level) {
+        this._generator.level = level;
+      }
+    }
+  });
+  var createStyler = (open, close, parent) => {
+    let openAll;
+    let closeAll;
+    if (parent === undefined) {
+      openAll = open;
+      closeAll = close;
+    } else {
+      openAll = parent.openAll + open;
+      closeAll = close + parent.closeAll;
+    }
+    return {
+      open,
+      close,
+      openAll,
+      closeAll,
+      parent
+    };
+  };
+  var createBuilder = (self, _styler, _isEmpty) => {
+    const builder = (...arguments_) => {
+      if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+        return applyStyle(builder, chalkTag(builder, ...arguments_));
+      }
+      return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+    };
+    Object.setPrototypeOf(builder, proto);
+    builder._generator = self;
+    builder._styler = _styler;
+    builder._isEmpty = _isEmpty;
+    return builder;
+  };
+  var applyStyle = (self, string) => {
+    if (self.level <= 0 || !string) {
+      return self._isEmpty ? "" : string;
+    }
+    let styler = self._styler;
+    if (styler === undefined) {
+      return string;
+    }
+    const { openAll, closeAll } = styler;
+    if (string.indexOf("\x1B") !== -1) {
+      while (styler !== undefined) {
+        string = stringReplaceAll(string, styler.close, styler.open);
+        styler = styler.parent;
+      }
+    }
+    const lfIndex = string.indexOf(`
+`);
+    if (lfIndex !== -1) {
+      string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+    }
+    return openAll + string + closeAll;
+  };
+  var template;
+  var chalkTag = (chalk2, ...strings) => {
+    const [firstString] = strings;
+    if (!isArray(firstString) || !isArray(firstString.raw)) {
+      return strings.join(" ");
+    }
+    const arguments_ = strings.slice(1);
+    const parts = [firstString.raw[0]];
+    for (let i = 1;i < firstString.length; i++) {
+      parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"), String(firstString.raw[i]));
+    }
+    if (template === undefined) {
+      template = require_templates();
+    }
+    return template(chalk2, parts.join(""));
+  };
+  Object.defineProperties(Chalk.prototype, styles);
+  var chalk = Chalk();
+  chalk.supportsColor = stdoutColor;
+  chalk.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+  chalk.stderr.supportsColor = stderrColor;
+  module.exports = chalk;
+});
+
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -2081,28 +3403,23 @@ import path from "node:path";
 var ENV_API_URL = process.env.THOUGHTFUL_API_URL;
 var ENV_NO_COLOR = process.env.THOUGHTFUL_NO_COLOR === "1" || process.env.THOUGHTFUL_NO_COLOR === "true";
 var ENV_DEBUG = process.env.THOUGHTFUL_DEBUG === "1" || process.env.THOUGHTFUL_DEBUG === "true";
-function isDevelopmentMode() {
-  if (true) {
-    return true;
-  }
-  const currentFile = new URL(import.meta.url).pathname;
-  return currentFile.includes("/src/");
-}
+var PRODUCTION_API_URL = "https://www.tokatsu.ai";
+var DEVELOPMENT_API_URL = "http://localhost:3000";
 var environmentOverride = null;
 function setEnvironmentOverride(env) {
   environmentOverride = env;
 }
 function getDefaultApiUrl() {
   if (environmentOverride === "dev") {
-    return "http://localhost:3000";
+    return DEVELOPMENT_API_URL;
   }
   if (environmentOverride === "prod") {
-    return "https://www.tokatsu.ai";
+    return PRODUCTION_API_URL;
   }
   if (ENV_API_URL) {
     return ENV_API_URL;
   }
-  return isDevelopmentMode() ? "http://localhost:3000" : "https://www.tokatsu.ai";
+  return PRODUCTION_API_URL;
 }
 function getXdgConfigHome() {
   return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
@@ -2142,7 +3459,6 @@ function ensureConfigDir() {
 }
 function loadConfig() {
   ensureConfigDir();
-  const smartDefault = isDevelopmentMode() ? "http://localhost:3000" : "https://www.tokatsu.ai";
   if (!fs.existsSync(CONFIG_FILE)) {
     return {
       apiUrl: getDefaultApiUrl()
@@ -2152,7 +3468,7 @@ function loadConfig() {
     const content = fs.readFileSync(CONFIG_FILE, "utf-8");
     const fileConfig = JSON.parse(content);
     const config = {
-      apiUrl: smartDefault,
+      apiUrl: PRODUCTION_API_URL,
       ...fileConfig
     };
     if (environmentOverride || ENV_API_URL) {
@@ -2204,496 +3520,8 @@ function isLoggedIn() {
   return Boolean(config.accessToken);
 }
 
-// ../../node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// ../../node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "node:process";
-import os2 from "node:os";
-import tty from "node:tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env: env2 } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env2) {
-    if (env2.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env2.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env2.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env2.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env2 && "AGENT_NAME" in env2) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env2.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os2.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env2) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env2))) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env2) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env2.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env2.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env2.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env2.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env2) {
-    const version = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env2.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env2.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env2) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// ../../node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// ../../node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
 // src/output.ts
+var import_chalk = __toESM(require_source(), 1);
 var globalOptions = {};
 function setGlobalOptions(options) {
   globalOptions = { ...options };
@@ -2723,13 +3551,13 @@ function shouldDisableColors() {
   return false;
 }
 var c = {
-  blue: (text) => shouldDisableColors() ? text : source_default.blue(text),
-  green: (text) => shouldDisableColors() ? text : source_default.green(text),
-  yellow: (text) => shouldDisableColors() ? text : source_default.yellow(text),
-  red: (text) => shouldDisableColors() ? text : source_default.red(text),
-  gray: (text) => shouldDisableColors() ? text : source_default.gray(text),
-  white: (text) => shouldDisableColors() ? text : source_default.white(text),
-  cyan: (text) => shouldDisableColors() ? text : source_default.cyan(text)
+  blue: (text) => shouldDisableColors() ? text : import_chalk.default.blue(text),
+  green: (text) => shouldDisableColors() ? text : import_chalk.default.green(text),
+  yellow: (text) => shouldDisableColors() ? text : import_chalk.default.yellow(text),
+  red: (text) => shouldDisableColors() ? text : import_chalk.default.red(text),
+  gray: (text) => shouldDisableColors() ? text : import_chalk.default.gray(text),
+  white: (text) => shouldDisableColors() ? text : import_chalk.default.white(text),
+  cyan: (text) => shouldDisableColors() ? text : import_chalk.default.cyan(text)
 };
 function isQuiet() {
   return Boolean(globalOptions.quiet);
@@ -3290,6 +4118,7 @@ Examples:
 }
 
 // src/commands/orgs.ts
+var import_chalk2 = __toESM(require_source(), 1);
 function registerOrgsCommands(program2) {
   const orgs = program2.command("orgs").description("Manage organizations").addHelpText("after", `
 Examples:
@@ -3315,7 +4144,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk2.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3331,22 +4160,22 @@ Examples:
           }))
         }));
       } else {
-        console.log(source_default.blue("Organizations"));
+        console.log(import_chalk2.default.blue("Organizations"));
         console.log();
         if (data.memberships.length === 0) {
-          console.log(source_default.gray("  No organizations found"));
+          console.log(import_chalk2.default.gray("  No organizations found"));
           return;
         }
         for (const m of data.memberships) {
           const isActive = m.id === data.activeMembershipId;
-          const marker = isActive ? source_default.green("*") : " ";
-          const name = isActive ? source_default.white(m.organizationName) : source_default.gray(m.organizationName);
-          const domain = m.organizationDomain ? source_default.gray(` (${m.organizationDomain})`) : "";
+          const marker = isActive ? import_chalk2.default.green("*") : " ";
+          const name = isActive ? import_chalk2.default.white(m.organizationName) : import_chalk2.default.gray(m.organizationName);
+          const domain = m.organizationDomain ? import_chalk2.default.gray(` (${m.organizationDomain})`) : "";
           console.log(`  ${marker} ${name}${domain}`);
-          console.log(source_default.gray(`      ID: ${m.organizationId}`));
+          console.log(import_chalk2.default.gray(`      ID: ${m.organizationId}`));
         }
         console.log();
-        console.log(source_default.gray("* = active organization"));
+        console.log(import_chalk2.default.gray("* = active organization"));
       }
     } catch (error) {
       handleApiError(error);
@@ -3367,7 +4196,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk2.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3401,8 +4230,8 @@ Examples:
           }
         }));
       } else {
-        console.log(source_default.green(`Switched to organization: ${membership.organizationName}`));
-        console.log(source_default.gray(`Workspace: ${result.workspace.name}`));
+        console.log(import_chalk2.default.green(`Switched to organization: ${membership.organizationName}`));
+        console.log(import_chalk2.default.gray(`Workspace: ${result.workspace.name}`));
       }
     } catch (error) {
       handleApiError(error);
@@ -3411,6 +4240,7 @@ Examples:
 }
 
 // src/commands/workspaces.ts
+var import_chalk3 = __toESM(require_source(), 1);
 function registerWorkspacesCommands(program2) {
   const workspaces = program2.command("workspaces").description("Manage workspaces").addHelpText("after", `
 Examples:
@@ -3439,7 +4269,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk3.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3455,24 +4285,24 @@ Examples:
           }))
         }));
       } else {
-        console.log(source_default.blue("Workspaces"));
+        console.log(import_chalk3.default.blue("Workspaces"));
         console.log();
         if (data.workspaces.length === 0) {
-          console.log(source_default.gray("  No workspaces found"));
+          console.log(import_chalk3.default.gray("  No workspaces found"));
           return;
         }
         for (const w of data.workspaces) {
           const isActive = w.id === data.activeWorkspaceId;
-          const marker = isActive ? source_default.green("*") : " ";
-          const name = isActive ? source_default.white(w.name) : source_default.gray(w.name);
+          const marker = isActive ? import_chalk3.default.green("*") : " ";
+          const name = isActive ? import_chalk3.default.white(w.name) : import_chalk3.default.gray(w.name);
           console.log(`  ${marker} ${name}`);
           if (w.description) {
-            console.log(source_default.gray(`      ${w.description}`));
+            console.log(import_chalk3.default.gray(`      ${w.description}`));
           }
-          console.log(source_default.gray(`      ID: ${w.id}`));
+          console.log(import_chalk3.default.gray(`      ID: ${w.id}`));
         }
         console.log();
-        console.log(source_default.gray("* = active workspace"));
+        console.log(import_chalk3.default.gray("* = active workspace"));
       }
     } catch (error) {
       handleApiError(error);
@@ -3492,7 +4322,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk3.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3521,7 +4351,7 @@ Examples:
           }
         }));
       } else {
-        console.log(source_default.green(`Switched to workspace: ${workspace.name}`));
+        console.log(import_chalk3.default.green(`Switched to workspace: ${workspace.name}`));
       }
     } catch (error) {
       handleApiError(error);
@@ -3543,7 +4373,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk3.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3565,9 +4395,9 @@ Examples:
           }
         }));
       } else {
-        console.log(source_default.green(`Created workspace: ${result.workspace.name}`));
-        console.log(source_default.gray(`ID: ${result.workspace.id}`));
-        console.log(source_default.gray("Switched to the new workspace."));
+        console.log(import_chalk3.default.green(`Created workspace: ${result.workspace.name}`));
+        console.log(import_chalk3.default.gray(`ID: ${result.workspace.id}`));
+        console.log(import_chalk3.default.gray("Switched to the new workspace."));
       }
     } catch (error) {
       handleApiError(error);
@@ -3576,6 +4406,7 @@ Examples:
 }
 
 // src/commands/pages.ts
+var import_chalk4 = __toESM(require_source(), 1);
 function buildTree(pages) {
   const nodeMap = new Map;
   const roots = [];
@@ -3602,10 +4433,10 @@ function printTree(nodes, prefix = "", isLast = true) {
     const node = nodes[i];
     const isLastNode = i === nodes.length - 1;
     const connector = prefix === "" ? "" : isLastNode ? "└─ " : "├─ ";
-    const status = node.status ? source_default.gray(` [${node.status}]`) : "";
-    const owner = node.ownerName ? source_default.gray(` @${node.ownerName}`) : "";
-    console.log(`${prefix}${connector}${source_default.white(node.title)}${status}${owner}`);
-    console.log(`${prefix}${isLastNode ? "   " : "│  "}${source_default.gray(node.slug)}`);
+    const status = node.status ? import_chalk4.default.gray(` [${node.status}]`) : "";
+    const owner = node.ownerName ? import_chalk4.default.gray(` @${node.ownerName}`) : "";
+    console.log(`${prefix}${connector}${import_chalk4.default.white(node.title)}${status}${owner}`);
+    console.log(`${prefix}${isLastNode ? "   " : "│  "}${import_chalk4.default.gray(node.slug)}`);
     if (node.children.length > 0) {
       const newPrefix = prefix + (isLastNode ? "   " : "│  ");
       printTree(node.children, newPrefix, isLastNode);
@@ -3650,7 +4481,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk4.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3661,17 +4492,17 @@ Examples:
         return;
       }
       if (data.pages.length === 0) {
-        console.log(source_default.gray("No pages found"));
+        console.log(import_chalk4.default.gray("No pages found"));
         return;
       }
-      console.log(source_default.blue("Pages"));
+      console.log(import_chalk4.default.blue("Pages"));
       console.log();
       if (flat) {
         for (const page of data.pages) {
-          const status = page.status ? source_default.gray(` [${page.status}]`) : "";
-          const owner = page.ownerName ? source_default.gray(` @${page.ownerName}`) : "";
-          console.log(`  ${source_default.white(page.title)}${status}${owner}`);
-          console.log(`  ${source_default.gray(page.slug)}`);
+          const status = page.status ? import_chalk4.default.gray(` [${page.status}]`) : "";
+          const owner = page.ownerName ? import_chalk4.default.gray(` @${page.ownerName}`) : "";
+          console.log(`  ${import_chalk4.default.white(page.title)}${status}${owner}`);
+          console.log(`  ${import_chalk4.default.gray(page.slug)}`);
           console.log();
         }
       } else {
@@ -3702,7 +4533,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk4.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3713,24 +4544,24 @@ Examples:
         return;
       }
       const page = data.page;
-      console.log(source_default.blue(page.title));
+      console.log(import_chalk4.default.blue(page.title));
       console.log();
-      console.log(`  ${source_default.gray("Slug:")} ${page.slug}`);
-      console.log(`  ${source_default.gray("ID:")} ${page.id}`);
+      console.log(`  ${import_chalk4.default.gray("Slug:")} ${page.slug}`);
+      console.log(`  ${import_chalk4.default.gray("ID:")} ${page.id}`);
       if (page.status) {
-        console.log(`  ${source_default.gray("Status:")} ${page.status}`);
+        console.log(`  ${import_chalk4.default.gray("Status:")} ${page.status}`);
       }
       if (page.ownerName) {
-        console.log(`  ${source_default.gray("Owner:")} ${page.ownerName}`);
+        console.log(`  ${import_chalk4.default.gray("Owner:")} ${page.ownerName}`);
       }
       if (page.parentSlug) {
-        console.log(`  ${source_default.gray("Parent:")} ${page.parentSlug}`);
+        console.log(`  ${import_chalk4.default.gray("Parent:")} ${page.parentSlug}`);
       }
-      console.log(`  ${source_default.gray("Created:")} ${new Date(page.createdAt).toLocaleString()}`);
-      console.log(`  ${source_default.gray("Updated:")} ${new Date(page.updatedAt).toLocaleString()}`);
+      console.log(`  ${import_chalk4.default.gray("Created:")} ${new Date(page.createdAt).toLocaleString()}`);
+      console.log(`  ${import_chalk4.default.gray("Updated:")} ${new Date(page.updatedAt).toLocaleString()}`);
       if (page.description) {
         console.log();
-        console.log(source_default.gray("Description:"));
+        console.log(import_chalk4.default.gray("Description:"));
         console.log(page.description);
       }
     } catch (error) {
@@ -3760,7 +4591,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk4.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3789,8 +4620,8 @@ Examples:
       if (json) {
         console.log(JSON.stringify({ success: true, page: data.page }));
       } else {
-        console.log(source_default.green(`Created page: ${data.page.title}`));
-        console.log(source_default.gray(`Slug: ${data.page.slug}`));
+        console.log(import_chalk4.default.green(`Created page: ${data.page.title}`));
+        console.log(import_chalk4.default.gray(`Slug: ${data.page.slug}`));
       }
     } catch (error) {
       handleApiError(error);
@@ -3820,7 +4651,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk4.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3843,12 +4674,12 @@ Examples:
             message: "No changes made (dry run)"
           }));
         } else {
-          console.log(source_default.blue("Dry run mode - no changes will be made"));
+          console.log(import_chalk4.default.blue("Dry run mode - no changes will be made"));
           console.log();
-          console.log(source_default.gray(`Page: ${slug}`));
-          console.log(source_default.gray("Updates:"));
+          console.log(import_chalk4.default.gray(`Page: ${slug}`));
+          console.log(import_chalk4.default.gray("Updates:"));
           for (const [key, value] of Object.entries(updates)) {
-            console.log(`  ${source_default.gray(`${key}:`)} ${value}`);
+            console.log(`  ${import_chalk4.default.gray(`${key}:`)} ${value}`);
           }
         }
         return;
@@ -3858,7 +4689,7 @@ Examples:
       if (json) {
         console.log(JSON.stringify({ success: true, page: data.page }));
       } else {
-        console.log(source_default.green(`Updated page: ${data.page.title}`));
+        console.log(import_chalk4.default.green(`Updated page: ${data.page.title}`));
       }
     } catch (error) {
       handleApiError(error);
@@ -3888,7 +4719,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk4.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3900,9 +4731,9 @@ Examples:
             message: "No changes made (dry run)"
           }));
         } else {
-          console.log(source_default.blue("Dry run mode - no changes will be made"));
+          console.log(import_chalk4.default.blue("Dry run mode - no changes will be made"));
           console.log();
-          console.log(source_default.gray(`Would delete page: ${slug}`));
+          console.log(import_chalk4.default.gray(`Would delete page: ${slug}`));
         }
         return;
       }
@@ -3910,7 +4741,7 @@ Examples:
         try {
           const shouldDelete = await confirm(`Are you sure you want to delete '${slug}'?`, { defaultValue: false });
           if (!shouldDelete) {
-            console.log(source_default.yellow("Cancelled"));
+            console.log(import_chalk4.default.yellow("Cancelled"));
             return;
           }
         } catch (error) {
@@ -3925,7 +4756,7 @@ Examples:
       if (json) {
         console.log(JSON.stringify({ success: true }));
       } else {
-        console.log(source_default.green(`Deleted page: ${slug}`));
+        console.log(import_chalk4.default.green(`Deleted page: ${slug}`));
       }
     } catch (error) {
       handleApiError(error);
@@ -3951,7 +4782,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk4.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -3962,18 +4793,18 @@ Examples:
         return;
       }
       if (data.pages.length === 0) {
-        console.log(source_default.gray(`No pages found matching '${query}'`));
+        console.log(import_chalk4.default.gray(`No pages found matching '${query}'`));
         return;
       }
-      console.log(source_default.blue(`Search results for '${query}'`));
+      console.log(import_chalk4.default.blue(`Search results for '${query}'`));
       console.log();
       for (const page of data.pages) {
-        const status = page.status ? source_default.gray(` [${page.status}]`) : "";
-        console.log(`  ${source_default.white(page.title)}${status}`);
-        console.log(`  ${source_default.gray(page.slug)}`);
+        const status = page.status ? import_chalk4.default.gray(` [${page.status}]`) : "";
+        console.log(`  ${import_chalk4.default.white(page.title)}${status}`);
+        console.log(`  ${import_chalk4.default.gray(page.slug)}`);
         if (page.description) {
           const desc = page.description.length > 100 ? page.description.slice(0, 100) + "..." : page.description;
-          console.log(`  ${source_default.gray(desc)}`);
+          console.log(`  ${import_chalk4.default.gray(desc)}`);
         }
         console.log();
       }
@@ -3984,6 +4815,7 @@ Examples:
 }
 
 // src/commands/chat.ts
+var import_chalk5 = __toESM(require_source(), 1);
 function registerChatCommands(program2) {
   const threads = program2.command("threads").description("Manage chat threads").addHelpText("after", `
 Examples:
@@ -4013,7 +4845,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk5.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -4024,17 +4856,17 @@ Examples:
         return;
       }
       if (data.threads.length === 0) {
-        console.log(source_default.gray("No chat threads found"));
+        console.log(import_chalk5.default.gray("No chat threads found"));
         return;
       }
-      console.log(source_default.blue("Chat Threads"));
+      console.log(import_chalk5.default.blue("Chat Threads"));
       console.log();
       for (const thread of data.threads) {
-        const title = thread.title || source_default.gray("(untitled)");
+        const title = thread.title || import_chalk5.default.gray("(untitled)");
         const date = thread.lastMessageAt ? new Date(thread.lastMessageAt).toLocaleDateString() : new Date(thread.createdAt).toLocaleDateString();
-        console.log(`  ${source_default.white(title)}`);
-        console.log(`  ${source_default.gray(`ID: ${thread.providerThreadId}`)}`);
-        console.log(`  ${source_default.gray(`Last activity: ${date}`)}`);
+        console.log(`  ${import_chalk5.default.white(title)}`);
+        console.log(`  ${import_chalk5.default.gray(`ID: ${thread.providerThreadId}`)}`);
+        console.log(`  ${import_chalk5.default.gray(`Last activity: ${date}`)}`);
         console.log();
       }
     } catch (error) {
@@ -4061,7 +4893,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk5.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -4070,10 +4902,10 @@ Examples:
       if (json) {
         console.log(JSON.stringify({ success: true, ...data }));
       } else {
-        console.log(source_default.green("Created new chat thread"));
-        console.log(source_default.gray(`Thread ID: ${data.thread.providerThreadId}`));
+        console.log(import_chalk5.default.green("Created new chat thread"));
+        console.log(import_chalk5.default.gray(`Thread ID: ${data.thread.providerThreadId}`));
         if (message) {
-          console.log(source_default.gray("Sent initial message"));
+          console.log(import_chalk5.default.gray("Sent initial message"));
         }
       }
     } catch (error) {
@@ -4100,7 +4932,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk5.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -4111,16 +4943,16 @@ Examples:
         return;
       }
       if (data.messages.length === 0) {
-        console.log(source_default.gray("No messages in this thread"));
+        console.log(import_chalk5.default.gray("No messages in this thread"));
         return;
       }
-      console.log(source_default.blue(`Thread ${threadId}`));
+      console.log(import_chalk5.default.blue(`Thread ${threadId}`));
       console.log();
       for (const msg of data.messages) {
-        const roleColor = msg.role === "user" ? source_default.cyan : source_default.green;
+        const roleColor = msg.role === "user" ? import_chalk5.default.cyan : import_chalk5.default.green;
         const roleLabel = msg.role === "user" ? "You" : "Assistant";
         const date = new Date(msg.createdAt).toLocaleString();
-        console.log(`${roleColor(roleLabel)} ${source_default.gray(`(${date})`)}`);
+        console.log(`${roleColor(roleLabel)} ${import_chalk5.default.gray(`(${date})`)}`);
         console.log(msg.content);
         console.log();
       }
@@ -4152,7 +4984,7 @@ Examples:
         if (json) {
           console.log(JSON.stringify({ error: true, message: "Not logged in" }));
         } else {
-          console.log(source_default.yellow("Not logged in. Run 'thoughtful login' first."));
+          console.log(import_chalk5.default.yellow("Not logged in. Run 'thoughtful login' first."));
         }
         process.exit(1);
       }
@@ -4176,10 +5008,10 @@ Examples:
       if (json) {
         console.log(JSON.stringify({ success: true, message: data.message }));
       } else {
-        console.log(source_default.green("Message sent"));
+        console.log(import_chalk5.default.green("Message sent"));
         if (data.message.content) {
           console.log();
-          console.log(source_default.gray("Response:"));
+          console.log(import_chalk5.default.gray("Response:"));
           console.log(data.message.content);
         }
       }
@@ -4190,6 +5022,7 @@ Examples:
 }
 
 // src/commands/completion.ts
+var import_chalk6 = __toESM(require_source(), 1);
 var bashCompletion = `
 # Bash completion for thoughtful CLI
 # Add this to your ~/.bashrc or ~/.bash_profile:
@@ -4398,21 +5231,21 @@ function registerCompletionCommand(program2) {
     console.log(fishCompletion);
   });
   completion.action(() => {
-    console.log(source_default.blue("Shell Completion Installation"));
+    console.log(import_chalk6.default.blue("Shell Completion Installation"));
     console.log();
     console.log("Generate completion scripts for your shell:");
     console.log();
-    console.log(source_default.cyan("Bash:"));
+    console.log(import_chalk6.default.cyan("Bash:"));
     console.log("  Add to ~/.bashrc:");
-    console.log(source_default.gray('  eval "$(thoughtful completion bash)"'));
+    console.log(import_chalk6.default.gray('  eval "$(thoughtful completion bash)"'));
     console.log();
-    console.log(source_default.cyan("Zsh:"));
+    console.log(import_chalk6.default.cyan("Zsh:"));
     console.log("  Add to ~/.zshrc:");
-    console.log(source_default.gray('  eval "$(thoughtful completion zsh)"'));
+    console.log(import_chalk6.default.gray('  eval "$(thoughtful completion zsh)"'));
     console.log();
-    console.log(source_default.cyan("Fish:"));
+    console.log(import_chalk6.default.cyan("Fish:"));
     console.log("  Save to completions directory:");
-    console.log(source_default.gray("  thoughtful completion fish > ~/.config/fish/completions/thoughtful.fish"));
+    console.log(import_chalk6.default.gray("  thoughtful completion fish > ~/.config/fish/completions/thoughtful.fish"));
     console.log();
     console.log("After adding the completion script, restart your shell or source the config file.");
   });