routess 1.122.4

package/dist/index.js

@@ -0,0 +1,4709 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/error.js
+var require_error = __commonJS((exports) => {
+  class CommanderError extends Error {
+    constructor(exitCode, code, message) {
+      super(message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+      this.code = code;
+      this.exitCode = exitCode;
+      this.nestedError = undefined;
+    }
+  }
+
+  class InvalidArgumentError extends CommanderError {
+    constructor(message) {
+      super(1, "commander.invalidArgument", message);
+      Error.captureStackTrace(this, this.constructor);
+      this.name = this.constructor.name;
+    }
+  }
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+});
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/argument.js
+var require_argument = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Argument {
+    constructor(name, description) {
+      this.description = description || "";
+      this.variadic = false;
+      this.parseArg = undefined;
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.argChoices = undefined;
+      switch (name[0]) {
+        case "<":
+          this.required = true;
+          this._name = name.slice(1, -1);
+          break;
+        case "[":
+          this.required = false;
+          this._name = name.slice(1, -1);
+          break;
+        default:
+          this.required = true;
+          this._name = name;
+          break;
+      }
+      if (this._name.length > 3 && this._name.slice(-3) === "...") {
+        this.variadic = true;
+        this._name = this._name.slice(0, -3);
+      }
+    }
+    name() {
+      return this._name;
+    }
+    _concatValue(value, previous) {
+      if (previous === this.defaultValue || !Array.isArray(previous)) {
+        return [value];
+      }
+      return previous.concat(value);
+    }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
+    choices(values) {
+      this.argChoices = values.slice();
+      this.parseArg = (arg, previous) => {
+        if (!this.argChoices.includes(arg)) {
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+        }
+        if (this.variadic) {
+          return this._concatValue(arg, previous);
+        }
+        return arg;
+      };
+      return this;
+    }
+    argRequired() {
+      this.required = true;
+      return this;
+    }
+    argOptional() {
+      this.required = false;
+      return this;
+    }
+  }
+  function humanReadableArgName(arg) {
+    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+  }
+  exports.Argument = Argument;
+  exports.humanReadableArgName = humanReadableArgName;
+});
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/help.js
+var require_help = __commonJS((exports) => {
+  var { humanReadableArgName } = require_argument();
+
+  class Help {
+    constructor() {
+      this.helpWidth = undefined;
+      this.minWidthToWrap = 40;
+      this.sortSubcommands = false;
+      this.sortOptions = false;
+      this.showGlobalOptions = false;
+    }
+    prepareContext(contextOptions) {
+      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+    }
+    visibleCommands(cmd) {
+      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const helpCommand = cmd._getHelpCommand();
+      if (helpCommand && !helpCommand._hidden) {
+        visibleCommands.push(helpCommand);
+      }
+      if (this.sortSubcommands) {
+        visibleCommands.sort((a, b) => {
+          return a.name().localeCompare(b.name());
+        });
+      }
+      return visibleCommands;
+    }
+    compareOptions(a, b) {
+      const getSortKey = (option) => {
+        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+      };
+      return getSortKey(a).localeCompare(getSortKey(b));
+    }
+    visibleOptions(cmd) {
+      const visibleOptions = cmd.options.filter((option) => !option.hidden);
+      const helpOption = cmd._getHelpOption();
+      if (helpOption && !helpOption.hidden) {
+        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+        if (!removeShort && !removeLong) {
+          visibleOptions.push(helpOption);
+        } else if (helpOption.long && !removeLong) {
+          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+        } else if (helpOption.short && !removeShort) {
+          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+        }
+      }
+      if (this.sortOptions) {
+        visibleOptions.sort(this.compareOptions);
+      }
+      return visibleOptions;
+    }
+    visibleGlobalOptions(cmd) {
+      if (!this.showGlobalOptions)
+        return [];
+      const globalOptions = [];
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+        globalOptions.push(...visibleOptions);
+      }
+      if (this.sortOptions) {
+        globalOptions.sort(this.compareOptions);
+      }
+      return globalOptions;
+    }
+    visibleArguments(cmd) {
+      if (cmd._argsDescription) {
+        cmd.registeredArguments.forEach((argument) => {
+          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+        });
+      }
+      if (cmd.registeredArguments.find((argument) => argument.description)) {
+        return cmd.registeredArguments;
+      }
+      return [];
+    }
+    subcommandTerm(cmd) {
+      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
+      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
+    }
+    optionTerm(option) {
+      return option.flags;
+    }
+    argumentTerm(argument) {
+      return argument.name();
+    }
+    longestSubcommandTermLength(cmd, helper) {
+      return helper.visibleCommands(cmd).reduce((max, command) => {
+        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
+      }, 0);
+    }
+    longestOptionTermLength(cmd, helper) {
+      return helper.visibleOptions(cmd).reduce((max, option) => {
+        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+      }, 0);
+    }
+    longestGlobalOptionTermLength(cmd, helper) {
+      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+      }, 0);
+    }
+    longestArgumentTermLength(cmd, helper) {
+      return helper.visibleArguments(cmd).reduce((max, argument) => {
+        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
+      }, 0);
+    }
+    commandUsage(cmd) {
+      let cmdName = cmd._name;
+      if (cmd._aliases[0]) {
+        cmdName = cmdName + "|" + cmd._aliases[0];
+      }
+      let ancestorCmdNames = "";
+      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
+      }
+      return ancestorCmdNames + cmdName + " " + cmd.usage();
+    }
+    commandDescription(cmd) {
+      return cmd.description();
+    }
+    subcommandDescription(cmd) {
+      return cmd.summary() || cmd.description();
+    }
+    optionDescription(option) {
+      const extraInfo = [];
+      if (option.argChoices) {
+        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+      }
+      if (option.defaultValue !== undefined) {
+        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
+        if (showDefault) {
+          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+        }
+      }
+      if (option.presetArg !== undefined && option.optional) {
+        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
+      }
+      if (option.envVar !== undefined) {
+        extraInfo.push(`env: ${option.envVar}`);
+      }
+      if (extraInfo.length > 0) {
+        return `${option.description} (${extraInfo.join(", ")})`;
+      }
+      return option.description;
+    }
+    argumentDescription(argument) {
+      const extraInfo = [];
+      if (argument.argChoices) {
+        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+      }
+      if (argument.defaultValue !== undefined) {
+        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+      }
+      if (extraInfo.length > 0) {
+        const extraDescription = `(${extraInfo.join(", ")})`;
+        if (argument.description) {
+          return `${argument.description} ${extraDescription}`;
+        }
+        return extraDescription;
+      }
+      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 commandDescription = helper.commandDescription(cmd);
+      if (commandDescription.length > 0) {
+        output = output.concat([
+          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
+          ""
+        ]);
+      }
+      const argumentList = helper.visibleArguments(cmd).map((argument) => {
+        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
+      });
+      if (argumentList.length > 0) {
+        output = output.concat([
+          helper.styleTitle("Arguments:"),
+          ...argumentList,
+          ""
+        ]);
+      }
+      const optionList = helper.visibleOptions(cmd).map((option) => {
+        return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+      });
+      if (optionList.length > 0) {
+        output = output.concat([
+          helper.styleTitle("Options:"),
+          ...optionList,
+          ""
+        ]);
+      }
+      if (helper.showGlobalOptions) {
+        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        });
+        if (globalOptionList.length > 0) {
+          output = output.concat([
+            helper.styleTitle("Global Options:"),
+            ...globalOptionList,
+            ""
+          ]);
+        }
+      }
+      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
+        return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd2)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd2)));
+      });
+      if (commandList.length > 0) {
+        output = output.concat([
+          helper.styleTitle("Commands:"),
+          ...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)
+        return str;
+      const rawLines = str.split(/\r\n|\n/);
+      const chunkPattern = /[\s]*[^\s]+/g;
+      const wrappedLines = [];
+      rawLines.forEach((line) => {
+        const chunks = line.match(chunkPattern);
+        if (chunks === null) {
+          wrappedLines.push("");
+          return;
+        }
+        let sumChunks = [chunks.shift()];
+        let sumWidth = this.displayWidth(sumChunks[0]);
+        chunks.forEach((chunk) => {
+          const visibleWidth = this.displayWidth(chunk);
+          if (sumWidth + visibleWidth <= width) {
+            sumChunks.push(chunk);
+            sumWidth += visibleWidth;
+            return;
+          }
+          wrappedLines.push(sumChunks.join(""));
+          const nextChunk = chunk.trimStart();
+          sumChunks = [nextChunk];
+          sumWidth = this.displayWidth(nextChunk);
+        });
+        wrappedLines.push(sumChunks.join(""));
+      });
+      return wrappedLines.join(`
+`);
+    }
+  }
+  function stripColor(str) {
+    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+    return str.replace(sgrPattern, "");
+  }
+  exports.Help = Help;
+  exports.stripColor = stripColor;
+});
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/option.js
+var require_option = __commonJS((exports) => {
+  var { InvalidArgumentError } = require_error();
+
+  class Option {
+    constructor(flags, description) {
+      this.flags = flags;
+      this.description = description || "";
+      this.required = flags.includes("<");
+      this.optional = flags.includes("[");
+      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
+      this.mandatory = false;
+      const optionFlags = splitOptionFlags(flags);
+      this.short = optionFlags.shortFlag;
+      this.long = optionFlags.longFlag;
+      this.negate = false;
+      if (this.long) {
+        this.negate = this.long.startsWith("--no-");
+      }
+      this.defaultValue = undefined;
+      this.defaultValueDescription = undefined;
+      this.presetArg = undefined;
+      this.envVar = undefined;
+      this.parseArg = undefined;
+      this.hidden = false;
+      this.argChoices = undefined;
+      this.conflictsWith = [];
+      this.implied = undefined;
+    }
+    default(value, description) {
+      this.defaultValue = value;
+      this.defaultValueDescription = description;
+      return this;
+    }
+    preset(arg) {
+      this.presetArg = arg;
+      return this;
+    }
+    conflicts(names) {
+      this.conflictsWith = this.conflictsWith.concat(names);
+      return this;
+    }
+    implies(impliedOptionValues) {
+      let newImplied = impliedOptionValues;
+      if (typeof impliedOptionValues === "string") {
+        newImplied = { [impliedOptionValues]: true };
+      }
+      this.implied = Object.assign(this.implied || {}, newImplied);
+      return this;
+    }
+    env(name) {
+      this.envVar = name;
+      return this;
+    }
+    argParser(fn) {
+      this.parseArg = fn;
+      return this;
+    }
+    makeOptionMandatory(mandatory = true) {
+      this.mandatory = !!mandatory;
+      return this;
+    }
+    hideHelp(hide = true) {
+      this.hidden = !!hide;
+      return this;
+    }
+    _concatValue(value, previous) {
+      if (previous === this.defaultValue || !Array.isArray(previous)) {
+        return [value];
+      }
+      return previous.concat(value);
+    }
+    choices(values) {
+      this.argChoices = values.slice();
+      this.parseArg = (arg, previous) => {
+        if (!this.argChoices.includes(arg)) {
+          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+        }
+        if (this.variadic) {
+          return this._concatValue(arg, previous);
+        }
+        return arg;
+      };
+      return this;
+    }
+    name() {
+      if (this.long) {
+        return this.long.replace(/^--/, "");
+      }
+      return this.short.replace(/^-/, "");
+    }
+    attributeName() {
+      if (this.negate) {
+        return camelcase(this.name().replace(/^no-/, ""));
+      }
+      return camelcase(this.name());
+    }
+    is(arg) {
+      return this.short === arg || this.long === arg;
+    }
+    isBoolean() {
+      return !this.required && !this.optional && !this.negate;
+    }
+  }
+
+  class DualOptions {
+    constructor(options) {
+      this.positiveOptions = new Map;
+      this.negativeOptions = new Map;
+      this.dualOptions = new Set;
+      options.forEach((option) => {
+        if (option.negate) {
+          this.negativeOptions.set(option.attributeName(), option);
+        } else {
+          this.positiveOptions.set(option.attributeName(), option);
+        }
+      });
+      this.negativeOptions.forEach((value, key) => {
+        if (this.positiveOptions.has(key)) {
+          this.dualOptions.add(key);
+        }
+      });
+    }
+    valueFromOption(value, option) {
+      const optionKey = option.attributeName();
+      if (!this.dualOptions.has(optionKey))
+        return true;
+      const preset = this.negativeOptions.get(optionKey).presetArg;
+      const negativeValue = preset !== undefined ? preset : false;
+      return option.negate === (negativeValue === value);
+    }
+  }
+  function camelcase(str) {
+    return str.split("-").reduce((str2, word) => {
+      return str2 + word[0].toUpperCase() + word.slice(1);
+    });
+  }
+  function splitOptionFlags(flags) {
+    let shortFlag;
+    let longFlag;
+    const shortFlagExp = /^-[^-]$/;
+    const longFlagExp = /^--[^-]/;
+    const flagParts = flags.split(/[ |,]+/).concat("guard");
+    if (shortFlagExp.test(flagParts[0]))
+      shortFlag = flagParts.shift();
+    if (longFlagExp.test(flagParts[0]))
+      longFlag = flagParts.shift();
+    if (!shortFlag && shortFlagExp.test(flagParts[0]))
+      shortFlag = flagParts.shift();
+    if (!shortFlag && longFlagExp.test(flagParts[0])) {
+      shortFlag = longFlag;
+      longFlag = flagParts.shift();
+    }
+    if (flagParts[0].startsWith("-")) {
+      const unsupportedFlag = flagParts[0];
+      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+      if (/^-[^-][^-]/.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
+      if (shortFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many short flags`);
+      if (longFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many long flags`);
+      throw new Error(`${baseError}
+- unrecognised flag format`);
+    }
+    if (shortFlag === undefined && longFlag === undefined)
+      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
+    return { shortFlag, longFlag };
+  }
+  exports.Option = Option;
+  exports.DualOptions = DualOptions;
+});
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js
+var require_suggestSimilar = __commonJS((exports) => {
+  var maxDistance = 3;
+  function editDistance(a, b) {
+    if (Math.abs(a.length - b.length) > maxDistance)
+      return Math.max(a.length, b.length);
+    const d = [];
+    for (let i = 0;i <= a.length; i++) {
+      d[i] = [i];
+    }
+    for (let j = 0;j <= b.length; j++) {
+      d[0][j] = j;
+    }
+    for (let j = 1;j <= b.length; j++) {
+      for (let i = 1;i <= a.length; i++) {
+        let cost = 1;
+        if (a[i - 1] === b[j - 1]) {
+          cost = 0;
+        } else {
+          cost = 1;
+        }
+        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+        }
+      }
+    }
+    return d[a.length][b.length];
+  }
+  function suggestSimilar(word, candidates) {
+    if (!candidates || candidates.length === 0)
+      return "";
+    candidates = Array.from(new Set(candidates));
+    const searchingOptions = word.startsWith("--");
+    if (searchingOptions) {
+      word = word.slice(2);
+      candidates = candidates.map((candidate) => candidate.slice(2));
+    }
+    let similar = [];
+    let bestDistance = maxDistance;
+    const minSimilarity = 0.4;
+    candidates.forEach((candidate) => {
+      if (candidate.length <= 1)
+        return;
+      const distance = editDistance(word, candidate);
+      const length = Math.max(word.length, candidate.length);
+      const similarity = (length - distance) / length;
+      if (similarity > minSimilarity) {
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          similar = [candidate];
+        } else if (distance === bestDistance) {
+          similar.push(candidate);
+        }
+      }
+    });
+    similar.sort((a, b) => a.localeCompare(b));
+    if (searchingOptions) {
+      similar = similar.map((candidate) => `--${candidate}`);
+    }
+    if (similar.length > 1) {
+      return `
+(Did you mean one of ${similar.join(", ")}?)`;
+    }
+    if (similar.length === 1) {
+      return `
+(Did you mean ${similar[0]}?)`;
+    }
+    return "";
+  }
+  exports.suggestSimilar = suggestSimilar;
+});
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/command.js
+var require_command = __commonJS((exports) => {
+  var EventEmitter = __require("node:events").EventEmitter;
+  var childProcess = __require("node:child_process");
+  var path = __require("node:path");
+  var fs = __require("node:fs");
+  var process2 = __require("node:process");
+  var { Argument, humanReadableArgName } = require_argument();
+  var { CommanderError } = require_error();
+  var { Help, stripColor } = require_help();
+  var { Option, DualOptions } = require_option();
+  var { suggestSimilar } = require_suggestSimilar();
+
+  class Command extends EventEmitter {
+    constructor(name) {
+      super();
+      this.commands = [];
+      this.options = [];
+      this.parent = null;
+      this._allowUnknownOption = false;
+      this._allowExcessArguments = false;
+      this.registeredArguments = [];
+      this._args = this.registeredArguments;
+      this.args = [];
+      this.rawArgs = [];
+      this.processedArgs = [];
+      this._scriptPath = null;
+      this._name = name || "";
+      this._optionValues = {};
+      this._optionValueSources = {};
+      this._storeOptionsAsProperties = false;
+      this._actionHandler = null;
+      this._executableHandler = false;
+      this._executableFile = null;
+      this._executableDir = null;
+      this._defaultCommandName = null;
+      this._exitCallback = null;
+      this._aliases = [];
+      this._combineFlagAndOptionalValue = true;
+      this._description = "";
+      this._summary = "";
+      this._argsDescription = undefined;
+      this._enablePositionalOptions = false;
+      this._passThroughOptions = false;
+      this._lifeCycleHooks = {};
+      this._showHelpAfterError = false;
+      this._showSuggestionAfterError = true;
+      this._savedState = null;
+      this._outputConfiguration = {
+        writeOut: (str) => process2.stdout.write(str),
+        writeErr: (str) => process2.stderr.write(str),
+        outputError: (str, write) => write(str),
+        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
+        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
+        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
+        stripColor: (str) => stripColor(str)
+      };
+      this._hidden = false;
+      this._helpOption = undefined;
+      this._addImplicitHelpCommand = undefined;
+      this._helpCommand = undefined;
+      this._helpConfiguration = {};
+    }
+    copyInheritedSettings(sourceCommand) {
+      this._outputConfiguration = sourceCommand._outputConfiguration;
+      this._helpOption = sourceCommand._helpOption;
+      this._helpCommand = sourceCommand._helpCommand;
+      this._helpConfiguration = sourceCommand._helpConfiguration;
+      this._exitCallback = sourceCommand._exitCallback;
+      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
+      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
+      this._allowExcessArguments = sourceCommand._allowExcessArguments;
+      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
+      this._showHelpAfterError = sourceCommand._showHelpAfterError;
+      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
+      return this;
+    }
+    _getCommandAndAncestors() {
+      const result = [];
+      for (let command = this;command; command = command.parent) {
+        result.push(command);
+      }
+      return result;
+    }
+    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
+      let desc = actionOptsOrExecDesc;
+      let opts = execOpts;
+      if (typeof desc === "object" && desc !== null) {
+        opts = desc;
+        desc = null;
+      }
+      opts = opts || {};
+      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
+      const cmd = this.createCommand(name);
+      if (desc) {
+        cmd.description(desc);
+        cmd._executableHandler = true;
+      }
+      if (opts.isDefault)
+        this._defaultCommandName = cmd._name;
+      cmd._hidden = !!(opts.noHelp || opts.hidden);
+      cmd._executableFile = opts.executableFile || null;
+      if (args)
+        cmd.arguments(args);
+      this._registerCommand(cmd);
+      cmd.parent = this;
+      cmd.copyInheritedSettings(this);
+      if (desc)
+        return this;
+      return cmd;
+    }
+    createCommand(name) {
+      return new Command(name);
+    }
+    createHelp() {
+      return Object.assign(new Help, this.configureHelp());
+    }
+    configureHelp(configuration) {
+      if (configuration === undefined)
+        return this._helpConfiguration;
+      this._helpConfiguration = configuration;
+      return this;
+    }
+    configureOutput(configuration) {
+      if (configuration === undefined)
+        return this._outputConfiguration;
+      Object.assign(this._outputConfiguration, configuration);
+      return this;
+    }
+    showHelpAfterError(displayHelp = true) {
+      if (typeof displayHelp !== "string")
+        displayHelp = !!displayHelp;
+      this._showHelpAfterError = displayHelp;
+      return this;
+    }
+    showSuggestionAfterError(displaySuggestion = true) {
+      this._showSuggestionAfterError = !!displaySuggestion;
+      return this;
+    }
+    addCommand(cmd, opts) {
+      if (!cmd._name) {
+        throw new Error(`Command passed to .addCommand() must have a name
+- specify the name in Command constructor or using .name()`);
+      }
+      opts = opts || {};
+      if (opts.isDefault)
+        this._defaultCommandName = cmd._name;
+      if (opts.noHelp || opts.hidden)
+        cmd._hidden = true;
+      this._registerCommand(cmd);
+      cmd.parent = this;
+      cmd._checkForBrokenPassThrough();
+      return this;
+    }
+    createArgument(name, description) {
+      return new Argument(name, description);
+    }
+    argument(name, description, fn, defaultValue) {
+      const argument = this.createArgument(name, description);
+      if (typeof fn === "function") {
+        argument.default(defaultValue).argParser(fn);
+      } else {
+        argument.default(fn);
+      }
+      this.addArgument(argument);
+      return this;
+    }
+    arguments(names) {
+      names.trim().split(/ +/).forEach((detail) => {
+        this.argument(detail);
+      });
+      return this;
+    }
+    addArgument(argument) {
+      const previousArgument = this.registeredArguments.slice(-1)[0];
+      if (previousArgument && previousArgument.variadic) {
+        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
+      }
+      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
+        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
+      }
+      this.registeredArguments.push(argument);
+      return this;
+    }
+    helpCommand(enableOrNameAndArgs, description) {
+      if (typeof enableOrNameAndArgs === "boolean") {
+        this._addImplicitHelpCommand = enableOrNameAndArgs;
+        return this;
+      }
+      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
+      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+      const helpDescription = description ?? "display help for command";
+      const helpCommand = this.createCommand(helpName);
+      helpCommand.helpOption(false);
+      if (helpArgs)
+        helpCommand.arguments(helpArgs);
+      if (helpDescription)
+        helpCommand.description(helpDescription);
+      this._addImplicitHelpCommand = true;
+      this._helpCommand = helpCommand;
+      return this;
+    }
+    addHelpCommand(helpCommand, deprecatedDescription) {
+      if (typeof helpCommand !== "object") {
+        this.helpCommand(helpCommand, deprecatedDescription);
+        return this;
+      }
+      this._addImplicitHelpCommand = true;
+      this._helpCommand = helpCommand;
+      return this;
+    }
+    _getHelpCommand() {
+      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
+      if (hasImplicitHelpCommand) {
+        if (this._helpCommand === undefined) {
+          this.helpCommand(undefined, undefined);
+        }
+        return this._helpCommand;
+      }
+      return null;
+    }
+    hook(event, listener) {
+      const allowedValues = ["preSubcommand", "preAction", "postAction"];
+      if (!allowedValues.includes(event)) {
+        throw new Error(`Unexpected value for event passed to hook : '${event}'.
+Expecting one of '${allowedValues.join("', '")}'`);
+      }
+      if (this._lifeCycleHooks[event]) {
+        this._lifeCycleHooks[event].push(listener);
+      } else {
+        this._lifeCycleHooks[event] = [listener];
+      }
+      return this;
+    }
+    exitOverride(fn) {
+      if (fn) {
+        this._exitCallback = fn;
+      } else {
+        this._exitCallback = (err) => {
+          if (err.code !== "commander.executeSubCommandAsync") {
+            throw err;
+          }
+        };
+      }
+      return this;
+    }
+    _exit(exitCode, code, message) {
+      if (this._exitCallback) {
+        this._exitCallback(new CommanderError(exitCode, code, message));
+      }
+      process2.exit(exitCode);
+    }
+    action(fn) {
+      const listener = (args) => {
+        const expectedArgsCount = this.registeredArguments.length;
+        const actionArgs = args.slice(0, expectedArgsCount);
+        if (this._storeOptionsAsProperties) {
+          actionArgs[expectedArgsCount] = this;
+        } else {
+          actionArgs[expectedArgsCount] = this.opts();
+        }
+        actionArgs.push(this);
+        return fn.apply(this, actionArgs);
+      };
+      this._actionHandler = listener;
+      return this;
+    }
+    createOption(flags, description) {
+      return new Option(flags, description);
+    }
+    _callParseArg(target, value, previous, invalidArgumentMessage) {
+      try {
+        return target.parseArg(value, previous);
+      } catch (err) {
+        if (err.code === "commander.invalidArgument") {
+          const message = `${invalidArgumentMessage} ${err.message}`;
+          this.error(message, { exitCode: err.exitCode, code: err.code });
+        }
+        throw err;
+      }
+    }
+    _registerOption(option) {
+      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
+      if (matchingOption) {
+        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
+        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
+-  already used by option '${matchingOption.flags}'`);
+      }
+      this.options.push(option);
+    }
+    _registerCommand(command) {
+      const knownBy = (cmd) => {
+        return [cmd.name()].concat(cmd.aliases());
+      };
+      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
+      if (alreadyUsed) {
+        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
+        const newCmd = knownBy(command).join("|");
+        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
+      }
+      this.commands.push(command);
+    }
+    addOption(option) {
+      this._registerOption(option);
+      const oname = option.name();
+      const name = option.attributeName();
+      if (option.negate) {
+        const positiveLongFlag = option.long.replace(/^--no-/, "--");
+        if (!this._findOption(positiveLongFlag)) {
+          this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, "default");
+        }
+      } else if (option.defaultValue !== undefined) {
+        this.setOptionValueWithSource(name, option.defaultValue, "default");
+      }
+      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
+        if (val == null && option.presetArg !== undefined) {
+          val = option.presetArg;
+        }
+        const oldValue = this.getOptionValue(name);
+        if (val !== null && option.parseArg) {
+          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
+        } else if (val !== null && option.variadic) {
+          val = option._concatValue(val, oldValue);
+        }
+        if (val == null) {
+          if (option.negate) {
+            val = false;
+          } else if (option.isBoolean() || option.optional) {
+            val = true;
+          } else {
+            val = "";
+          }
+        }
+        this.setOptionValueWithSource(name, val, valueSource);
+      };
+      this.on("option:" + oname, (val) => {
+        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
+        handleOptionValue(val, invalidValueMessage, "cli");
+      });
+      if (option.envVar) {
+        this.on("optionEnv:" + oname, (val) => {
+          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
+          handleOptionValue(val, invalidValueMessage, "env");
+        });
+      }
+      return this;
+    }
+    _optionEx(config, flags, description, fn, defaultValue) {
+      if (typeof flags === "object" && flags instanceof Option) {
+        throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
+      }
+      const option = this.createOption(flags, description);
+      option.makeOptionMandatory(!!config.mandatory);
+      if (typeof fn === "function") {
+        option.default(defaultValue).argParser(fn);
+      } else if (fn instanceof RegExp) {
+        const regex = fn;
+        fn = (val, def) => {
+          const m = regex.exec(val);
+          return m ? m[0] : def;
+        };
+        option.default(defaultValue).argParser(fn);
+      } else {
+        option.default(fn);
+      }
+      return this.addOption(option);
+    }
+    option(flags, description, parseArg, defaultValue) {
+      return this._optionEx({}, flags, description, parseArg, defaultValue);
+    }
+    requiredOption(flags, description, parseArg, defaultValue) {
+      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
+    }
+    combineFlagAndOptionalValue(combine = true) {
+      this._combineFlagAndOptionalValue = !!combine;
+      return this;
+    }
+    allowUnknownOption(allowUnknown = true) {
+      this._allowUnknownOption = !!allowUnknown;
+      return this;
+    }
+    allowExcessArguments(allowExcess = true) {
+      this._allowExcessArguments = !!allowExcess;
+      return this;
+    }
+    enablePositionalOptions(positional = true) {
+      this._enablePositionalOptions = !!positional;
+      return this;
+    }
+    passThroughOptions(passThrough = true) {
+      this._passThroughOptions = !!passThrough;
+      this._checkForBrokenPassThrough();
+      return this;
+    }
+    _checkForBrokenPassThrough() {
+      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
+        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
+      }
+    }
+    storeOptionsAsProperties(storeAsProperties = true) {
+      if (this.options.length) {
+        throw new Error("call .storeOptionsAsProperties() before adding options");
+      }
+      if (Object.keys(this._optionValues).length) {
+        throw new Error("call .storeOptionsAsProperties() before setting option values");
+      }
+      this._storeOptionsAsProperties = !!storeAsProperties;
+      return this;
+    }
+    getOptionValue(key) {
+      if (this._storeOptionsAsProperties) {
+        return this[key];
+      }
+      return this._optionValues[key];
+    }
+    setOptionValue(key, value) {
+      return this.setOptionValueWithSource(key, value, undefined);
+    }
+    setOptionValueWithSource(key, value, source) {
+      if (this._storeOptionsAsProperties) {
+        this[key] = value;
+      } else {
+        this._optionValues[key] = value;
+      }
+      this._optionValueSources[key] = source;
+      return this;
+    }
+    getOptionValueSource(key) {
+      return this._optionValueSources[key];
+    }
+    getOptionValueSourceWithGlobals(key) {
+      let source;
+      this._getCommandAndAncestors().forEach((cmd) => {
+        if (cmd.getOptionValueSource(key) !== undefined) {
+          source = cmd.getOptionValueSource(key);
+        }
+      });
+      return source;
+    }
+    _prepareUserArgs(argv, parseOptions) {
+      if (argv !== undefined && !Array.isArray(argv)) {
+        throw new Error("first parameter to parse must be array or undefined");
+      }
+      parseOptions = parseOptions || {};
+      if (argv === undefined && parseOptions.from === undefined) {
+        if (process2.versions?.electron) {
+          parseOptions.from = "electron";
+        }
+        const execArgv = process2.execArgv ?? [];
+        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
+          parseOptions.from = "eval";
+        }
+      }
+      if (argv === undefined) {
+        argv = process2.argv;
+      }
+      this.rawArgs = argv.slice();
+      let userArgs;
+      switch (parseOptions.from) {
+        case undefined:
+        case "node":
+          this._scriptPath = argv[1];
+          userArgs = argv.slice(2);
+          break;
+        case "electron":
+          if (process2.defaultApp) {
+            this._scriptPath = argv[1];
+            userArgs = argv.slice(2);
+          } else {
+            userArgs = argv.slice(1);
+          }
+          break;
+        case "user":
+          userArgs = argv.slice(0);
+          break;
+        case "eval":
+          userArgs = argv.slice(1);
+          break;
+        default:
+          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
+      }
+      if (!this._name && this._scriptPath)
+        this.nameFromFilename(this._scriptPath);
+      this._name = this._name || "program";
+      return userArgs;
+    }
+    parse(argv, parseOptions) {
+      this._prepareForParse();
+      const userArgs = this._prepareUserArgs(argv, parseOptions);
+      this._parseCommand([], userArgs);
+      return this;
+    }
+    async parseAsync(argv, parseOptions) {
+      this._prepareForParse();
+      const userArgs = this._prepareUserArgs(argv, parseOptions);
+      await this._parseCommand([], userArgs);
+      return this;
+    }
+    _prepareForParse() {
+      if (this._savedState === null) {
+        this.saveStateBeforeParse();
+      } else {
+        this.restoreStateBeforeParse();
+      }
+    }
+    saveStateBeforeParse() {
+      this._savedState = {
+        _name: this._name,
+        _optionValues: { ...this._optionValues },
+        _optionValueSources: { ...this._optionValueSources }
+      };
+    }
+    restoreStateBeforeParse() {
+      if (this._storeOptionsAsProperties)
+        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
+- either make a new Command for each call to parse, or stop storing options as properties`);
+      this._name = this._savedState._name;
+      this._scriptPath = null;
+      this.rawArgs = [];
+      this._optionValues = { ...this._savedState._optionValues };
+      this._optionValueSources = { ...this._savedState._optionValueSources };
+      this.args = [];
+      this.processedArgs = [];
+    }
+    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+      if (fs.existsSync(executableFile))
+        return;
+      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+      const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+      throw new Error(executableMissing);
+    }
+    _executeSubCommand(subcommand, args) {
+      args = args.slice();
+      let launchWithNode = false;
+      const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
+      function findFile(baseDir, baseName) {
+        const localBin = path.resolve(baseDir, baseName);
+        if (fs.existsSync(localBin))
+          return localBin;
+        if (sourceExt.includes(path.extname(baseName)))
+          return;
+        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
+        if (foundExt)
+          return `${localBin}${foundExt}`;
+        return;
+      }
+      this._checkForMissingMandatoryOptions();
+      this._checkForConflictingOptions();
+      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
+      let executableDir = this._executableDir || "";
+      if (this._scriptPath) {
+        let resolvedScriptPath;
+        try {
+          resolvedScriptPath = fs.realpathSync(this._scriptPath);
+        } catch {
+          resolvedScriptPath = this._scriptPath;
+        }
+        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+      }
+      if (executableDir) {
+        let localFile = findFile(executableDir, executableFile);
+        if (!localFile && !subcommand._executableFile && this._scriptPath) {
+          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+          if (legacyName !== this._name) {
+            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
+          }
+        }
+        executableFile = localFile || executableFile;
+      }
+      launchWithNode = sourceExt.includes(path.extname(executableFile));
+      let proc;
+      if (process2.platform !== "win32") {
+        if (launchWithNode) {
+          args.unshift(executableFile);
+          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+        } else {
+          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
+        }
+      } else {
+        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
+        args.unshift(executableFile);
+        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+      }
+      if (!proc.killed) {
+        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
+        signals.forEach((signal) => {
+          process2.on(signal, () => {
+            if (proc.killed === false && proc.exitCode === null) {
+              proc.kill(signal);
+            }
+          });
+        });
+      }
+      const exitCallback = this._exitCallback;
+      proc.on("close", (code) => {
+        code = code ?? 1;
+        if (!exitCallback) {
+          process2.exit(code);
+        } else {
+          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
+        }
+      });
+      proc.on("error", (err) => {
+        if (err.code === "ENOENT") {
+          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
+        } else if (err.code === "EACCES") {
+          throw new Error(`'${executableFile}' not executable`);
+        }
+        if (!exitCallback) {
+          process2.exit(1);
+        } else {
+          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
+          wrappedError.nestedError = err;
+          exitCallback(wrappedError);
+        }
+      });
+      this.runningCommand = proc;
+    }
+    _dispatchSubcommand(commandName, operands, unknown) {
+      const subCommand = this._findCommand(commandName);
+      if (!subCommand)
+        this.help({ error: true });
+      subCommand._prepareForParse();
+      let promiseChain;
+      promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
+      promiseChain = this._chainOrCall(promiseChain, () => {
+        if (subCommand._executableHandler) {
+          this._executeSubCommand(subCommand, operands.concat(unknown));
+        } else {
+          return subCommand._parseCommand(operands, unknown);
+        }
+      });
+      return promiseChain;
+    }
+    _dispatchHelpCommand(subcommandName) {
+      if (!subcommandName) {
+        this.help();
+      }
+      const subCommand = this._findCommand(subcommandName);
+      if (subCommand && !subCommand._executableHandler) {
+        subCommand.help();
+      }
+      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
+    }
+    _checkNumberOfArguments() {
+      this.registeredArguments.forEach((arg, i) => {
+        if (arg.required && this.args[i] == null) {
+          this.missingArgument(arg.name());
+        }
+      });
+      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
+        return;
+      }
+      if (this.args.length > this.registeredArguments.length) {
+        this._excessArguments(this.args);
+      }
+    }
+    _processArguments() {
+      const myParseArg = (argument, value, previous) => {
+        let parsedValue = value;
+        if (value !== null && argument.parseArg) {
+          const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
+          parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
+        }
+        return parsedValue;
+      };
+      this._checkNumberOfArguments();
+      const processedArgs = [];
+      this.registeredArguments.forEach((declaredArg, index) => {
+        let value = declaredArg.defaultValue;
+        if (declaredArg.variadic) {
+          if (index < this.args.length) {
+            value = this.args.slice(index);
+            if (declaredArg.parseArg) {
+              value = value.reduce((processed, v) => {
+                return myParseArg(declaredArg, v, processed);
+              }, declaredArg.defaultValue);
+            }
+          } else if (value === undefined) {
+            value = [];
+          }
+        } else if (index < this.args.length) {
+          value = this.args[index];
+          if (declaredArg.parseArg) {
+            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
+          }
+        }
+        processedArgs[index] = value;
+      });
+      this.processedArgs = processedArgs;
+    }
+    _chainOrCall(promise, fn) {
+      if (promise && promise.then && typeof promise.then === "function") {
+        return promise.then(() => fn());
+      }
+      return fn();
+    }
+    _chainOrCallHooks(promise, event) {
+      let result = promise;
+      const hooks = [];
+      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
+        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
+          hooks.push({ hookedCommand, callback });
+        });
+      });
+      if (event === "postAction") {
+        hooks.reverse();
+      }
+      hooks.forEach((hookDetail) => {
+        result = this._chainOrCall(result, () => {
+          return hookDetail.callback(hookDetail.hookedCommand, this);
+        });
+      });
+      return result;
+    }
+    _chainOrCallSubCommandHook(promise, subCommand, event) {
+      let result = promise;
+      if (this._lifeCycleHooks[event] !== undefined) {
+        this._lifeCycleHooks[event].forEach((hook) => {
+          result = this._chainOrCall(result, () => {
+            return hook(this, subCommand);
+          });
+        });
+      }
+      return result;
+    }
+    _parseCommand(operands, unknown) {
+      const parsed = this.parseOptions(unknown);
+      this._parseOptionsEnv();
+      this._parseOptionsImplied();
+      operands = operands.concat(parsed.operands);
+      unknown = parsed.unknown;
+      this.args = operands.concat(unknown);
+      if (operands && this._findCommand(operands[0])) {
+        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
+      }
+      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
+        return this._dispatchHelpCommand(operands[1]);
+      }
+      if (this._defaultCommandName) {
+        this._outputHelpIfRequested(unknown);
+        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+      }
+      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
+        this.help({ error: true });
+      }
+      this._outputHelpIfRequested(parsed.unknown);
+      this._checkForMissingMandatoryOptions();
+      this._checkForConflictingOptions();
+      const checkForUnknownOptions = () => {
+        if (parsed.unknown.length > 0) {
+          this.unknownOption(parsed.unknown[0]);
+        }
+      };
+      const commandEvent = `command:${this.name()}`;
+      if (this._actionHandler) {
+        checkForUnknownOptions();
+        this._processArguments();
+        let promiseChain;
+        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
+        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
+        if (this.parent) {
+          promiseChain = this._chainOrCall(promiseChain, () => {
+            this.parent.emit(commandEvent, operands, unknown);
+          });
+        }
+        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
+        return promiseChain;
+      }
+      if (this.parent && this.parent.listenerCount(commandEvent)) {
+        checkForUnknownOptions();
+        this._processArguments();
+        this.parent.emit(commandEvent, operands, unknown);
+      } else if (operands.length) {
+        if (this._findCommand("*")) {
+          return this._dispatchSubcommand("*", operands, unknown);
+        }
+        if (this.listenerCount("command:*")) {
+          this.emit("command:*", operands, unknown);
+        } else if (this.commands.length) {
+          this.unknownCommand();
+        } else {
+          checkForUnknownOptions();
+          this._processArguments();
+        }
+      } else if (this.commands.length) {
+        checkForUnknownOptions();
+        this.help({ error: true });
+      } else {
+        checkForUnknownOptions();
+        this._processArguments();
+      }
+    }
+    _findCommand(name) {
+      if (!name)
+        return;
+      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
+    }
+    _findOption(arg) {
+      return this.options.find((option) => option.is(arg));
+    }
+    _checkForMissingMandatoryOptions() {
+      this._getCommandAndAncestors().forEach((cmd) => {
+        cmd.options.forEach((anOption) => {
+          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
+            cmd.missingMandatoryOptionValue(anOption);
+          }
+        });
+      });
+    }
+    _checkForConflictingLocalOptions() {
+      const definedNonDefaultOptions = this.options.filter((option) => {
+        const optionKey = option.attributeName();
+        if (this.getOptionValue(optionKey) === undefined) {
+          return false;
+        }
+        return this.getOptionValueSource(optionKey) !== "default";
+      });
+      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
+      optionsWithConflicting.forEach((option) => {
+        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
+        if (conflictingAndDefined) {
+          this._conflictingOption(option, conflictingAndDefined);
+        }
+      });
+    }
+    _checkForConflictingOptions() {
+      this._getCommandAndAncestors().forEach((cmd) => {
+        cmd._checkForConflictingLocalOptions();
+      });
+    }
+    parseOptions(argv) {
+      const operands = [];
+      const unknown = [];
+      let dest = operands;
+      const args = argv.slice();
+      function maybeOption(arg) {
+        return arg.length > 1 && arg[0] === "-";
+      }
+      let activeVariadicOption = null;
+      while (args.length) {
+        const arg = args.shift();
+        if (arg === "--") {
+          if (dest === unknown)
+            dest.push(arg);
+          dest.push(...args);
+          break;
+        }
+        if (activeVariadicOption && !maybeOption(arg)) {
+          this.emit(`option:${activeVariadicOption.name()}`, arg);
+          continue;
+        }
+        activeVariadicOption = null;
+        if (maybeOption(arg)) {
+          const option = this._findOption(arg);
+          if (option) {
+            if (option.required) {
+              const value = args.shift();
+              if (value === undefined)
+                this.optionMissingArgument(option);
+              this.emit(`option:${option.name()}`, value);
+            } else if (option.optional) {
+              let value = null;
+              if (args.length > 0 && !maybeOption(args[0])) {
+                value = args.shift();
+              }
+              this.emit(`option:${option.name()}`, value);
+            } else {
+              this.emit(`option:${option.name()}`);
+            }
+            activeVariadicOption = option.variadic ? option : null;
+            continue;
+          }
+        }
+        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
+          const option = this._findOption(`-${arg[1]}`);
+          if (option) {
+            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
+              this.emit(`option:${option.name()}`, arg.slice(2));
+            } else {
+              this.emit(`option:${option.name()}`);
+              args.unshift(`-${arg.slice(2)}`);
+            }
+            continue;
+          }
+        }
+        if (/^--[^=]+=/.test(arg)) {
+          const index = arg.indexOf("=");
+          const option = this._findOption(arg.slice(0, index));
+          if (option && (option.required || option.optional)) {
+            this.emit(`option:${option.name()}`, arg.slice(index + 1));
+            continue;
+          }
+        }
+        if (maybeOption(arg)) {
+          dest = unknown;
+        }
+        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
+          if (this._findCommand(arg)) {
+            operands.push(arg);
+            if (args.length > 0)
+              unknown.push(...args);
+            break;
+          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
+            operands.push(arg);
+            if (args.length > 0)
+              operands.push(...args);
+            break;
+          } else if (this._defaultCommandName) {
+            unknown.push(arg);
+            if (args.length > 0)
+              unknown.push(...args);
+            break;
+          }
+        }
+        if (this._passThroughOptions) {
+          dest.push(arg);
+          if (args.length > 0)
+            dest.push(...args);
+          break;
+        }
+        dest.push(arg);
+      }
+      return { operands, unknown };
+    }
+    opts() {
+      if (this._storeOptionsAsProperties) {
+        const result = {};
+        const len = this.options.length;
+        for (let i = 0;i < len; i++) {
+          const key = this.options[i].attributeName();
+          result[key] = key === this._versionOptionName ? this._version : this[key];
+        }
+        return result;
+      }
+      return this._optionValues;
+    }
+    optsWithGlobals() {
+      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
+    }
+    error(message, errorOptions) {
+      this._outputConfiguration.outputError(`${message}
+`, this._outputConfiguration.writeErr);
+      if (typeof this._showHelpAfterError === "string") {
+        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
+`);
+      } else if (this._showHelpAfterError) {
+        this._outputConfiguration.writeErr(`
+`);
+        this.outputHelp({ error: true });
+      }
+      const config = errorOptions || {};
+      const exitCode = config.exitCode || 1;
+      const code = config.code || "commander.error";
+      this._exit(exitCode, code, message);
+    }
+    _parseOptionsEnv() {
+      this.options.forEach((option) => {
+        if (option.envVar && option.envVar in process2.env) {
+          const optionKey = option.attributeName();
+          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
+            if (option.required || option.optional) {
+              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+            } else {
+              this.emit(`optionEnv:${option.name()}`);
+            }
+          }
+        }
+      });
+    }
+    _parseOptionsImplied() {
+      const dualHelper = new DualOptions(this.options);
+      const hasCustomOptionValue = (optionKey) => {
+        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
+      };
+      this.options.filter((option) => option.implied !== undefined && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
+        Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
+          this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
+        });
+      });
+    }
+    missingArgument(name) {
+      const message = `error: missing required argument '${name}'`;
+      this.error(message, { code: "commander.missingArgument" });
+    }
+    optionMissingArgument(option) {
+      const message = `error: option '${option.flags}' argument missing`;
+      this.error(message, { code: "commander.optionMissingArgument" });
+    }
+    missingMandatoryOptionValue(option) {
+      const message = `error: required option '${option.flags}' not specified`;
+      this.error(message, { code: "commander.missingMandatoryOptionValue" });
+    }
+    _conflictingOption(option, conflictingOption) {
+      const findBestOptionFromValue = (option2) => {
+        const optionKey = option2.attributeName();
+        const optionValue = this.getOptionValue(optionKey);
+        const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
+        const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
+        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
+          return negativeOption;
+        }
+        return positiveOption || option2;
+      };
+      const getErrorMessage = (option2) => {
+        const bestOption = findBestOptionFromValue(option2);
+        const optionKey = bestOption.attributeName();
+        const source = this.getOptionValueSource(optionKey);
+        if (source === "env") {
+          return `environment variable '${bestOption.envVar}'`;
+        }
+        return `option '${bestOption.flags}'`;
+      };
+      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
+      this.error(message, { code: "commander.conflictingOption" });
+    }
+    unknownOption(flag) {
+      if (this._allowUnknownOption)
+        return;
+      let suggestion = "";
+      if (flag.startsWith("--") && this._showSuggestionAfterError) {
+        let candidateFlags = [];
+        let command = this;
+        do {
+          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
+          candidateFlags = candidateFlags.concat(moreFlags);
+          command = command.parent;
+        } while (command && !command._enablePositionalOptions);
+        suggestion = suggestSimilar(flag, candidateFlags);
+      }
+      const message = `error: unknown option '${flag}'${suggestion}`;
+      this.error(message, { code: "commander.unknownOption" });
+    }
+    _excessArguments(receivedArgs) {
+      if (this._allowExcessArguments)
+        return;
+      const expected = this.registeredArguments.length;
+      const s = expected === 1 ? "" : "s";
+      const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
+      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
+      this.error(message, { code: "commander.excessArguments" });
+    }
+    unknownCommand() {
+      const unknownName = this.args[0];
+      let suggestion = "";
+      if (this._showSuggestionAfterError) {
+        const candidateNames = [];
+        this.createHelp().visibleCommands(this).forEach((command) => {
+          candidateNames.push(command.name());
+          if (command.alias())
+            candidateNames.push(command.alias());
+        });
+        suggestion = suggestSimilar(unknownName, candidateNames);
+      }
+      const message = `error: unknown command '${unknownName}'${suggestion}`;
+      this.error(message, { code: "commander.unknownCommand" });
+    }
+    version(str, flags, description) {
+      if (str === undefined)
+        return this._version;
+      this._version = str;
+      flags = flags || "-V, --version";
+      description = description || "output the version number";
+      const versionOption = this.createOption(flags, description);
+      this._versionOptionName = versionOption.attributeName();
+      this._registerOption(versionOption);
+      this.on("option:" + versionOption.name(), () => {
+        this._outputConfiguration.writeOut(`${str}
+`);
+        this._exit(0, "commander.version", str);
+      });
+      return this;
+    }
+    description(str, argsDescription) {
+      if (str === undefined && argsDescription === undefined)
+        return this._description;
+      this._description = str;
+      if (argsDescription) {
+        this._argsDescription = argsDescription;
+      }
+      return this;
+    }
+    summary(str) {
+      if (str === undefined)
+        return this._summary;
+      this._summary = str;
+      return this;
+    }
+    alias(alias) {
+      if (alias === undefined)
+        return this._aliases[0];
+      let command = this;
+      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+        command = this.commands[this.commands.length - 1];
+      }
+      if (alias === command._name)
+        throw new Error("Command alias can't be the same as its name");
+      const matchingCommand = this.parent?._findCommand(alias);
+      if (matchingCommand) {
+        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
+        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+      }
+      command._aliases.push(alias);
+      return this;
+    }
+    aliases(aliases) {
+      if (aliases === undefined)
+        return this._aliases;
+      aliases.forEach((alias) => this.alias(alias));
+      return this;
+    }
+    usage(str) {
+      if (str === undefined) {
+        if (this._usage)
+          return this._usage;
+        const args = this.registeredArguments.map((arg) => {
+          return humanReadableArgName(arg);
+        });
+        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
+      }
+      this._usage = str;
+      return this;
+    }
+    name(str) {
+      if (str === undefined)
+        return this._name;
+      this._name = str;
+      return this;
+    }
+    nameFromFilename(filename) {
+      this._name = path.basename(filename, path.extname(filename));
+      return this;
+    }
+    executableDir(path2) {
+      if (path2 === undefined)
+        return this._executableDir;
+      this._executableDir = path2;
+      return this;
+    }
+    helpInformation(contextOptions) {
+      const helper = this.createHelp();
+      const context = this._getOutputContext(contextOptions);
+      helper.prepareContext({
+        error: context.error,
+        helpWidth: context.helpWidth,
+        outputHasColors: context.hasColors
+      });
+      const text = helper.formatHelp(this, helper);
+      if (context.hasColors)
+        return text;
+      return this._outputConfiguration.stripColor(text);
+    }
+    _getOutputContext(contextOptions) {
+      contextOptions = contextOptions || {};
+      const error = !!contextOptions.error;
+      let baseWrite;
+      let hasColors;
+      let helpWidth;
+      if (error) {
+        baseWrite = (str) => this._outputConfiguration.writeErr(str);
+        hasColors = this._outputConfiguration.getErrHasColors();
+        helpWidth = this._outputConfiguration.getErrHelpWidth();
+      } else {
+        baseWrite = (str) => this._outputConfiguration.writeOut(str);
+        hasColors = this._outputConfiguration.getOutHasColors();
+        helpWidth = this._outputConfiguration.getOutHelpWidth();
+      }
+      const write = (str) => {
+        if (!hasColors)
+          str = this._outputConfiguration.stripColor(str);
+        return baseWrite(str);
+      };
+      return { error, write, hasColors, helpWidth };
+    }
+    outputHelp(contextOptions) {
+      let deprecatedCallback;
+      if (typeof contextOptions === "function") {
+        deprecatedCallback = contextOptions;
+        contextOptions = undefined;
+      }
+      const outputContext = this._getOutputContext(contextOptions);
+      const eventContext = {
+        error: outputContext.error,
+        write: outputContext.write,
+        command: this
+      };
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
+      this.emit("beforeHelp", eventContext);
+      let helpInformation = this.helpInformation({ error: outputContext.error });
+      if (deprecatedCallback) {
+        helpInformation = deprecatedCallback(helpInformation);
+        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
+          throw new Error("outputHelp callback must return a string or a Buffer");
+        }
+      }
+      outputContext.write(helpInformation);
+      if (this._getHelpOption()?.long) {
+        this.emit(this._getHelpOption().long);
+      }
+      this.emit("afterHelp", eventContext);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
+    }
+    helpOption(flags, description) {
+      if (typeof flags === "boolean") {
+        if (flags) {
+          this._helpOption = this._helpOption ?? undefined;
+        } else {
+          this._helpOption = null;
+        }
+        return this;
+      }
+      flags = flags ?? "-h, --help";
+      description = description ?? "display help for command";
+      this._helpOption = this.createOption(flags, description);
+      return this;
+    }
+    _getHelpOption() {
+      if (this._helpOption === undefined) {
+        this.helpOption(undefined, undefined);
+      }
+      return this._helpOption;
+    }
+    addHelpOption(option) {
+      this._helpOption = option;
+      return this;
+    }
+    help(contextOptions) {
+      this.outputHelp(contextOptions);
+      let exitCode = Number(process2.exitCode ?? 0);
+      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode = 1;
+      }
+      this._exit(exitCode, "commander.help", "(outputHelp)");
+    }
+    addHelpText(position, text) {
+      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
+      if (!allowedValues.includes(position)) {
+        throw new Error(`Unexpected value for position to addHelpText.
+Expecting one of '${allowedValues.join("', '")}'`);
+      }
+      const helpEvent = `${position}Help`;
+      this.on(helpEvent, (context) => {
+        let helpStr;
+        if (typeof text === "function") {
+          helpStr = text({ error: context.error, command: context.command });
+        } else {
+          helpStr = text;
+        }
+        if (helpStr) {
+          context.write(`${helpStr}
+`);
+        }
+      });
+      return this;
+    }
+    _outputHelpIfRequested(args) {
+      const helpOption = this._getHelpOption();
+      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
+      if (helpRequested) {
+        this.outputHelp();
+        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      }
+    }
+  }
+  function incrementNodeInspectorPort(args) {
+    return args.map((arg) => {
+      if (!arg.startsWith("--inspect")) {
+        return arg;
+      }
+      let debugOption;
+      let debugHost = "127.0.0.1";
+      let debugPort = "9229";
+      let match;
+      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
+        debugOption = match[1];
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+        debugOption = match[1];
+        if (/^\d+$/.test(match[3])) {
+          debugPort = match[3];
+        } else {
+          debugHost = match[3];
+        }
+      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+        debugOption = match[1];
+        debugHost = match[3];
+        debugPort = match[4];
+      }
+      if (debugOption && debugPort !== "0") {
+        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
+      }
+      return arg;
+    });
+  }
+  function useColor() {
+    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
+      return false;
+    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
+      return true;
+    return;
+  }
+  exports.Command = Command;
+  exports.useColor = useColor;
+});
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/index.js
+var require_commander = __commonJS((exports) => {
+  var { Argument } = require_argument();
+  var { Command } = require_command();
+  var { CommanderError, InvalidArgumentError } = require_error();
+  var { Help } = require_help();
+  var { Option } = require_option();
+  exports.program = new Command;
+  exports.createCommand = (name) => new Command(name);
+  exports.createOption = (flags, description) => new Option(flags, description);
+  exports.createArgument = (name, description) => new Argument(name, description);
+  exports.Command = Command;
+  exports.Option = Option;
+  exports.Argument = Argument;
+  exports.Help = Help;
+  exports.CommanderError = CommanderError;
+  exports.InvalidArgumentError = InvalidArgumentError;
+  exports.InvalidOptionArgumentError = InvalidArgumentError;
+});
+
+// ../../packages/core/dist/errors/index.js
+var require_errors = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.severityForCode = exports.inferCodeFromStatus = exports.isDomainErrorPayload = undefined;
+  var DOMAIN_CODES = new Set([
+    "VALIDATION_FAILED",
+    "NOT_FOUND",
+    "UNAUTHORIZED",
+    "FORBIDDEN",
+    "CONFLICT",
+    "PRECONDITION_REQUIRED",
+    "RATE_LIMITED",
+    "INTERNAL"
+  ]);
+  var isDomainErrorPayload = (value) => {
+    if (typeof value !== "object" || value === null)
+      return false;
+    const v = value;
+    return typeof v.statusCode === "number" && typeof v.code === "string" && DOMAIN_CODES.has(v.code) && typeof v.message === "string";
+  };
+  exports.isDomainErrorPayload = isDomainErrorPayload;
+  var inferCodeFromStatus = (status) => {
+    if (status === 401)
+      return "UNAUTHORIZED";
+    if (status === 403)
+      return "FORBIDDEN";
+    if (status === 404)
+      return "NOT_FOUND";
+    if (status === 409)
+      return "CONFLICT";
+    if (status === 412 || status === 428)
+      return "PRECONDITION_REQUIRED";
+    if (status === 422 || status === 400)
+      return "VALIDATION_FAILED";
+    if (status === 429)
+      return "RATE_LIMITED";
+    return "INTERNAL";
+  };
+  exports.inferCodeFromStatus = inferCodeFromStatus;
+  var severityForCode = (code) => {
+    switch (code) {
+      case "VALIDATION_FAILED":
+        return "low";
+      case "NOT_FOUND":
+      case "CONFLICT":
+      case "PRECONDITION_REQUIRED":
+      case "RATE_LIMITED":
+        return "medium";
+      case "UNAUTHORIZED":
+      case "FORBIDDEN":
+        return "high";
+      case "INTERNAL":
+        return "critical";
+    }
+  };
+  exports.severityForCode = severityForCode;
+});
+
+// ../../packages/core/dist/history/index.js
+var require_history = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.canRedo = exports.canUndo = exports.emptyHistory = undefined;
+  exports.recordSnapshot = recordSnapshot;
+  exports.undoStep = undoStep;
+  exports.redoStep = redoStep;
+  var emptyHistory = () => ({ past: [], future: [] });
+  exports.emptyHistory = emptyHistory;
+  var canUndo = (history) => history.past.length > 0;
+  exports.canUndo = canUndo;
+  var canRedo = (history) => history.future.length > 0;
+  exports.canRedo = canRedo;
+  var DEFAULT_MAX_DEPTH = 50;
+  function recordSnapshot(history, current, config = {}) {
+    const { maxDepth = DEFAULT_MAX_DEPTH, equals } = config;
+    const lastPast = history.past[history.past.length - 1];
+    if (lastPast !== undefined && equals?.(lastPast, current)) {
+      return history;
+    }
+    const past = [...history.past, current];
+    const trimmed = past.length > maxDepth ? past.slice(past.length - maxDepth) : past;
+    return { past: trimmed, future: [] };
+  }
+  function undoStep(history, current) {
+    if (history.past.length === 0)
+      return null;
+    const previous = history.past[history.past.length - 1];
+    return {
+      history: { past: history.past.slice(0, -1), future: [...history.future, current] },
+      previous
+    };
+  }
+  function redoStep(history, current) {
+    if (history.future.length === 0)
+      return null;
+    const next = history.future[history.future.length - 1];
+    return {
+      history: { past: [...history.past, current], future: history.future.slice(0, -1) },
+      next
+    };
+  }
+});
+
+// ../../packages/core/dist/types/index.js
+var require_types = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ROUTE_VISIBILITIES = exports.ROUTE_ACTIVITIES = undefined;
+  exports.ROUTE_ACTIVITIES = ["run", "cycle", "walk"];
+  exports.ROUTE_VISIBILITIES = ["private", "unlisted", "public"];
+});
+
+// ../../packages/core/dist/preferences/user-preferences.js
+var require_user_preferences = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DEFAULT_USER_PREFERENCES = exports.OVERLAY_KEYS = exports.ROUTE_VISIBILITIES = exports.MAP_STYLES = exports.UNITS = exports.ACTIVITIES = undefined;
+  exports.isActivity = isActivity;
+  exports.isUnits = isUnits;
+  exports.isMapStyle = isMapStyle;
+  exports.isRouteVisibility = isRouteVisibility;
+  exports.normalizeUserPreferences = normalizeUserPreferences;
+  exports.mergeUserPreferences = mergeUserPreferences;
+  exports.ACTIVITIES = ["run", "cycle", "walk"];
+  exports.UNITS = ["km", "mi"];
+  exports.MAP_STYLES = ["streets", "outdoors", "satellite"];
+  var types_1 = require_types();
+  Object.defineProperty(exports, "ROUTE_VISIBILITIES", { enumerable: true, get: function() {
+    return types_1.ROUTE_VISIBILITIES;
+  } });
+  exports.OVERLAY_KEYS = ["heatmap", "contour", "bike", "surface", "wind"];
+  var ACTIVITY_LABELS = {
+    run: "Running",
+    cycle: "Cycling",
+    walk: "Walking"
+  };
+  var LABEL_TO_ACTIVITY = {
+    Running: "run",
+    Cycling: "cycle",
+    Walking: "walk"
+  };
+  exports.DEFAULT_USER_PREFERENCES = {
+    units: "km",
+    showPois: true,
+    terrain3d: false,
+    autoSnap: true,
+    defaultActivity: "Cycling",
+    selectedSports: [],
+    sportSpeeds: {},
+    mapStyle: "outdoors",
+    overlays: {
+      heatmap: true,
+      contour: false,
+      bike: true,
+      surface: false,
+      wind: false
+    },
+    defaultRouteVisibility: "private"
+  };
+  function isActivity(value) {
+    return exports.ACTIVITIES.includes(value);
+  }
+  function isUnits(value) {
+    return exports.UNITS.includes(value);
+  }
+  function isMapStyle(value) {
+    return exports.MAP_STYLES.includes(value);
+  }
+  function isRouteVisibility(value) {
+    return types_1.ROUTE_VISIBILITIES.includes(value);
+  }
+  function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  function normalizeSelectedSports(input) {
+    if (!Array.isArray(input)) {
+      return [...exports.DEFAULT_USER_PREFERENCES.selectedSports];
+    }
+    const seen = new Set;
+    return input.filter(isActivity).filter((sport) => {
+      if (seen.has(sport)) {
+        return false;
+      }
+      seen.add(sport);
+      return true;
+    });
+  }
+  function normalizeDefaultActivity(input, selectedSports) {
+    if (typeof input === "string") {
+      const mappedSport = LABEL_TO_ACTIVITY[input];
+      if (!mappedSport) {
+        return input;
+      }
+      if (selectedSports.length === 0 || selectedSports.includes(mappedSport)) {
+        return input;
+      }
+    }
+    if (selectedSports.length > 0) {
+      return ACTIVITY_LABELS[selectedSports[0]];
+    }
+    return exports.DEFAULT_USER_PREFERENCES.defaultActivity;
+  }
+  function normalizeSportSpeeds(input) {
+    if (!input || typeof input !== "object") {
+      return { ...exports.DEFAULT_USER_PREFERENCES.sportSpeeds };
+    }
+    const source = input;
+    const next = {};
+    for (const activity of exports.ACTIVITIES) {
+      const value = source[activity];
+      if (isFiniteNumber(value) && value > 0) {
+        next[activity] = value;
+      }
+    }
+    return next;
+  }
+  function normalizeOverlays(input) {
+    const source = input && typeof input === "object" ? input : {};
+    const result = { ...exports.DEFAULT_USER_PREFERENCES.overlays };
+    for (const key of exports.OVERLAY_KEYS) {
+      const value = source[key];
+      if (typeof value === "boolean") {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  function normalizeUserPreferences(input) {
+    const selectedSports = normalizeSelectedSports(input?.selectedSports);
+    return {
+      units: isUnits(input?.units) ? input.units : exports.DEFAULT_USER_PREFERENCES.units,
+      showPois: typeof input?.showPois === "boolean" ? input.showPois : exports.DEFAULT_USER_PREFERENCES.showPois,
+      terrain3d: typeof input?.terrain3d === "boolean" ? input.terrain3d : exports.DEFAULT_USER_PREFERENCES.terrain3d,
+      autoSnap: typeof input?.autoSnap === "boolean" ? input.autoSnap : exports.DEFAULT_USER_PREFERENCES.autoSnap,
+      defaultActivity: normalizeDefaultActivity(input?.defaultActivity, selectedSports),
+      selectedSports,
+      sportSpeeds: normalizeSportSpeeds(input?.sportSpeeds),
+      mapStyle: isMapStyle(input?.mapStyle) ? input.mapStyle : exports.DEFAULT_USER_PREFERENCES.mapStyle,
+      overlays: normalizeOverlays(input?.overlays),
+      defaultRouteVisibility: isRouteVisibility(input?.defaultRouteVisibility) ? input.defaultRouteVisibility : exports.DEFAULT_USER_PREFERENCES.defaultRouteVisibility
+    };
+  }
+  function mergeUserPreferences(current, update) {
+    const base = normalizeUserPreferences(current);
+    return normalizeUserPreferences({
+      ...base,
+      ...update,
+      sportSpeeds: {
+        ...base.sportSpeeds,
+        ...update.sportSpeeds ?? {}
+      },
+      overlays: {
+        ...base.overlays,
+        ...update.overlays ?? {}
+      }
+    });
+  }
+});
+
+// ../../node_modules/.bun/zustand@5.0.13+e55371ec98c955e9/node_modules/zustand/vanilla.js
+var require_vanilla = __commonJS((exports) => {
+  var createStoreImpl = (createState) => {
+    let state;
+    const listeners = /* @__PURE__ */ new Set;
+    const setState = (partial, replace) => {
+      const nextState = typeof partial === "function" ? partial(state) : partial;
+      if (!Object.is(nextState, state)) {
+        const previousState = state;
+        state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+        listeners.forEach((listener) => listener(state, previousState));
+      }
+    };
+    const getState = () => state;
+    const getInitialState = () => initialState;
+    const subscribe = (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    };
+    const api = { setState, getState, getInitialState, subscribe };
+    const initialState = state = createState(setState, getState, api);
+    return api;
+  };
+  var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+  exports.createStore = createStore;
+});
+
+// ../../node_modules/.bun/react@19.2.6/node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS((exports, module) => {
+  (function() {
+    function defineDeprecationWarning(methodName, info) {
+      Object.defineProperty(Component.prototype, methodName, {
+        get: function() {
+          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+        }
+      });
+    }
+    function getIteratorFn(maybeIterable) {
+      if (maybeIterable === null || typeof maybeIterable !== "object")
+        return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return typeof maybeIterable === "function" ? maybeIterable : null;
+    }
+    function warnNoop(publicInstance, callerName) {
+      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+      var warningKey = publicInstance + "." + callerName;
+      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
+    }
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function ComponentDummy() {}
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function noop() {}
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
+      oldElement._store && (newKey._store.validated = oldElement._store.validated);
+      return newKey;
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    function getElementKey(element, index) {
+      return typeof element === "object" && element !== null && element.key != null ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+    }
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch (typeof thenable.status === "string" ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
+            thenable.status === "pending" && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+          }, function(error) {
+            thenable.status === "pending" && (thenable.status = "rejected", thenable.reason = error);
+          })), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if (type === "undefined" || type === "boolean")
+        children = null;
+      var invokeCallback = false;
+      if (children === null)
+        invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+            }
+        }
+      if (invokeCallback) {
+        invokeCallback = children;
+        callback = callback(invokeCallback);
+        var childKey = nameSoFar === "" ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+        isArrayImpl(callback) ? (escapedPrefix = "", childKey != null && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+          return c;
+        })) : callback != null && (isValidElement(callback) && (callback.key != null && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (callback.key == null || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), nameSoFar !== "" && invokeCallback != null && isValidElement(invokeCallback) && invokeCallback.key == null && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+        return 1;
+      }
+      invokeCallback = 0;
+      childKey = nameSoFar === "" ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0;i < children.length; i++)
+          nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (i = getIteratorFn(children), typeof i === "function")
+        for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = true), children = i.call(children), i = 0;!(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (type === "object") {
+        if (typeof children.then === "function")
+          return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+        array = String(children);
+        throw Error("Objects are not valid as a React child (found: " + (array === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (children == null)
+        return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (payload._status === -1) {
+        var ioInfo = payload._ioInfo;
+        ioInfo != null && (ioInfo.start = ioInfo.end = performance.now());
+        ioInfo = payload._result;
+        var thenable = ioInfo();
+        thenable.then(function(moduleObject) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 1;
+            payload._result = moduleObject;
+            var _ioInfo = payload._ioInfo;
+            _ioInfo != null && (_ioInfo.end = performance.now());
+            thenable.status === undefined && (thenable.status = "fulfilled", thenable.value = moduleObject);
+          }
+        }, function(error) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 2;
+            payload._result = error;
+            var _ioInfo2 = payload._ioInfo;
+            _ioInfo2 != null && (_ioInfo2.end = performance.now());
+            thenable.status === undefined && (thenable.status = "rejected", thenable.reason = error);
+          }
+        });
+        ioInfo = payload._ioInfo;
+        if (ioInfo != null) {
+          ioInfo.value = thenable;
+          var displayName = thenable.displayName;
+          typeof displayName === "string" && (ioInfo.name = displayName);
+        }
+        payload._status === -1 && (payload._status = 0, payload._result = thenable);
+      }
+      if (payload._status === 1)
+        return ioInfo = payload._result, ioInfo === undefined && console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`, ioInfo), "default" in ioInfo || console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`, ioInfo), ioInfo.default;
+      throw payload._result;
+    }
+    function resolveDispatcher() {
+      var dispatcher = ReactSharedInternals.H;
+      dispatcher === null && console.error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`);
+      return dispatcher;
+    }
+    function releaseAsyncTransition() {
+      ReactSharedInternals.asyncTransitions--;
+    }
+    function enqueueTask(task) {
+      if (enqueueTaskImpl === null)
+        try {
+          var requireString = ("require" + Math.random()).slice(0, 7);
+          enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
+        } catch (_err) {
+          enqueueTaskImpl = function(callback) {
+            didWarnAboutMessageChannel === false && (didWarnAboutMessageChannel = true, typeof MessageChannel === "undefined" && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+            var channel = new MessageChannel;
+            channel.port1.onmessage = callback;
+            channel.port2.postMessage(undefined);
+          };
+        }
+      return enqueueTaskImpl(task);
+    }
+    function aggregateErrors(errors) {
+      return 1 < errors.length && typeof AggregateError === "function" ? new AggregateError(errors) : errors[0];
+    }
+    function popActScope(prevActQueue, prevActScopeDepth) {
+      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
+      actScopeDepth = prevActScopeDepth;
+    }
+    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+      var queue = ReactSharedInternals.actQueue;
+      if (queue !== null)
+        if (queue.length !== 0)
+          try {
+            flushActQueue(queue);
+            enqueueTask(function() {
+              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            });
+            return;
+          } catch (error) {
+            ReactSharedInternals.thrownErrors.push(error);
+          }
+        else
+          ReactSharedInternals.actQueue = null;
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+    }
+    function flushActQueue(queue) {
+      if (!isFlushing) {
+        isFlushing = true;
+        var i = 0;
+        try {
+          for (;i < queue.length; i++) {
+            var callback = queue[i];
+            do {
+              ReactSharedInternals.didUsePromise = false;
+              var continuation = callback(false);
+              if (continuation !== null) {
+                if (ReactSharedInternals.didUsePromise) {
+                  queue[i] = callback;
+                  queue.splice(0, i);
+                  return;
+                }
+                callback = continuation;
+              } else
+                break;
+            } while (1);
+          }
+          queue.length = 0;
+        } catch (error) {
+          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+        } finally {
+          isFlushing = false;
+        }
+      }
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+      isMounted: function() {
+        return false;
+      },
+      enqueueForceUpdate: function(publicInstance) {
+        warnNoop(publicInstance, "forceUpdate");
+      },
+      enqueueReplaceState: function(publicInstance) {
+        warnNoop(publicInstance, "replaceState");
+      },
+      enqueueSetState: function(publicInstance) {
+        warnNoop(publicInstance, "setState");
+      }
+    }, assign = Object.assign, emptyObject = {};
+    Object.freeze(emptyObject);
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null)
+        throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    var deprecatedAPIs = {
+      isMounted: [
+        "isMounted",
+        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+      ],
+      replaceState: [
+        "replaceState",
+        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+      ]
+    };
+    for (fnName in deprecatedAPIs)
+      deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+    ComponentDummy.prototype = Component.prototype;
+    deprecatedAPIs = PureComponent.prototype = new ComponentDummy;
+    deprecatedAPIs.constructor = PureComponent;
+    assign(deprecatedAPIs, Component.prototype);
+    deprecatedAPIs.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
+      H: null,
+      A: null,
+      T: null,
+      S: null,
+      actQueue: null,
+      asyncTransitions: 0,
+      isBatchingLegacy: false,
+      didScheduleLegacyUpdate: false,
+      didUsePromise: false,
+      thrownErrors: [],
+      getCurrentStack: null,
+      recentlyCreatedOwnerStacks: 0
+    }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    deprecatedAPIs = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = typeof reportError === "function" ? reportError : function(error) {
+      if (typeof window === "object" && typeof window.ErrorEvent === "function") {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: typeof error === "object" && error !== null && typeof error.message === "string" ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event))
+          return;
+      } else if (typeof process === "object" && typeof process.emit === "function") {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = typeof queueMicrotask === "function" ? function(callback) {
+      queueMicrotask(function() {
+        return queueMicrotask(callback);
+      });
+    } : enqueueTask;
+    deprecatedAPIs = Object.freeze({
+      __proto__: null,
+      c: function(size) {
+        return resolveDispatcher().useMemoCache(size);
+      }
+    });
+    var fnName = {
+      map: mapChildren,
+      forEach: function(children, forEachFunc, forEachContext) {
+        mapChildren(children, function() {
+          forEachFunc.apply(this, arguments);
+        }, forEachContext);
+      },
+      count: function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      },
+      toArray: function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      },
+      only: function(children) {
+        if (!isValidElement(children))
+          throw Error("React.Children.only expected to receive a single React element child.");
+        return children;
+      }
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = fnName;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = deprecatedAPIs;
+    exports.act = function(callback) {
+      var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+      actScopeDepth++;
+      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : [], didAwaitActCall = false;
+      try {
+        var result = callback();
+      } catch (error) {
+        ReactSharedInternals.thrownErrors.push(error);
+      }
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        var thenable = result;
+        queueSeveralMicrotasks(function() {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+        });
+        return {
+          then: function(resolve, reject) {
+            didAwaitActCall = true;
+            thenable.then(function(returnValue) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              if (prevActScopeDepth === 0) {
+                try {
+                  flushActQueue(queue), enqueueTask(function() {
+                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                  });
+                } catch (error$0) {
+                  ReactSharedInternals.thrownErrors.push(error$0);
+                }
+                if (0 < ReactSharedInternals.thrownErrors.length) {
+                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+                  ReactSharedInternals.thrownErrors.length = 0;
+                  reject(_thrownError);
+                }
+              } else
+                resolve(returnValue);
+            }, function(error) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+            });
+          }
+        };
+      }
+      var returnValue$jscomp$0 = result;
+      popActScope(prevActQueue, prevActScopeDepth);
+      prevActScopeDepth === 0 && (flushActQueue(queue), queue.length !== 0 && queueSeveralMicrotasks(function() {
+        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
+      }), ReactSharedInternals.actQueue = null);
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      return {
+        then: function(resolve, reject) {
+          didAwaitActCall = true;
+          prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
+          })) : resolve(returnValue$jscomp$0);
+        }
+      };
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.captureOwnerStack = function() {
+      var getCurrentStack = ReactSharedInternals.getCurrentStack;
+      return getCurrentStack === null ? null : getCurrentStack();
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (element === null || element === undefined)
+        throw Error("The argument must be a React element, but you passed " + element + ".");
+      var props = assign({}, element.props), key = element.key, owner = element._owner;
+      if (config != null) {
+        var JSCompiler_inline_result;
+        a: {
+          if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
+            JSCompiler_inline_result = false;
+            break a;
+          }
+          JSCompiler_inline_result = config.ref !== undefined;
+        }
+        JSCompiler_inline_result && (owner = getOwner());
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+        for (propName in config)
+          !hasOwnProperty.call(config, propName) || propName === "key" || propName === "__self" || propName === "__source" || propName === "ref" && config.ref === undefined || (props[propName] = config[propName]);
+      }
+      var propName = arguments.length - 2;
+      if (propName === 1)
+        props.children = children;
+      else if (1 < propName) {
+        JSCompiler_inline_result = Array(propName);
+        for (var i = 0;i < propName; i++)
+          JSCompiler_inline_result[i] = arguments[i + 2];
+        props.children = JSCompiler_inline_result;
+      }
+      props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
+      for (key = 2;key < arguments.length; key++)
+        validateChildKeys(arguments[key]);
+      return props;
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      defaultValue._currentRenderer = null;
+      defaultValue._currentRenderer2 = null;
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      for (var i = 2;i < arguments.length; i++)
+        validateChildKeys(arguments[i]);
+      i = {};
+      var key = null;
+      if (config != null)
+        for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && propName !== "key" && propName !== "__self" && propName !== "__source" && (i[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (childrenLength === 1)
+        i.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), _i = 0;_i < childrenLength; _i++)
+          childArray[_i] = arguments[_i + 2];
+        Object.freeze && Object.freeze(childArray);
+        i.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          i[propName] === undefined && (i[propName] = childrenLength[propName]);
+      key && defineKeyPropWarningGetter(i, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.createRef = function() {
+      var refObject = { current: null };
+      Object.seal(refObject);
+      return refObject;
+    };
+    exports.forwardRef = function(render) {
+      render != null && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof render !== "function" ? console.error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render) : render.length !== 0 && render.length !== 2 && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+      render != null && render.defaultProps != null && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
+      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
+      Object.defineProperty(elementType, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+        }
+      });
+      return elementType;
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      ctor = { _status: -1, _result: ctor };
+      var lazyType = {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: ctor,
+        _init: lazyInitializer
+      }, ioInfo = {
+        name: "lazy",
+        start: -1,
+        end: -1,
+        value: null,
+        owner: null,
+        debugStack: Error("react-stack-top-frame"),
+        debugTask: console.createTask ? console.createTask("lazy()") : null
+      };
+      ctor._ioInfo = ioInfo;
+      lazyType._debugInfo = [{ awaited: ioInfo }];
+      return lazyType;
+    };
+    exports.memo = function(type, compare) {
+      type == null && console.error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
+      compare = {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: compare === undefined ? null : compare
+      };
+      var ownName;
+      Object.defineProperty(compare, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+        }
+      });
+      return compare;
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      currentTransition._updatedFibers = new Set;
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        onStartTransitionFinish !== null && onStartTransitionFinish(currentTransition, returnValue);
+        typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function" && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        prevTransition === null && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), prevTransition !== null && currentTransition.types !== null && (prevTransition.types !== null && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return resolveDispatcher().useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return resolveDispatcher().use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return resolveDispatcher().useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return resolveDispatcher().useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      var dispatcher = resolveDispatcher();
+      Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
+      return dispatcher.useContext(Context);
+    };
+    exports.useDebugValue = function(value, formatterFn) {
+      return resolveDispatcher().useDebugValue(value, formatterFn);
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return resolveDispatcher().useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      create == null && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return resolveDispatcher().useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return resolveDispatcher().useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return resolveDispatcher().useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      create == null && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      create == null && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return resolveDispatcher().useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return resolveDispatcher().useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return resolveDispatcher().useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return resolveDispatcher().useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return resolveDispatcher().useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    };
+    exports.useTransition = function() {
+      return resolveDispatcher().useTransition();
+    };
+    exports.version = "19.2.6";
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+});
+
+// ../../node_modules/.bun/react@19.2.6/node_modules/react/index.js
+var require_react = __commonJS((exports, module) => {
+  var react_development = __toESM(require_react_development());
+  if (false) {} else {
+    module.exports = react_development;
+  }
+});
+
+// ../../node_modules/.bun/zustand@5.0.13+e55371ec98c955e9/node_modules/zustand/react.js
+var require_react2 = __commonJS((exports) => {
+  var React = __toESM(require_react());
+  var vanilla = require_vanilla();
+  var identity = (arg) => arg;
+  function useStore(api, selector = identity) {
+    const slice = React.useSyncExternalStore(api.subscribe, React.useCallback(() => selector(api.getState()), [api, selector]), React.useCallback(() => selector(api.getInitialState()), [api, selector]));
+    React.useDebugValue(slice);
+    return slice;
+  }
+  var createImpl = (createState) => {
+    const api = vanilla.createStore(createState);
+    const useBoundStore = (selector) => useStore(api, selector);
+    Object.assign(useBoundStore, api);
+    return useBoundStore;
+  };
+  var create = (createState) => createState ? createImpl(createState) : createImpl;
+  exports.create = create;
+  exports.useStore = useStore;
+});
+
+// ../../node_modules/.bun/zustand@5.0.13+e55371ec98c955e9/node_modules/zustand/index.js
+var require_zustand = __commonJS((exports) => {
+  var vanilla = require_vanilla();
+  var react = require_react2();
+  Object.keys(vanilla).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function() {
+          return vanilla[k];
+        }
+      });
+  });
+  Object.keys(react).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function() {
+          return react[k];
+        }
+      });
+  });
+});
+
+// ../../node_modules/.bun/zustand@5.0.13+e55371ec98c955e9/node_modules/zustand/middleware.js
+var require_middleware = __commonJS((exports) => {
+  var reduxImpl = (reducer, initial) => (set, _get, api) => {
+    api.dispatch = (action) => {
+      set((state) => reducer(state, action), false, action);
+      return action;
+    };
+    api.dispatchFromDevtools = true;
+    return { dispatch: (...args) => api.dispatch(...args), ...initial };
+  };
+  var redux = reduxImpl;
+  var shouldDispatchFromDevtools = (api) => !!api.dispatchFromDevtools && typeof api.dispatch === "function";
+  var trackedConnections = /* @__PURE__ */ new Map;
+  var getTrackedConnectionState = (name) => {
+    const api = trackedConnections.get(name);
+    if (!api)
+      return {};
+    return Object.fromEntries(Object.entries(api.stores).map(([key, api2]) => [key, api2.getState()]));
+  };
+  var extractConnectionInformation = (store, extensionConnector, options) => {
+    if (store === undefined) {
+      return {
+        type: "untracked",
+        connection: extensionConnector.connect(options)
+      };
+    }
+    const existingConnection = trackedConnections.get(options.name);
+    if (existingConnection) {
+      return { type: "tracked", store, ...existingConnection };
+    }
+    const newConnection = {
+      connection: extensionConnector.connect(options),
+      stores: {}
+    };
+    trackedConnections.set(options.name, newConnection);
+    return { type: "tracked", store, ...newConnection };
+  };
+  var removeStoreFromTrackedConnections = (name, store) => {
+    if (store === undefined)
+      return;
+    const connectionInfo = trackedConnections.get(name);
+    if (!connectionInfo)
+      return;
+    delete connectionInfo.stores[store];
+    if (Object.keys(connectionInfo.stores).length === 0) {
+      trackedConnections.delete(name);
+    }
+  };
+  var v8StackLineRe = /.+ (.+) .+/;
+  var geckoStackLineRe = /^([^@]+)@/;
+  function findCallerName(stack) {
+    var _a, _b, _c;
+    if (!stack)
+      return;
+    const traceLines = stack.split(`
+`);
+    const apiSetStateLineIndex = traceLines.findIndex((traceLine) => traceLine.includes("api.setState"));
+    if (apiSetStateLineIndex < 0)
+      return;
+    const callerLine = ((_a = traceLines[apiSetStateLineIndex + 1]) == null ? undefined : _a.trim()) || "";
+    return ((_b = v8StackLineRe.exec(callerLine)) == null ? undefined : _b[1]) || ((_c = geckoStackLineRe.exec(callerLine)) == null ? undefined : _c[1]);
+  }
+  var devtoolsImpl = (fn, devtoolsOptions = {}) => (set, get, api) => {
+    const { enabled, anonymousActionType, store, ...options } = devtoolsOptions;
+    let extensionConnector;
+    try {
+      extensionConnector = (enabled != null ? enabled : true) && window.__REDUX_DEVTOOLS_EXTENSION__;
+    } catch (e) {}
+    if (!extensionConnector) {
+      return fn(set, get, api);
+    }
+    const { connection, ...connectionInformation } = extractConnectionInformation(store, extensionConnector, options);
+    let isRecording = true;
+    api.setState = (state, replace, nameOrAction) => {
+      const r = set(state, replace);
+      if (!isRecording)
+        return r;
+      const action = nameOrAction === undefined ? {
+        type: anonymousActionType || findCallerName(new Error().stack) || "anonymous"
+      } : typeof nameOrAction === "string" ? { type: nameOrAction } : nameOrAction;
+      if (store === undefined) {
+        connection == null || connection.send(action, get());
+        return r;
+      }
+      connection == null || connection.send({
+        ...action,
+        type: `${store}/${action.type}`
+      }, {
+        ...getTrackedConnectionState(options.name),
+        [store]: api.getState()
+      });
+      return r;
+    };
+    api.devtools = {
+      cleanup: () => {
+        if (connection && typeof connection.unsubscribe === "function") {
+          connection.unsubscribe();
+        }
+        removeStoreFromTrackedConnections(options.name, store);
+      }
+    };
+    const setStateFromDevtools = (...a) => {
+      const originalIsRecording = isRecording;
+      isRecording = false;
+      set(...a);
+      isRecording = originalIsRecording;
+    };
+    const initialState = fn(api.setState, get, api);
+    if (connectionInformation.type === "untracked") {
+      connection == null || connection.init(initialState);
+    } else {
+      connectionInformation.stores[connectionInformation.store] = api;
+      connection == null || connection.init(Object.fromEntries(Object.entries(connectionInformation.stores).map(([key, store2]) => [
+        key,
+        key === connectionInformation.store ? initialState : store2.getState()
+      ])));
+    }
+    if (shouldDispatchFromDevtools(api)) {
+      let didWarnAboutReservedActionType = false;
+      const originalDispatch = api.dispatch;
+      api.dispatch = (...args) => {
+        if (args[0].type === "__setState" && !didWarnAboutReservedActionType) {
+          console.warn('[zustand devtools middleware] "__setState" action type is reserved to set state from the devtools. Avoid using it.');
+          didWarnAboutReservedActionType = true;
+        }
+        originalDispatch(...args);
+      };
+    }
+    connection.subscribe((message) => {
+      var _a;
+      switch (message.type) {
+        case "ACTION":
+          if (typeof message.payload !== "string") {
+            console.error("[zustand devtools middleware] Unsupported action format");
+            return;
+          }
+          return parseJsonThen(message.payload, (action) => {
+            if (action.type === "__setState") {
+              if (store === undefined) {
+                setStateFromDevtools(action.state);
+                return;
+              }
+              if (Object.keys(action.state).length !== 1) {
+                console.error(`
+                    [zustand devtools middleware] Unsupported __setState action format.
+                    When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),
+                    and value of this only key should be a state object. Example: { "type": "__setState", "state": { "abc123Store": { "foo": "bar" } } }
+                    `);
+              }
+              const stateFromDevtools = action.state[store];
+              if (stateFromDevtools === undefined || stateFromDevtools === null) {
+                return;
+              }
+              if (JSON.stringify(api.getState()) !== JSON.stringify(stateFromDevtools)) {
+                setStateFromDevtools(stateFromDevtools);
+              }
+              return;
+            }
+            if (shouldDispatchFromDevtools(api)) {
+              api.dispatch(action);
+            }
+          });
+        case "DISPATCH":
+          switch (message.payload.type) {
+            case "RESET":
+              setStateFromDevtools(initialState);
+              if (store === undefined) {
+                return connection == null ? undefined : connection.init(api.getState());
+              }
+              return connection == null ? undefined : connection.init(getTrackedConnectionState(options.name));
+            case "COMMIT":
+              if (store === undefined) {
+                connection == null || connection.init(api.getState());
+                return;
+              }
+              return connection == null ? undefined : connection.init(getTrackedConnectionState(options.name));
+            case "ROLLBACK":
+              return parseJsonThen(message.state, (state) => {
+                if (store === undefined) {
+                  setStateFromDevtools(state);
+                  connection == null || connection.init(api.getState());
+                  return;
+                }
+                setStateFromDevtools(state[store]);
+                connection == null || connection.init(getTrackedConnectionState(options.name));
+              });
+            case "JUMP_TO_STATE":
+            case "JUMP_TO_ACTION":
+              return parseJsonThen(message.state, (state) => {
+                if (store === undefined) {
+                  setStateFromDevtools(state);
+                  return;
+                }
+                if (JSON.stringify(api.getState()) !== JSON.stringify(state[store])) {
+                  setStateFromDevtools(state[store]);
+                }
+              });
+            case "IMPORT_STATE": {
+              const { nextLiftedState } = message.payload;
+              const lastComputedState = (_a = nextLiftedState.computedStates.slice(-1)[0]) == null ? undefined : _a.state;
+              if (!lastComputedState)
+                return;
+              if (store === undefined) {
+                setStateFromDevtools(lastComputedState);
+              } else {
+                setStateFromDevtools(lastComputedState[store]);
+              }
+              connection == null || connection.send(null, nextLiftedState);
+              return;
+            }
+            case "PAUSE_RECORDING":
+              return isRecording = !isRecording;
+          }
+          return;
+      }
+    });
+    return initialState;
+  };
+  var devtools = devtoolsImpl;
+  var parseJsonThen = (stringified, fn) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(stringified);
+    } catch (e) {
+      console.error("[zustand devtools middleware] Could not parse the received json", e);
+    }
+    if (parsed !== undefined)
+      fn(parsed);
+  };
+  var subscribeWithSelectorImpl = (fn) => (set, get, api) => {
+    const origSubscribe = api.subscribe;
+    api.subscribe = (selector, optListener, options) => {
+      let listener = selector;
+      if (optListener) {
+        const equalityFn = (options == null ? undefined : options.equalityFn) || Object.is;
+        let currentSlice = selector(api.getState());
+        listener = (state) => {
+          const nextSlice = selector(state);
+          if (!equalityFn(currentSlice, nextSlice)) {
+            const previousSlice = currentSlice;
+            optListener(currentSlice = nextSlice, previousSlice);
+          }
+        };
+        if (options == null ? undefined : options.fireImmediately) {
+          optListener(currentSlice, currentSlice);
+        }
+      }
+      return origSubscribe(listener);
+    };
+    const initialState = fn(set, get, api);
+    return initialState;
+  };
+  var subscribeWithSelector = subscribeWithSelectorImpl;
+  function combine(initialState, create) {
+    return (...args) => Object.assign({}, initialState, create(...args));
+  }
+  function createJSONStorage(getStorage, options) {
+    let storage;
+    try {
+      storage = getStorage();
+    } catch (e) {
+      return;
+    }
+    const persistStorage = {
+      getItem: (name) => {
+        var _a;
+        const parse = (str2) => {
+          if (str2 === null) {
+            return null;
+          }
+          return JSON.parse(str2, options == null ? undefined : options.reviver);
+        };
+        const str = (_a = storage.getItem(name)) != null ? _a : null;
+        if (str instanceof Promise) {
+          return str.then(parse);
+        }
+        return parse(str);
+      },
+      setItem: (name, newValue) => storage.setItem(name, JSON.stringify(newValue, options == null ? undefined : options.replacer)),
+      removeItem: (name) => storage.removeItem(name)
+    };
+    return persistStorage;
+  }
+  var toThenable = (fn) => (input) => {
+    try {
+      const result = fn(input);
+      if (result instanceof Promise) {
+        return result;
+      }
+      return {
+        then(onFulfilled) {
+          return toThenable(onFulfilled)(result);
+        },
+        catch(_onRejected) {
+          return this;
+        }
+      };
+    } catch (e) {
+      return {
+        then(_onFulfilled) {
+          return this;
+        },
+        catch(onRejected) {
+          return toThenable(onRejected)(e);
+        }
+      };
+    }
+  };
+  var persistImpl = (config, baseOptions) => (set, get, api) => {
+    let options = {
+      storage: createJSONStorage(() => window.localStorage),
+      partialize: (state) => state,
+      version: 0,
+      merge: (persistedState, currentState) => ({
+        ...currentState,
+        ...persistedState
+      }),
+      ...baseOptions
+    };
+    let hasHydrated = false;
+    let hydrationVersion = 0;
+    const hydrationListeners = /* @__PURE__ */ new Set;
+    const finishHydrationListeners = /* @__PURE__ */ new Set;
+    let storage = options.storage;
+    if (!storage) {
+      return config((...args) => {
+        console.warn(`[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`);
+        set(...args);
+      }, get, api);
+    }
+    const setItem = () => {
+      const state = options.partialize({ ...get() });
+      return storage.setItem(options.name, {
+        state,
+        version: options.version
+      });
+    };
+    const savedSetState = api.setState;
+    api.setState = (state, replace) => {
+      savedSetState(state, replace);
+      return setItem();
+    };
+    const configResult = config((...args) => {
+      set(...args);
+      return setItem();
+    }, get, api);
+    api.getInitialState = () => configResult;
+    let stateFromStorage;
+    const hydrate = () => {
+      var _a, _b;
+      if (!storage)
+        return;
+      const currentVersion = ++hydrationVersion;
+      hasHydrated = false;
+      hydrationListeners.forEach((cb) => {
+        var _a2;
+        return cb((_a2 = get()) != null ? _a2 : configResult);
+      });
+      const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? undefined : _b.call(options, (_a = get()) != null ? _a : configResult)) || undefined;
+      return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+        if (deserializedStorageValue) {
+          if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+            if (options.migrate) {
+              const migration = options.migrate(deserializedStorageValue.state, deserializedStorageValue.version);
+              if (migration instanceof Promise) {
+                return migration.then((result) => [true, result]);
+              }
+              return [true, migration];
+            }
+            console.error(`State loaded from storage couldn't be migrated since no migrate function was provided`);
+          } else {
+            return [false, deserializedStorageValue.state];
+          }
+        }
+        return [false, undefined];
+      }).then((migrationResult) => {
+        var _a2;
+        if (currentVersion !== hydrationVersion) {
+          return;
+        }
+        const [migrated, migratedState] = migrationResult;
+        stateFromStorage = options.merge(migratedState, (_a2 = get()) != null ? _a2 : configResult);
+        set(stateFromStorage, true);
+        if (migrated) {
+          return setItem();
+        }
+      }).then(() => {
+        if (currentVersion !== hydrationVersion) {
+          return;
+        }
+        postRehydrationCallback == null || postRehydrationCallback(get(), undefined);
+        stateFromStorage = get();
+        hasHydrated = true;
+        finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+      }).catch((e) => {
+        if (currentVersion !== hydrationVersion) {
+          return;
+        }
+        postRehydrationCallback == null || postRehydrationCallback(undefined, e);
+      });
+    };
+    api.persist = {
+      setOptions: (newOptions) => {
+        options = {
+          ...options,
+          ...newOptions
+        };
+        if (newOptions.storage) {
+          storage = newOptions.storage;
+        }
+      },
+      clearStorage: () => {
+        storage == null || storage.removeItem(options.name);
+      },
+      getOptions: () => options,
+      rehydrate: () => hydrate(),
+      hasHydrated: () => hasHydrated,
+      onHydrate: (cb) => {
+        hydrationListeners.add(cb);
+        return () => {
+          hydrationListeners.delete(cb);
+        };
+      },
+      onFinishHydration: (cb) => {
+        finishHydrationListeners.add(cb);
+        return () => {
+          finishHydrationListeners.delete(cb);
+        };
+      }
+    };
+    if (!options.skipHydration) {
+      hydrate();
+    }
+    return stateFromStorage || configResult;
+  };
+  var persist = persistImpl;
+  function ssrSafe(config, isSSR = typeof window === "undefined") {
+    return (set, get, api) => {
+      if (!isSSR) {
+        return config(set, get, api);
+      }
+      const ssrSet = () => {
+        throw new Error("Cannot set state of Zustand store in SSR");
+      };
+      api.setState = ssrSet;
+      return config(ssrSet, get, api);
+    };
+  }
+  exports.combine = combine;
+  exports.createJSONStorage = createJSONStorage;
+  exports.devtools = devtools;
+  exports.persist = persist;
+  exports.redux = redux;
+  exports.subscribeWithSelector = subscribeWithSelector;
+  exports.unstable_ssrSafe = ssrSafe;
+});
+
+// ../../packages/core/dist/stores/routing.js
+var require_routing = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createRoutingStore = createRoutingStore;
+  var zustand_1 = require_zustand();
+  var middleware_1 = require_middleware();
+  var history_1 = require_history();
+  var initialState = {
+    waypoints: [],
+    routePath: [],
+    distanceMeters: null,
+    durationSeconds: null,
+    isOfflineRoute: false,
+    hasRoute: false,
+    elevationGain: undefined,
+    elevationLoss: undefined,
+    elevationProfile: undefined,
+    isComputingElevation: false,
+    isMapLocked: false,
+    mode: { kind: "unsaved" },
+    activity: undefined,
+    history: (0, history_1.emptyHistory)(),
+    canUndo: false,
+    canRedo: false
+  };
+  var migrateWaypoints = (coords = [], flags = []) => coords.map((coord, i) => ({ coord, type: flags[i] ? "direct" : "routed" }));
+  var migrateLegacyPersistedState = (persisted) => {
+    const { waypoints, directFlags, undoStack: _u, redoStack: _r, ...rest } = persisted;
+    return {
+      ...rest,
+      waypoints: migrateWaypoints(waypoints ?? [], directFlags ?? [])
+    };
+  };
+  var dropLegacyMetricStrings = (persisted) => {
+    const { routeDistance: _rd, routeDuration: _rdur, ...rest } = persisted;
+    return rest;
+  };
+  function createRoutingStore(logger) {
+    const persistConfig = {
+      name: "routing-store",
+      version: 3,
+      migrate: (persisted, version) => {
+        let next = persisted ?? {};
+        if (version < 1) {
+          next = migrateLegacyPersistedState(next);
+        }
+        if (version < 2) {
+          next = dropLegacyMetricStrings(next);
+        }
+        return next;
+      },
+      partialize: (state) => ({
+        waypoints: state.waypoints,
+        routePath: state.routePath,
+        distanceMeters: state.distanceMeters,
+        durationSeconds: state.durationSeconds,
+        isOfflineRoute: state.isOfflineRoute,
+        hasRoute: state.hasRoute,
+        elevationGain: state.elevationGain,
+        elevationLoss: state.elevationLoss,
+        elevationProfile: state.elevationProfile,
+        isMapLocked: state.isMapLocked,
+        mode: state.mode,
+        activity: state.activity,
+        history: state.history,
+        canUndo: state.canUndo,
+        canRedo: state.canRedo
+      })
+    };
+    return (0, zustand_1.create)()((0, middleware_1.persist)((set) => ({
+      ...initialState,
+      addWaypoint: (coord, type) => {
+        logger.info("[RoutingStore] Adding waypoint:", coord, "type:", type);
+        set((state) => ({ waypoints: [...state.waypoints, { coord, type }] }));
+      },
+      removeWaypoint: (index) => {
+        logger.info("[RoutingStore] Removing waypoint at index:", index);
+        set((state) => ({ waypoints: state.waypoints.filter((_, i) => i !== index) }));
+      },
+      setWaypoints: (waypoints) => {
+        logger.info("[RoutingStore] Setting waypoints:", waypoints.length);
+        set({ waypoints });
+      },
+      updateWaypointCoords: (coords) => {
+        logger.info("[RoutingStore] Updating waypoint coords:", coords.length);
+        set((state) => ({
+          waypoints: state.waypoints.map((wp, i) => i < coords.length ? { ...wp, coord: coords[i] } : wp)
+        }));
+      },
+      setWaypointType: (index, type) => {
+        set((state) => ({
+          waypoints: state.waypoints.map((wp, i) => i === index ? { ...wp, type } : wp)
+        }));
+      },
+      setWaypointName: (index, name) => {
+        const trimmed = name?.trim();
+        set((state) => ({
+          waypoints: state.waypoints.map((wp, i) => i === index ? { ...wp, name: trimmed && trimmed.length > 0 ? trimmed : undefined } : wp)
+        }));
+      },
+      clearWaypoints: () => {
+        logger.info("[RoutingStore] Clearing waypoints");
+        set({
+          waypoints: [],
+          routePath: [],
+          distanceMeters: null,
+          durationSeconds: null,
+          isOfflineRoute: false,
+          hasRoute: false,
+          elevationGain: undefined,
+          elevationLoss: undefined,
+          elevationProfile: undefined,
+          isComputingElevation: false,
+          mode: { kind: "unsaved" }
+        });
+      },
+      setRoutePath: (routePath) => {
+        set({ routePath });
+      },
+      clearRoutePath: () => {
+        set({ routePath: [] });
+      },
+      setRouteMetrics: ({ distanceMeters, durationSeconds, isOffline }) => {
+        set({ distanceMeters, durationSeconds, isOfflineRoute: isOffline });
+      },
+      clearRouteMetrics: () => {
+        set({ distanceMeters: null, durationSeconds: null, isOfflineRoute: false });
+      },
+      setHasRoute: (hasRoute) => {
+        set({ hasRoute });
+      },
+      setElevation: ({ gainMeters, lossMeters, profile }) => {
+        set({
+          elevationGain: gainMeters,
+          elevationLoss: lossMeters,
+          elevationProfile: profile
+        });
+      },
+      clearElevation: () => {
+        set({
+          elevationGain: undefined,
+          elevationLoss: undefined,
+          elevationProfile: undefined
+        });
+      },
+      setIsComputingElevation: (computing) => {
+        set({ isComputingElevation: computing });
+      },
+      setIsMapLocked: (isLocked) => {
+        set({ isMapLocked: isLocked });
+      },
+      setMode: (mode) => {
+        set({ mode });
+      },
+      setEditingName: (name) => {
+        const trimmed = name.trim();
+        if (!trimmed)
+          return;
+        set((state) => {
+          if (state.mode.kind !== "editing" || state.mode.name === trimmed)
+            return state;
+          return { mode: { ...state.mode, name: trimmed } };
+        });
+      },
+      setBaseline: (baseline) => {
+        set((state) => {
+          if (state.mode.kind !== "editing")
+            return state;
+          return { mode: { ...state.mode, name: baseline.name, baseline } };
+        });
+      },
+      setActivity: (activity) => {
+        set({ activity });
+      },
+      saveSnapshot: () => {
+        set((state) => {
+          const snapshot = state.waypoints.map((wp) => ({ ...wp }));
+          const nextHistory = (0, history_1.recordSnapshot)(state.history, snapshot);
+          logger.info("[RoutingStore] Saving snapshot:", snapshot.length, "waypoints");
+          return {
+            history: nextHistory,
+            canUndo: (0, history_1.canUndo)(nextHistory),
+            canRedo: (0, history_1.canRedo)(nextHistory)
+          };
+        });
+      },
+      undo: () => {
+        set((state) => {
+          const current = state.waypoints.map((wp) => ({ ...wp }));
+          const step = (0, history_1.undoStep)(state.history, current);
+          if (!step) {
+            logger.warn("[RoutingStore] No actions to undo");
+            return state;
+          }
+          logger.info("[RoutingStore] Undo:", state.waypoints.length, "->", step.previous.length, "waypoints");
+          return {
+            waypoints: step.previous,
+            history: step.history,
+            canUndo: (0, history_1.canUndo)(step.history),
+            canRedo: (0, history_1.canRedo)(step.history)
+          };
+        });
+      },
+      redo: () => {
+        set((state) => {
+          const current = state.waypoints.map((wp) => ({ ...wp }));
+          const step = (0, history_1.redoStep)(state.history, current);
+          if (!step) {
+            logger.warn("[RoutingStore] No actions to redo");
+            return state;
+          }
+          logger.info("[RoutingStore] Redo:", state.waypoints.length, "->", step.next.length, "waypoints");
+          return {
+            waypoints: step.next,
+            history: step.history,
+            canUndo: (0, history_1.canUndo)(step.history),
+            canRedo: (0, history_1.canRedo)(step.history)
+          };
+        });
+      },
+      clearHistory: () => {
+        logger.info("[RoutingStore] Clearing history");
+        set({ history: (0, history_1.emptyHistory)(), canUndo: false, canRedo: false });
+      }
+    }), persistConfig));
+  }
+});
+
+// ../../packages/core/dist/stores/index.js
+var require_stores = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_routing(), exports);
+});
+
+// ../../packages/core/dist/utils/formatting.js
+var require_formatting = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.formatFileSize = exports.formatElevation = exports.formatBearing = exports.formatCoordinate = exports.formatRouteStats = exports.formatDuration = exports.formatDistance = exports.formatDisplaySpeed = exports.fromDisplaySpeed = exports.toDisplaySpeed = exports.KMH_TO_MPH = undefined;
+  exports.KMH_TO_MPH = 0.621371;
+  var toDisplaySpeed = (kmh, units) => units === "mi" ? kmh * exports.KMH_TO_MPH : kmh;
+  exports.toDisplaySpeed = toDisplaySpeed;
+  var fromDisplaySpeed = (value, units) => units === "mi" ? value / exports.KMH_TO_MPH : value;
+  exports.fromDisplaySpeed = fromDisplaySpeed;
+  var formatDisplaySpeed = (kmh, units) => {
+    const display = (0, exports.toDisplaySpeed)(kmh, units);
+    return Number.isFinite(display) ? String(Math.round(display * 10) / 10) : "";
+  };
+  exports.formatDisplaySpeed = formatDisplaySpeed;
+  var formatDistance = (distanceKm, options = {}) => {
+    const { precision = 2, unit = "auto", showUnit = true } = options;
+    if (unit === "auto") {
+      if (distanceKm < 1) {
+        const meters = Math.round(distanceKm * 1000);
+        return showUnit ? `${meters} m` : meters.toString();
+      }
+    }
+    const formatted = distanceKm.toFixed(precision);
+    return showUnit ? `${formatted} km` : formatted;
+  };
+  exports.formatDistance = formatDistance;
+  var formatDuration = (durationMinutes, options = {}) => {
+    const { format = "auto", showUnit = true } = options;
+    if (format === "minutes" || format === "auto" && durationMinutes < 60) {
+      const minutes2 = Math.round(durationMinutes);
+      return showUnit ? `${minutes2} min` : minutes2.toString();
+    }
+    if (format === "hours" || format === "auto" && durationMinutes >= 60) {
+      const hours = Math.floor(durationMinutes / 60);
+      const minutes2 = Math.round(durationMinutes % 60);
+      if (minutes2 === 0) {
+        return showUnit ? `${hours} h` : hours.toString();
+      }
+      const decimalHours = (durationMinutes / 60).toFixed(1);
+      return showUnit ? `${decimalHours} h` : decimalHours;
+    }
+    if (format === "full") {
+      const hours = Math.floor(durationMinutes / 60);
+      const minutes2 = Math.round(durationMinutes % 60);
+      if (durationMinutes >= 60) {
+        return showUnit ? `${hours} h ${minutes2} min` : `${hours}:${minutes2.toString().padStart(2, "0")}`;
+      } else {
+        return showUnit ? `${minutes2} min` : minutes2.toString();
+      }
+    }
+    const minutes = Math.round(durationMinutes);
+    return showUnit ? `${minutes} min` : minutes.toString();
+  };
+  exports.formatDuration = formatDuration;
+  var formatRouteStats = (distanceKm, durationMinutes, options = {}) => {
+    const { separator = " • ", includeSpeed = false } = options;
+    const distance = (0, exports.formatDistance)(distanceKm);
+    const duration = (0, exports.formatDuration)(durationMinutes);
+    let result = `${distance}${separator}${duration}`;
+    if (includeSpeed && durationMinutes > 0) {
+      const speedKmh = (distanceKm / (durationMinutes / 60)).toFixed(1);
+      result += `${separator}${speedKmh} km/h`;
+    }
+    return result;
+  };
+  exports.formatRouteStats = formatRouteStats;
+  var formatCoordinate = (coordinate, precision = 6) => {
+    const [lon, lat] = coordinate;
+    return `${lat.toFixed(precision)}, ${lon.toFixed(precision)}`;
+  };
+  exports.formatCoordinate = formatCoordinate;
+  var formatBearing = (bearing, format = "degrees") => {
+    const normalizedBearing = (bearing % 360 + 360) % 360;
+    if (format === "degrees") {
+      return `${normalizedBearing.toFixed(0)}°`;
+    }
+    if (format === "cardinal") {
+      const cardinals = [
+        "N",
+        "NNE",
+        "NE",
+        "ENE",
+        "E",
+        "ESE",
+        "SE",
+        "SSE",
+        "S",
+        "SSW",
+        "SW",
+        "WSW",
+        "W",
+        "WNW",
+        "NW",
+        "NNW"
+      ];
+      const index = Math.round(normalizedBearing / 22.5) % 16;
+      return cardinals[index];
+    }
+    if (format === "both") {
+      const degrees = (0, exports.formatBearing)(bearing, "degrees");
+      const cardinal = (0, exports.formatBearing)(bearing, "cardinal");
+      return `${degrees} (${cardinal})`;
+    }
+    return normalizedBearing.toString();
+  };
+  exports.formatBearing = formatBearing;
+  var formatElevation = (elevationMeters, type = "absolute") => {
+    const rounded = Math.round(elevationMeters);
+    if (type === "gain") {
+      return `↗ ${rounded} m`;
+    }
+    if (type === "loss") {
+      return `↘ ${Math.abs(rounded)} m`;
+    }
+    return `${rounded} m`;
+  };
+  exports.formatElevation = formatElevation;
+  var formatFileSize = (bytes) => {
+    const units = ["B", "KB", "MB", "GB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    const precision = unitIndex === 0 ? 0 : 1;
+    return `${size.toFixed(precision)} ${units[unitIndex]}`;
+  };
+  exports.formatFileSize = formatFileSize;
+});
+
+// ../../packages/core/dist/utils/geospatial.js
+var require_geospatial = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.calculateBearing = exports.closestPointOnSegment = exports.estimateWalkingDuration = exports.estimateDuration = exports.isValidCoordinate = exports.pointToSegmentDistance = exports.calculatePathDistance = exports.haversineDistance = exports.EARTH_RADIUS_KM = undefined;
+  exports.EARTH_RADIUS_KM = 6371;
+  var toRadians = (degrees) => degrees * Math.PI / 180;
+  var haversineDistance = (coord1, coord2) => {
+    const [lon1, lat1] = coord1;
+    const [lon2, lat2] = coord2;
+    const dLat = toRadians(lat2 - lat1);
+    const dLon = toRadians(lon2 - lon1);
+    const lat1Rad = toRadians(lat1);
+    const lat2Rad = toRadians(lat2);
+    const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1Rad) * Math.cos(lat2Rad) * Math.sin(dLon / 2) ** 2;
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return exports.EARTH_RADIUS_KM * c;
+  };
+  exports.haversineDistance = haversineDistance;
+  var calculatePathDistance = (coordinates) => {
+    if (coordinates.length < 2)
+      return 0;
+    let totalDistance = 0;
+    for (let i = 0;i < coordinates.length - 1; i++) {
+      totalDistance += (0, exports.haversineDistance)(coordinates[i], coordinates[i + 1]);
+    }
+    return totalDistance;
+  };
+  exports.calculatePathDistance = calculatePathDistance;
+  var pointToSegmentDistance = (point, lineStart, lineEnd) => {
+    const [px, py] = point;
+    const [x1, y1] = lineStart;
+    const [x2, y2] = lineEnd;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    if (dx === 0 && dy === 0) {
+      return (0, exports.haversineDistance)(point, lineStart);
+    }
+    const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / (dx * dx + dy * dy)));
+    const closestPoint = [x1 + t * dx, y1 + t * dy];
+    return (0, exports.haversineDistance)(point, closestPoint);
+  };
+  exports.pointToSegmentDistance = pointToSegmentDistance;
+  var isValidCoordinate = (coordinate) => {
+    const [lon, lat] = coordinate;
+    return typeof lon === "number" && typeof lat === "number" && lon >= -180 && lon <= 180 && lat >= -90 && lat <= 90 && !Number.isNaN(lon) && !Number.isNaN(lat);
+  };
+  exports.isValidCoordinate = isValidCoordinate;
+  var estimateDuration = (distanceKm, speedKmh) => {
+    if (speedKmh <= 0)
+      return 0;
+    return Math.round(distanceKm / speedKmh * 60);
+  };
+  exports.estimateDuration = estimateDuration;
+  var estimateWalkingDuration = (distanceKm) => (0, exports.estimateDuration)(distanceKm, 5);
+  exports.estimateWalkingDuration = estimateWalkingDuration;
+  var closestPointOnSegment = (p, v, w) => {
+    const l2 = (v[0] - w[0]) ** 2 + (v[1] - w[1]) ** 2;
+    if (l2 === 0)
+      return v;
+    let t = ((p[0] - v[0]) * (w[0] - v[0]) + (p[1] - v[1]) * (w[1] - v[1])) / l2;
+    t = Math.max(0, Math.min(1, t));
+    return [v[0] + t * (w[0] - v[0]), v[1] + t * (w[1] - v[1])];
+  };
+  exports.closestPointOnSegment = closestPointOnSegment;
+  var calculateBearing = (coord1, coord2) => {
+    const [lon1, lat1] = coord1;
+    const [lon2, lat2] = coord2;
+    const lat1Rad = toRadians(lat1);
+    const lat2Rad = toRadians(lat2);
+    const dLon = toRadians(lon2 - lon1);
+    const x = Math.sin(dLon) * Math.cos(lat2Rad);
+    const y = Math.cos(lat1Rad) * Math.sin(lat2Rad) - Math.sin(lat1Rad) * Math.cos(lat2Rad) * Math.cos(dLon);
+    const bearing = Math.atan2(x, y);
+    return (bearing * 180 / Math.PI + 360) % 360;
+  };
+  exports.calculateBearing = calculateBearing;
+});
+
+// ../../packages/core/dist/utils/routeGeneration.js
+var require_routeGeneration = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DEFAULT_SMART_WAYPOINT_THRESHOLDS = undefined;
+  exports.selectSmartWaypoints = selectSmartWaypoints;
+  var geospatial_1 = require_geospatial();
+  exports.DEFAULT_SMART_WAYPOINT_THRESHOLDS = {
+    directionChangeThresholdDeg: 30,
+    maxDistanceIntervalKm: 2,
+    minDistanceBetweenWaypointsKm: 0.1,
+    maxWaypoints: 15
+  };
+  function calculateBearing(a, b) {
+    const lat1 = a[1] * Math.PI / 180;
+    const lat2 = b[1] * Math.PI / 180;
+    const deltaLon = (b[0] - a[0]) * Math.PI / 180;
+    const y = Math.sin(deltaLon) * Math.cos(lat2);
+    const x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(deltaLon);
+    const bearing = Math.atan2(y, x) * 180 / Math.PI;
+    return (bearing + 360) % 360;
+  }
+  function angleDifference(a, b) {
+    let diff = Math.abs(a - b);
+    if (diff > 180)
+      diff = 360 - diff;
+    return diff;
+  }
+  function reduceToCap(waypoints, cap) {
+    if (waypoints.length <= cap)
+      return waypoints;
+    const reduced = [waypoints[0]];
+    const middleSlots = cap - 2;
+    const step = Math.max(1, Math.floor((waypoints.length - 2) / middleSlots));
+    for (let i = step;i < waypoints.length - 1; i += step) {
+      if (reduced.length < cap - 1)
+        reduced.push(waypoints[i]);
+    }
+    reduced.push(waypoints[waypoints.length - 1]);
+    return reduced;
+  }
+  function selectSmartWaypoints(trackPoints, thresholds = exports.DEFAULT_SMART_WAYPOINT_THRESHOLDS) {
+    if (trackPoints.length < 2)
+      return [...trackPoints];
+    const waypoints = [trackPoints[0]];
+    let lastWaypointIndex = 0;
+    let cumulativeDistance = 0;
+    for (let i = 1;i < trackPoints.length - 1; i++) {
+      const currentPoint = trackPoints[i];
+      const prevPoint = trackPoints[i - 1];
+      const lastWaypoint = trackPoints[lastWaypointIndex];
+      const distanceFromLastWaypoint = (0, geospatial_1.haversineDistance)(lastWaypoint, currentPoint);
+      const segmentDistance = (0, geospatial_1.haversineDistance)(prevPoint, currentPoint);
+      cumulativeDistance += segmentDistance;
+      if (distanceFromLastWaypoint < thresholds.minDistanceBetweenWaypointsKm)
+        continue;
+      let shouldAdd = false;
+      if (i >= 2 && i < trackPoints.length - 2) {
+        const windowSize = Math.min(3, Math.floor(trackPoints.length / 20));
+        const beforeIndex = Math.max(0, i - windowSize);
+        const afterIndex = Math.min(trackPoints.length - 1, i + windowSize);
+        const bearingBefore = calculateBearing(trackPoints[beforeIndex], currentPoint);
+        const bearingAfter = calculateBearing(currentPoint, trackPoints[afterIndex]);
+        if (angleDifference(bearingBefore, bearingAfter) >= thresholds.directionChangeThresholdDeg) {
+          shouldAdd = true;
+        }
+      }
+      if (cumulativeDistance >= thresholds.maxDistanceIntervalKm) {
+        shouldAdd = true;
+        cumulativeDistance = 0;
+      }
+      if (shouldAdd) {
+        waypoints.push(currentPoint);
+        lastWaypointIndex = i;
+      }
+    }
+    const last = trackPoints[trackPoints.length - 1];
+    const distanceToEnd = (0, geospatial_1.haversineDistance)(waypoints[waypoints.length - 1], last);
+    if (distanceToEnd >= thresholds.minDistanceBetweenWaypointsKm) {
+      waypoints.push(last);
+    }
+    return reduceToCap(waypoints, thresholds.maxWaypoints);
+  }
+});
+
+// ../../packages/core/dist/utils/index.js
+var require_utils = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_formatting(), exports);
+  __exportStar(require_geospatial(), exports);
+  __exportStar(require_routeGeneration(), exports);
+});
+
+// ../../packages/core/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_errors(), exports);
+  __exportStar(require_history(), exports);
+  __exportStar(require_user_preferences(), exports);
+  __exportStar(require_stores(), exports);
+  __exportStar(require_types(), exports);
+  __exportStar(require_utils(), exports);
+});
+
+// src/output.ts
+var exports_output = {};
+__export(exports_output, {
+  renderResult: () => renderResult,
+  renderError: () => renderError,
+  cliErrorFromDomain: () => cliErrorFromDomain,
+  EXIT_CODES: () => EXIT_CODES,
+  CliError: () => CliError
+});
+function cliErrorFromDomain(payload) {
+  return new CliError(payload.message, EXIT_CODES[payload.code], payload);
+}
+function renderResult(options, data, humanRenderer) {
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+    return;
+  }
+  const rendered = humanRenderer(data);
+  if (rendered.length > 0) {
+    process.stdout.write(`${rendered}
+`);
+  }
+}
+function renderError(options, error) {
+  if (error instanceof CliError) {
+    if (options.json) {
+      const body = error.payload ?? { exitCode: error.exitCode, message: error.message };
+      process.stderr.write(`${JSON.stringify(body, null, 2)}
+`);
+    } else {
+      process.stderr.write(`error: ${error.message}
+`);
+    }
+    return error.exitCode;
+  }
+  if (import_core.isDomainErrorPayload(error)) {
+    if (options.json) {
+      process.stderr.write(`${JSON.stringify(error, null, 2)}
+`);
+    } else {
+      process.stderr.write(`error: ${error.message}
+`);
+    }
+    return EXIT_CODES[error.code];
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (options.json) {
+    process.stderr.write(`${JSON.stringify({ exitCode: EXIT_CODES.GENERIC, message }, null, 2)}
+`);
+  } else {
+    process.stderr.write(`error: ${message}
+`);
+  }
+  return EXIT_CODES.GENERIC;
+}
+var import_core, EXIT_CODES, CliError;
+var init_output = __esm(() => {
+  import_core = __toESM(require_dist(), 1);
+  EXIT_CODES = {
+    GENERIC: 1,
+    USAGE: 2,
+    VALIDATION_FAILED: 3,
+    NOT_FOUND: 4,
+    UNAUTHORIZED: 5,
+    FORBIDDEN: 6,
+    CONFLICT: 7,
+    RATE_LIMITED: 8,
+    PRECONDITION_REQUIRED: 9,
+    NETWORK: 10,
+    INTERNAL: 11
+  };
+  CliError = class CliError extends Error {
+    exitCode;
+    payload;
+    constructor(message, exitCode, payload) {
+      super(message);
+      this.exitCode = exitCode;
+      this.payload = payload;
+      this.name = "CliError";
+    }
+  };
+});
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../../node_modules/.bun/commander@13.1.0/node_modules/commander/esm.mjs
+var import__ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
+
+// src/client.ts
+init_output();
+var import_core2 = __toESM(require_dist(), 1);
+async function request(client, path, options = {}) {
+  const url = new URL(path.startsWith("/") ? path.slice(1) : path, `${client.apiUrl.replace(/\/$/, "")}/`);
+  const headers = {
+    Accept: "application/json"
+  };
+  if (client.token) {
+    headers.Authorization = `Bearer ${client.token}`;
+  }
+  if (options.body !== undefined) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (options.confirm) {
+    headers["X-Routess-Confirm"] = "true";
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body !== undefined ? JSON.stringify(options.body) : undefined
+    });
+  } catch (cause) {
+    throw new CliError(`Network error reaching ${url.origin}: ${cause instanceof Error ? cause.message : String(cause)}`, EXIT_CODES.NETWORK);
+  }
+  if (response.status === 204) {
+    return;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  const payload = contentType.includes("application/json") ? await response.json() : undefined;
+  if (!response.ok) {
+    if (import_core2.isDomainErrorPayload(payload)) {
+      throw new CliError(payload.message, EXIT_CODES[payload.code], payload);
+    }
+    throw new CliError(`Request failed: ${response.status} ${response.statusText}`, response.status === 401 ? EXIT_CODES.UNAUTHORIZED : EXIT_CODES.GENERIC);
+  }
+  return payload;
+}
+
+// src/config.ts
+init_output();
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  const base = xdg && xdg.length > 0 ? xdg : join(homedir(), ".config");
+  return join(base, "routess");
+}
+function authFilePath() {
+  return join(configDir(), "auth.json");
+}
+function readPersisted() {
+  const path = authFilePath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function loadConfig() {
+  const envToken = process.env.ROUTESS_TOKEN?.trim();
+  const envApiUrl = process.env.ROUTESS_API_URL?.trim();
+  const persisted = readPersisted();
+  const apiUrl = envApiUrl || persisted.apiUrl || "https://routess-api.robbeverhelst.com";
+  if (envToken && envToken.length > 0) {
+    return { apiUrl, token: envToken, tokenSource: "env" };
+  }
+  if (persisted.token && persisted.token.length > 0) {
+    return { apiUrl, token: persisted.token, tokenSource: "file" };
+  }
+  return { apiUrl, token: null, tokenSource: "none" };
+}
+function saveToken(token, apiUrl) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true });
+  const path = authFilePath();
+  const existing = readPersisted();
+  const payload = {
+    ...existing,
+    token,
+    ...apiUrl ? { apiUrl } : {}
+  };
+  writeFileSync(path, `${JSON.stringify(payload, null, 2)}
+`, { encoding: "utf8" });
+  try {
+    chmodSync(path, 384);
+  } catch {}
+}
+function clearToken() {
+  const path = authFilePath();
+  if (!existsSync(path)) {
+    return false;
+  }
+  rmSync(path);
+  const dir = configDir();
+  try {
+    rmSync(dir, { recursive: false });
+  } catch {}
+  return true;
+}
+function configFileLocation() {
+  return authFilePath();
+}
+function requireToken(config) {
+  if (!config.token) {
+    throw new CliError("Not signed in. Run `routess auth login --token <pat>` after minting a token in the web app Settings → API Tokens.", EXIT_CODES.UNAUTHORIZED);
+  }
+  return config.token;
+}
+
+// src/commands/auth.ts
+init_output();
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Authentication: log in with a personal access token, log out, identify the current session.");
+  auth.command("login").description("Store a personal access token for subsequent commands. Mint a token at the web app's Settings → API Tokens page first.").requiredOption("--token <pat>", "the routess_pat_… token copied from the web Settings page").option("--api-url <url>", "API base URL to associate with this token (otherwise the existing value or the default is kept)").action(async (options) => {
+    await runWithProgram(program2, async (runOptions) => {
+      if (!options.token?.startsWith("routess_pat_")) {
+        throw new CliError("Token must start with routess_pat_", EXIT_CODES.USAGE);
+      }
+      const config = { ...loadConfig(), token: options.token, apiUrl: options.apiUrl ?? loadConfig().apiUrl };
+      let me;
+      try {
+        me = await request(config, "/api/v1/users/me");
+      } catch (error) {
+        if (error instanceof CliError && error.exitCode === EXIT_CODES.UNAUTHORIZED) {
+          throw new CliError("Token was rejected by the API. Confirm it was copied in full and that the API URL is correct.", EXIT_CODES.UNAUTHORIZED);
+        }
+        throw error;
+      }
+      saveToken(options.token, options.apiUrl);
+      renderResult(runOptions, { user: me, location: configFileLocation() }, (data) => {
+        return `Signed in as ${data.user.email}. Token saved to ${data.location}.`;
+      });
+    });
+  });
+  auth.command("logout").description("Forget the stored token. The token itself remains valid on the server until revoked from the web Settings page.").action(async () => {
+    await runWithProgram(program2, async (runOptions) => {
+      const removed = clearToken();
+      renderResult(runOptions, { removed, location: configFileLocation() }, (data) => data.removed ? `Token removed (${data.location}).` : "No stored token to remove.");
+    });
+  });
+  auth.command("whoami").description("Show the user identity associated with the currently active token.").action(async () => {
+    await runWithProgram(program2, async (runOptions) => {
+      const config = loadConfig();
+      requireToken(config);
+      const me = await request(config, "/api/v1/users/me");
+      renderResult(runOptions, me, (data) => `${data.email}  (id=${data.id}, name=${data.name})`);
+    });
+  });
+}
+async function runWithProgram(program2, action) {
+  const opts = program2.opts();
+  const runOptions = { json: Boolean(opts.json) };
+  try {
+    await action(runOptions);
+  } catch (error) {
+    const { renderError: renderError2 } = await Promise.resolve().then(() => (init_output(), exports_output));
+    const code = renderError2(runOptions, error);
+    process.exit(code);
+  }
+}
+
+// src/commands/routes.ts
+init_output();
+function formatRouteRow(route) {
+  const distanceKm = route.distance ? `${(route.distance / 1000).toFixed(1)}km` : "—";
+  const activity = route.activity ?? "—";
+  return `${route.id}	${route.name}	${activity}	${route.visibility}	${distanceKm}`;
+}
+function registerRoutesCommands(program2) {
+  const routes = program2.command("routes").description("List, inspect, and edit metadata of saved routes.");
+  routes.command("list").description("List the authenticated user's routes.").action(async () => {
+    await runWithProgram2(program2, async (runOptions) => {
+      const config = loadConfig();
+      requireToken(config);
+      const items = await request(config, "/api/v1/routes");
+      renderResult(runOptions, items, (data) => {
+        if (data.length === 0) {
+          return "No routes.";
+        }
+        const header = "id\tname\tactivity\tprivacy\tdistance";
+        const body = data.map(formatRouteRow).join(`
+`);
+        return `${header}
+${body}`;
+      });
+    });
+  });
+  routes.command("get <id>").description("Fetch a single route by id.").action(async (id) => {
+    await runWithProgram2(program2, async (runOptions) => {
+      const config = loadConfig();
+      requireToken(config);
+      const numericId = parseId(id);
+      const route = await request(config, `/api/v1/routes/${numericId}`);
+      renderResult(runOptions, route, (data) => {
+        const distanceKm = data.distance ? `${(data.distance / 1000).toFixed(2)} km` : "n/a";
+        const lines = [
+          `Route ${data.id}: ${data.name}`,
+          `  activity  : ${data.activity ?? "n/a"}`,
+          `  visibility: ${data.visibility}`,
+          `  distance  : ${distanceKm}`,
+          `  tags      : ${data.tags.join(", ") || "(none)"}`,
+          `  created   : ${data.createdAt}`,
+          `  updated   : ${data.updatedAt}`
+        ];
+        return lines.join(`
+`);
+      });
+    });
+  });
+  routes.command("update <id>").description("Update metadata on a route (name / activity / visibility). Body fields are optional but at least one is required.").option("--name <name>", "rename the route").option("--activity <activity>", "set the activity (e.g. run, cycle, walk)").option("--visibility <visibility>", "set the visibility: private | unlisted | public").option("--confirm", "set X-Routess-Confirm: true (required when --visibility is public)").action(async (id, options) => {
+    await runWithProgram2(program2, async (runOptions) => {
+      const config = loadConfig();
+      requireToken(config);
+      const body = {};
+      if (options.name !== undefined)
+        body.name = options.name;
+      if (options.activity !== undefined)
+        body.activity = options.activity;
+      if (options.visibility !== undefined)
+        body.visibility = options.visibility;
+      if (Object.keys(body).length === 0) {
+        throw new CliError("At least one of --name, --activity, --visibility is required.", EXIT_CODES.USAGE);
+      }
+      const numericId = parseId(id);
+      const route = await request(config, `/api/v1/routes/${numericId}`, {
+        method: "PATCH",
+        body,
+        confirm: options.confirm
+      });
+      renderResult(runOptions, route, (data) => `Updated route ${data.id}: ${data.name} (${data.visibility}).`);
+    });
+  });
+  routes.command("delete <id>").description("Delete a route. PAT callers must pass --confirm.").option("--confirm", "set X-Routess-Confirm: true").action(async (id, options) => {
+    await runWithProgram2(program2, async (runOptions) => {
+      const config = loadConfig();
+      requireToken(config);
+      const numericId = parseId(id);
+      const result = await request(config, `/api/v1/routes/${numericId}`, {
+        method: "DELETE",
+        confirm: options.confirm
+      });
+      renderResult(runOptions, result, (data) => data.message);
+    });
+  });
+}
+function parseId(id) {
+  const numeric = Number(id);
+  if (!Number.isFinite(numeric) || !Number.isInteger(numeric) || numeric <= 0) {
+    throw new CliError(`Invalid route id: ${id}`, EXIT_CODES.USAGE);
+  }
+  return numeric;
+}
+async function runWithProgram2(program2, action) {
+  const opts = program2.opts();
+  const runOptions = { json: Boolean(opts.json) };
+  try {
+    await action(runOptions);
+  } catch (error) {
+    const { renderError: renderError2 } = await Promise.resolve().then(() => (init_output(), exports_output));
+    const code = renderError2(runOptions, error);
+    process.exit(code);
+  }
+}
+
+// src/index.ts
+init_output();
+var program2 = new Command;
+var packageJsonPath = join2(dirname(fileURLToPath(import.meta.url)), "../package.json");
+var packageVersion = JSON.parse(readFileSync2(packageJsonPath, "utf8")).version;
+program2.name("routess").description("Routess command-line interface. See `routess auth login --help` to get started.").version(packageVersion).option("--json", "emit machine-readable JSON to stdout, errors as DomainErrorPayload to stderr", false).option("--api-url <url>", "override the API base URL (defaults to ROUTESS_API_URL env var or production)");
+async function runCommand(action) {
+  const options = program2.opts();
+  const runOptions = { json: Boolean(options.json) };
+  try {
+    await action(runOptions);
+  } catch (error) {
+    const code = renderError(runOptions, error);
+    process.exit(code);
+  }
+}
+registerAuthCommands(program2);
+registerRoutesCommands(program2);
+program2.parseAsync(process.argv).catch((error) => {
+  const options = program2.opts();
+  const code = renderError({ json: Boolean(options.json) }, error);
+  process.exit(code);
+});
+export {
+  runCommand
+};