@vibedeckx/linux-x64 0.1.11 → 0.1.15

package/node_modules/@stricli/core/dist/index.js

@@ -0,0 +1,2237 @@
+// src/context.ts
+function checkEnvironmentVariable(process, varName) {
+  const value = process.env?.[varName];
+  return typeof value === "string" && value !== "0";
+}
+
+// src/exit-code.ts
+var ExitCode = {
+  /**
+   * Unable to find a command in the application with the given command line arguments.
+   */
+  UnknownCommand: -5,
+  /**
+   * Unable to parse the specified arguments.
+   */
+  InvalidArgument: -4,
+  /**
+   * An error was thrown while loading the context for a command run.
+   */
+  ContextLoadError: -3,
+  /**
+   * Failed to load command module.
+   */
+  CommandLoadError: -2,
+  /**
+   * An unexpected error was thrown by or not caught by this library.
+   */
+  InternalError: -1,
+  /**
+   * Command executed successfully.
+   */
+  Success: 0,
+  /**
+   * Command module unexpectedly threw an error.
+   */
+  CommandRunError: 1
+};
+
+// src/util/case-style.ts
+function convertKebabCaseToCamelCase(str) {
+  return str.replace(/-./g, (match) => match[1].toUpperCase());
+}
+function convertCamelCaseToKebabCase(name) {
+  return Array.from(name).map((char, i) => {
+    const upper = char.toUpperCase();
+    const lower = char.toLowerCase();
+    if (i === 0 || upper !== char || upper === lower) {
+      return char;
+    }
+    return `-${lower}`;
+  }).join("");
+}
+
+// src/util/distance.ts
+function newSparseMatrix(defaultValue) {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    get: (...args) => {
+      return values.get(args.join(",")) ?? defaultValue;
+    },
+    set: (value, ...args) => {
+      values.set(args.join(","), value);
+    }
+    // toString([iMin, iMax], [jMin, jMax]) {
+    //   const rows: string[] = [];
+    //   for (let i = iMin; i <= iMax; ++i) {
+    //     const row: string[] = [];
+    //     for (let j = jMin; j <= jMax; ++j) {
+    //       row.push(this.get(i, j).toString());
+    //     }
+    //     rows.push(row.join(", "));
+    //   }
+    //   return rows.join("\n");
+    // },
+  };
+}
+function damerauLevenshtein(a, b, options) {
+  const { threshold, weights } = options;
+  if (a === b) {
+    return 0;
+  }
+  const lengthDiff = Math.abs(a.length - b.length);
+  if (typeof threshold === "number" && lengthDiff > threshold) {
+    return Infinity;
+  }
+  const matrix = newSparseMatrix(Infinity);
+  matrix.set(0, -1, -1);
+  for (let j = 0; j < b.length; ++j) {
+    matrix.set((j + 1) * weights.insertion, -1, j);
+  }
+  for (let i = 0; i < a.length; ++i) {
+    matrix.set((i + 1) * weights.deletion, i, -1);
+  }
+  let prevRowMinDistance = -Infinity;
+  for (let i = 0; i < a.length; ++i) {
+    let rowMinDistance = Infinity;
+    for (let j = 0; j <= b.length - 1; ++j) {
+      const cost = a[i] === b[j] ? 0 : 1;
+      const distances = [
+        // deletion
+        matrix.get(i - 1, j) + weights.deletion,
+        // insertion
+        matrix.get(i, j - 1) + weights.insertion,
+        // substitution
+        matrix.get(i - 1, j - 1) + cost * weights.substitution
+      ];
+      if (a[i] === b[j - 1] && a[i - 1] === b[j]) {
+        distances.push(matrix.get(i - 2, j - 2) + cost * weights.transposition);
+      }
+      const minDistance = Math.min(...distances);
+      matrix.set(minDistance, i, j);
+      if (minDistance < rowMinDistance) {
+        rowMinDistance = minDistance;
+      }
+    }
+    if (rowMinDistance > threshold) {
+      if (prevRowMinDistance > threshold) {
+        return Infinity;
+      }
+      prevRowMinDistance = rowMinDistance;
+    } else {
+      prevRowMinDistance = -Infinity;
+    }
+  }
+  const distance = matrix.get(a.length - 1, b.length - 1);
+  if (distance > threshold) {
+    return Infinity;
+  }
+  return distance;
+}
+function compareAlternatives(a, b, target) {
+  const cmp = a[1] - b[1];
+  if (cmp !== 0) {
+    return cmp;
+  }
+  const aStartsWith = a[0].startsWith(target);
+  const bStartsWith = b[0].startsWith(target);
+  if (aStartsWith && !bStartsWith) {
+    return -1;
+  } else if (!aStartsWith && bStartsWith) {
+    return 1;
+  }
+  return a[0].localeCompare(b[0]);
+}
+function filterClosestAlternatives(target, alternatives, options) {
+  const validAlternatives = alternatives.map((alt) => [alt, damerauLevenshtein(target, alt, options)]).filter(([, dist]) => dist <= options.threshold);
+  const minDistance = Math.min(...validAlternatives.map(([, dist]) => dist));
+  return validAlternatives.filter(([, dist]) => dist === minDistance).sort((a, b) => compareAlternatives(a, b, target)).map(([alt]) => alt);
+}
+
+// src/util/error.ts
+var InternalError = class extends Error {
+};
+function formatException(exc) {
+  if (exc instanceof Error) {
+    return exc.stack ?? String(exc);
+  }
+  return String(exc);
+}
+
+// src/util/formatting.ts
+function maximum(arr1, arr2) {
+  const maxValues = [];
+  const maxLength = Math.max(arr1.length, arr2.length);
+  for (let i = 0; i < maxLength; ++i) {
+    maxValues[i] = Math.max(arr1[i], arr2[i]);
+  }
+  return maxValues;
+}
+function formatRowsWithColumns(cells, separators) {
+  if (cells.length === 0) {
+    return [];
+  }
+  const startingLengths = Array(Math.max(...cells.map((cellRow) => cellRow.length))).fill(0, 0);
+  const maxLengths = cells.reduce((acc, cellRow) => {
+    const lengths = cellRow.map((cell) => cell.length);
+    return maximum(acc, lengths);
+  }, startingLengths);
+  return cells.map((cellRow) => {
+    const firstCell = (cellRow[0] ?? "").padEnd(maxLengths[0]);
+    return cellRow.slice(1).reduce(
+      (parts, str, i, arr) => {
+        const paddedStr = arr.length === i + 1 ? str : str.padEnd(maxLengths[i + 1]);
+        return [...parts, separators?.[i] ?? " ", paddedStr];
+      },
+      [firstCell]
+    ).join("").trimEnd();
+  });
+}
+function joinWithGrammar(parts, grammar) {
+  if (parts.length <= 1) {
+    return parts[0] ?? "";
+  }
+  if (parts.length === 2) {
+    return parts.join(` ${grammar.conjunction} `);
+  }
+  let allButLast = parts.slice(0, parts.length - 1).join(", ");
+  if (grammar.serialComma) {
+    allButLast += ",";
+  }
+  return [allButLast, grammar.conjunction, parts[parts.length - 1]].join(" ");
+}
+
+// src/util/array.ts
+function group(array, callback) {
+  return array.reduce((groupings, item) => {
+    const key = callback(item);
+    const groupItems = groupings[key] ?? [];
+    groupItems.push(item);
+    groupings[key] = groupItems;
+    return groupings;
+  }, {});
+}
+function groupBy(array, selector) {
+  return group(array, (item) => item[selector]);
+}
+
+// src/util/promise.ts
+async function allSettledOrElse(values) {
+  const results = await Promise.allSettled(values);
+  const grouped = groupBy(results, "status");
+  if (grouped.rejected && grouped.rejected.length > 0) {
+    return { status: "rejected", reasons: grouped.rejected.map((result) => result.reason) };
+  }
+  return { status: "fulfilled", value: grouped.fulfilled?.map((result) => result.value) ?? [] };
+}
+
+// src/parameter/parser/boolean.ts
+var booleanParser = (input) => {
+  switch (input.toLowerCase()) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+  }
+  throw new SyntaxError(`Cannot convert ${input} to a boolean`);
+};
+var TRUTHY_VALUES = /* @__PURE__ */ new Set(["true", "t", "yes", "y", "on", "1"]);
+var FALSY_VALUES = /* @__PURE__ */ new Set(["false", "f", "no", "n", "off", "0"]);
+var looseBooleanParser = (input) => {
+  const value = input.toLowerCase();
+  if (TRUTHY_VALUES.has(value)) {
+    return true;
+  }
+  if (FALSY_VALUES.has(value)) {
+    return false;
+  }
+  throw new SyntaxError(`Cannot convert ${input} to a boolean`);
+};
+
+// src/parameter/parser/number.ts
+var numberParser = (input) => {
+  const value = Number(input);
+  if (Number.isNaN(value)) {
+    throw new SyntaxError(`Cannot convert ${input} to a number`);
+  }
+  return value;
+};
+
+// src/parameter/scanner.ts
+var ArgumentScannerError = class extends InternalError {
+  _brand;
+};
+function formatMessageForArgumentScannerError(error, formatter) {
+  const errorType = error.constructor.name;
+  const formatError = formatter[errorType];
+  if (formatError) {
+    return formatError(error);
+  }
+  return error.message;
+}
+function resolveAliases(flags, aliases, scannerCaseStyle) {
+  return Object.fromEntries(
+    Object.entries(aliases).map(([alias, internalFlagName_]) => {
+      const internalFlagName = internalFlagName_;
+      const flag = flags[internalFlagName];
+      if (!flag) {
+        const externalFlagName = asExternal(internalFlagName, scannerCaseStyle);
+        throw new FlagNotFoundError(externalFlagName, [], alias);
+      }
+      return [alias, [internalFlagName, flag]];
+    })
+  );
+}
+var FlagNotFoundError = class extends ArgumentScannerError {
+  /**
+   * Command line input that triggered this error.
+   */
+  input;
+  /**
+   * Set of proposed suggestions that are similar to the input.
+   */
+  corrections;
+  /**
+   * Set if error was caused indirectly by an alias.
+   * This indicates that something is wrong with the command configuration itself.
+   */
+  aliasName;
+  constructor(input, corrections, aliasName) {
+    let message = `No flag registered for --${input}`;
+    if (aliasName) {
+      message += ` (aliased from -${aliasName})`;
+    } else if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(
+        corrections.map((correction) => `--${correction}`),
+        {
+          kind: "conjunctive",
+          conjunction: "or",
+          serialComma: true
+        }
+      );
+      message += `, did you mean ${formattedCorrections}?`;
+    }
+    super(message);
+    this.input = input;
+    this.corrections = corrections;
+    this.aliasName = aliasName;
+  }
+};
+var AliasNotFoundError = class extends ArgumentScannerError {
+  /**
+   * Command line input that triggered this error.
+   */
+  input;
+  constructor(input) {
+    super(`No alias registered for -${input}`);
+    this.input = input;
+  }
+};
+function getPlaceholder(param, index) {
+  if (param.placeholder) {
+    return param.placeholder;
+  }
+  return typeof index === "number" ? `arg${index}` : "args";
+}
+function asExternal(internal, scannerCaseStyle) {
+  return scannerCaseStyle === "allow-kebab-for-camel" ? convertCamelCaseToKebabCase(internal) : internal;
+}
+var ArgumentParseError = class extends ArgumentScannerError {
+  /**
+   * External name of flag or placeholder for positional argument that was parsing this input.
+   */
+  externalFlagNameOrPlaceholder;
+  /**
+   * Command line input that triggered this error.
+   */
+  input;
+  /**
+   * Raw exception thrown from parse function.
+   */
+  exception;
+  constructor(externalFlagNameOrPlaceholder, input, exception) {
+    super(
+      `Failed to parse "${input}" for ${externalFlagNameOrPlaceholder}: ${exception instanceof Error ? exception.message : String(exception)}`
+    );
+    this.externalFlagNameOrPlaceholder = externalFlagNameOrPlaceholder;
+    this.input = input;
+    this.exception = exception;
+  }
+};
+function parseInput(externalFlagNameOrPlaceholder, parameter, input, context) {
+  try {
+    return parameter.parse.call(context, input);
+  } catch (exc) {
+    throw new ArgumentParseError(externalFlagNameOrPlaceholder, input, exc);
+  }
+}
+var EnumValidationError = class extends ArgumentScannerError {
+  /**
+   * External name of flag that was parsing this input.
+   */
+  externalFlagName;
+  /**
+   * Command line input that triggered this error.
+   */
+  input;
+  /**
+   * All possible enum values.
+   */
+  values;
+  constructor(externalFlagName, input, values, corrections) {
+    let message = `Expected "${input}" to be one of (${values.join("|")})`;
+    if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(
+        corrections.map((str) => `"${str}"`),
+        {
+          kind: "conjunctive",
+          conjunction: "or",
+          serialComma: true
+        }
+      );
+      message += `, did you mean ${formattedCorrections}?`;
+    }
+    super(message);
+    this.externalFlagName = externalFlagName;
+    this.input = input;
+    this.values = values;
+  }
+};
+var UnsatisfiedFlagError = class extends ArgumentScannerError {
+  /**
+   * External name of flag that was active when this error was thrown.
+   */
+  externalFlagName;
+  /**
+   * External name of flag that interrupted the original flag.
+   */
+  nextFlagName;
+  constructor(externalFlagName, nextFlagName) {
+    let message = `Expected input for flag --${externalFlagName}`;
+    if (nextFlagName) {
+      message += ` but encountered --${nextFlagName} instead`;
+    }
+    super(message);
+    this.externalFlagName = externalFlagName;
+    this.nextFlagName = nextFlagName;
+  }
+};
+var UnexpectedPositionalError = class extends ArgumentScannerError {
+  /**
+   * Expected (maximum) count of positional arguments.
+   */
+  expectedCount;
+  /**
+   * Command line input that triggered this error.
+   */
+  input;
+  constructor(expectedCount, input) {
+    super(`Too many arguments, expected ${expectedCount} but encountered "${input}"`);
+    this.expectedCount = expectedCount;
+    this.input = input;
+  }
+};
+var UnsatisfiedPositionalError = class extends ArgumentScannerError {
+  /**
+   * Placeholder for positional argument that was active when this error was thrown.
+   */
+  placeholder;
+  /**
+   * If specified, indicates the minimum number of arguments that are expected and the last argument count.
+   */
+  limit;
+  constructor(placeholder, limit) {
+    let message;
+    if (limit) {
+      message = `Expected at least ${limit[0]} argument(s) for ${placeholder}`;
+      if (limit[1] === 0) {
+        message += " but found none";
+      } else {
+        message += ` but only found ${limit[1]}`;
+      }
+    } else {
+      message = `Expected argument for ${placeholder}`;
+    }
+    super(message);
+    this.placeholder = placeholder;
+    this.limit = limit;
+  }
+};
+function undoNegation(flagName) {
+  if (flagName.startsWith("no") && flagName.length > 2) {
+    if (flagName[2] === "-") {
+      return flagName.slice(4);
+    }
+    const firstChar = flagName[2];
+    const firstUpper = firstChar.toUpperCase();
+    if (firstChar !== firstUpper) {
+      return;
+    }
+    const firstLower = firstChar.toLowerCase();
+    return firstLower + flagName.slice(3);
+  }
+}
+function findInternalFlagMatch(externalFlagName, flags, config) {
+  const internalFlagName = externalFlagName;
+  let flag = flags[internalFlagName];
+  let foundFlagWithNegatedFalse;
+  let foundFlagWithNegatedFalseFromKebabConversion = false;
+  if (!flag) {
+    const internalWithoutNegation = undoNegation(internalFlagName);
+    if (internalWithoutNegation) {
+      flag = flags[internalWithoutNegation];
+      if (flag && flag.kind == "boolean") {
+        if (flag.withNegated !== false) {
+          return { namedFlag: [internalWithoutNegation, flag], negated: true };
+        } else {
+          foundFlagWithNegatedFalse = internalWithoutNegation;
+          flag = void 0;
+        }
+      }
+    }
+  }
+  const camelCaseFlagName = convertKebabCaseToCamelCase(externalFlagName);
+  if (config.caseStyle === "allow-kebab-for-camel" && !flag) {
+    flag = flags[camelCaseFlagName];
+    if (flag) {
+      return { namedFlag: [camelCaseFlagName, flag] };
+    }
+    const camelCaseWithoutNegation = undoNegation(camelCaseFlagName);
+    if (camelCaseWithoutNegation) {
+      flag = flags[camelCaseWithoutNegation];
+      if (flag && flag.kind == "boolean") {
+        if (flag.withNegated !== false) {
+          return { namedFlag: [camelCaseWithoutNegation, flag], negated: true };
+        } else {
+          foundFlagWithNegatedFalse = camelCaseWithoutNegation;
+          foundFlagWithNegatedFalseFromKebabConversion = true;
+          flag = void 0;
+        }
+      }
+    }
+  }
+  if (!flag) {
+    if (foundFlagWithNegatedFalse) {
+      let correction = foundFlagWithNegatedFalse;
+      if (foundFlagWithNegatedFalseFromKebabConversion && externalFlagName.includes("-")) {
+        correction = convertCamelCaseToKebabCase(foundFlagWithNegatedFalse);
+      }
+      throw new FlagNotFoundError(externalFlagName, [correction]);
+    }
+    if (camelCaseFlagName in flags) {
+      throw new FlagNotFoundError(externalFlagName, [camelCaseFlagName]);
+    }
+    const kebabCaseFlagName = convertCamelCaseToKebabCase(externalFlagName);
+    if (kebabCaseFlagName in flags) {
+      throw new FlagNotFoundError(externalFlagName, [kebabCaseFlagName]);
+    }
+    const corrections = filterClosestAlternatives(internalFlagName, Object.keys(flags), config.distanceOptions);
+    throw new FlagNotFoundError(externalFlagName, corrections);
+  }
+  return { namedFlag: [internalFlagName, flag] };
+}
+function isNiladic(namedFlagWithNegation) {
+  if (namedFlagWithNegation.namedFlag[1].kind === "boolean" || namedFlagWithNegation.namedFlag[1].kind === "counter") {
+    return true;
+  }
+  return false;
+}
+var FLAG_SHORTHAND_PATTERN = /^-([a-z]+)$/i;
+var FLAG_NAME_PATTERN = /^--([a-z][a-z-.\d_]+)$/i;
+function findFlagsByArgument(arg, flags, resolvedAliases, config) {
+  const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(arg);
+  if (shorthandMatch) {
+    const batch = shorthandMatch[1];
+    return Array.from(batch).map((alias) => {
+      const aliasName = alias;
+      const namedFlag = resolvedAliases[aliasName];
+      if (!namedFlag) {
+        throw new AliasNotFoundError(aliasName);
+      }
+      return { namedFlag };
+    });
+  }
+  const flagNameMatch = FLAG_NAME_PATTERN.exec(arg);
+  if (flagNameMatch) {
+    const externalFlagName = flagNameMatch[1];
+    return [findInternalFlagMatch(externalFlagName, flags, config)];
+  }
+  return [];
+}
+var FLAG_NAME_VALUE_PATTERN = /^--([a-z][a-z-.\d_]+)=(.+)$/i;
+var ALIAS_VALUE_PATTERN = /^-([a-z])=(.+)$/i;
+var InvalidNegatedFlagSyntaxError = class extends ArgumentScannerError {
+  /**
+   * External name of flag that was active when this error was thrown.
+   */
+  externalFlagName;
+  /**
+   * Input text equivalent to right hand side of input
+   */
+  valueText;
+  constructor(externalFlagName, valueText) {
+    super(`Cannot negate flag --${externalFlagName} and pass "${valueText}" as value`);
+    this.externalFlagName = externalFlagName;
+    this.valueText = valueText;
+  }
+};
+function findFlagByArgumentWithInput(arg, flags, resolvedAliases, config) {
+  const flagsNameMatch = FLAG_NAME_VALUE_PATTERN.exec(arg);
+  if (flagsNameMatch) {
+    const externalFlagName = flagsNameMatch[1];
+    const { namedFlag: flagMatch, negated } = findInternalFlagMatch(externalFlagName, flags, config);
+    const valueText = flagsNameMatch[2];
+    if (negated) {
+      throw new InvalidNegatedFlagSyntaxError(externalFlagName, valueText);
+    }
+    return [flagMatch, valueText];
+  }
+  const aliasValueMatch = ALIAS_VALUE_PATTERN.exec(arg);
+  if (aliasValueMatch) {
+    const aliasName = aliasValueMatch[1];
+    const namedFlag = resolvedAliases[aliasName];
+    if (!namedFlag) {
+      throw new AliasNotFoundError(aliasName);
+    }
+    const valueText = aliasValueMatch[2];
+    return [namedFlag, valueText];
+  }
+}
+async function parseInputsForFlag(externalFlagName, flag, inputs, config, context) {
+  if (!inputs) {
+    if ("default" in flag && typeof flag.default !== "undefined") {
+      if (flag.kind === "boolean") {
+        return flag.default;
+      }
+      if (flag.kind === "enum") {
+        if ("variadic" in flag && flag.variadic && Array.isArray(flag.default)) {
+          const defaultArray = flag.default;
+          for (const value of defaultArray) {
+            if (!flag.values.includes(value)) {
+              const corrections = filterClosestAlternatives(value, flag.values, config.distanceOptions);
+              throw new EnumValidationError(externalFlagName, value, flag.values, corrections);
+            }
+          }
+          return flag.default;
+        }
+        return flag.default;
+      }
+      if ("variadic" in flag && flag.variadic && Array.isArray(flag.default)) {
+        const defaultArray = flag.default;
+        return Promise.all(defaultArray.map((input2) => parseInput(externalFlagName, flag, input2, context)));
+      }
+      return parseInput(externalFlagName, flag, flag.default, context);
+    }
+    if (flag.optional) {
+      return;
+    }
+    if (flag.kind === "boolean") {
+      return false;
+    } else if (flag.kind === "counter") {
+      return 0;
+    }
+    throw new UnsatisfiedFlagError(externalFlagName);
+  }
+  if (flag.kind === "counter") {
+    return inputs.reduce((total, input2) => {
+      try {
+        return total + numberParser.call(context, input2);
+      } catch (exc) {
+        throw new ArgumentParseError(externalFlagName, input2, exc);
+      }
+    }, 0);
+  }
+  if ("variadic" in flag && flag.variadic) {
+    if (flag.kind === "enum") {
+      for (const input2 of inputs) {
+        if (!flag.values.includes(input2)) {
+          const corrections = filterClosestAlternatives(input2, flag.values, config.distanceOptions);
+          throw new EnumValidationError(externalFlagName, input2, flag.values, corrections);
+        }
+      }
+      return inputs;
+    }
+    return Promise.all(inputs.map((input2) => parseInput(externalFlagName, flag, input2, context)));
+  }
+  const input = inputs[0];
+  if (flag.kind === "boolean") {
+    try {
+      return looseBooleanParser.call(context, input);
+    } catch (exc) {
+      throw new ArgumentParseError(externalFlagName, input, exc);
+    }
+  }
+  if (flag.kind === "enum") {
+    if (!flag.values.includes(input)) {
+      const corrections = filterClosestAlternatives(input, flag.values, config.distanceOptions);
+      throw new EnumValidationError(externalFlagName, input, flag.values, corrections);
+    }
+    return input;
+  }
+  return parseInput(externalFlagName, flag, input, context);
+}
+var UnexpectedFlagError = class extends ArgumentScannerError {
+  /**
+   * External name of flag that was parsing this input.
+   */
+  externalFlagName;
+  /**
+   * Command line input that was previously encountered by this flag.
+   */
+  previousInput;
+  /**
+   * Command line input that triggered this error.
+   */
+  input;
+  constructor(externalFlagName, previousInput, input) {
+    super(`Too many arguments for --${externalFlagName}, encountered "${input}" after "${previousInput}"`);
+    this.externalFlagName = externalFlagName;
+    this.previousInput = previousInput;
+    this.input = input;
+  }
+};
+function isVariadicFlag(flag) {
+  if (flag.kind === "counter") {
+    return true;
+  }
+  if ("variadic" in flag) {
+    return Boolean(flag.variadic);
+  }
+  return false;
+}
+function storeInput(flagInputs, scannerCaseStyle, [internalFlagName, flag], input) {
+  const inputs = flagInputs.get(internalFlagName) ?? [];
+  if (inputs.length > 0 && !isVariadicFlag(flag)) {
+    const externalFlagName = asExternal(internalFlagName, scannerCaseStyle);
+    throw new UnexpectedFlagError(externalFlagName, inputs[0], input);
+  }
+  if ("variadic" in flag && typeof flag.variadic === "string") {
+    const multipleInputs = input.split(flag.variadic);
+    flagInputs.set(internalFlagName, [...inputs, ...multipleInputs]);
+  } else {
+    flagInputs.set(internalFlagName, [...inputs, input]);
+  }
+}
+function isFlagSatisfiedByInputs(flags, flagInputs, key) {
+  const inputs = flagInputs.get(key);
+  if (inputs) {
+    const flag = flags[key];
+    if (isVariadicFlag(flag)) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function buildArgumentScanner(parameters, config) {
+  const { flags = {}, aliases = {}, positional = { kind: "tuple", parameters: [] } } = parameters;
+  const resolvedAliases = resolveAliases(flags, aliases, config.caseStyle);
+  const positionalInputs = [];
+  const flagInputs = /* @__PURE__ */ new Map();
+  let positionalIndex = 0;
+  let activeFlag;
+  let treatInputsAsArguments = false;
+  return {
+    next: (input) => {
+      if (!treatInputsAsArguments && config.allowArgumentEscapeSequence && input === "--") {
+        if (activeFlag) {
+          if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+            storeInput(flagInputs, config.caseStyle, activeFlag, "");
+            activeFlag = void 0;
+          } else {
+            const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
+            throw new UnsatisfiedFlagError(externalFlagName);
+          }
+        }
+        treatInputsAsArguments = true;
+        return;
+      }
+      if (!treatInputsAsArguments) {
+        const flagInput = findFlagByArgumentWithInput(input, flags, resolvedAliases, config);
+        if (flagInput) {
+          if (activeFlag) {
+            if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+              storeInput(flagInputs, config.caseStyle, activeFlag, "");
+              activeFlag = void 0;
+            } else {
+              const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
+              const nextExternalFlagName = asExternal(flagInput[0][0], config.caseStyle);
+              throw new UnsatisfiedFlagError(externalFlagName, nextExternalFlagName);
+            }
+          }
+          storeInput(flagInputs, config.caseStyle, ...flagInput);
+          return;
+        }
+        const nextFlags = findFlagsByArgument(input, flags, resolvedAliases, config);
+        if (nextFlags.length > 0) {
+          if (activeFlag) {
+            if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+              storeInput(flagInputs, config.caseStyle, activeFlag, "");
+              activeFlag = void 0;
+            } else {
+              const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
+              const nextFlagName = asExternal(nextFlags[0].namedFlag[0], config.caseStyle);
+              throw new UnsatisfiedFlagError(externalFlagName, nextFlagName);
+            }
+          }
+          if (nextFlags.every(isNiladic)) {
+            for (const nextFlag of nextFlags) {
+              if (nextFlag.namedFlag[1].kind === "boolean") {
+                storeInput(
+                  flagInputs,
+                  config.caseStyle,
+                  nextFlag.namedFlag,
+                  nextFlag.negated ? "false" : "true"
+                );
+              } else {
+                storeInput(flagInputs, config.caseStyle, nextFlag.namedFlag, "1");
+              }
+            }
+          } else if (nextFlags.length > 1) {
+            const nextFlagExpectingArg = nextFlags.find((nextFlag) => !isNiladic(nextFlag));
+            const externalFlagName = asExternal(nextFlagExpectingArg.namedFlag[0], config.caseStyle);
+            throw new UnsatisfiedFlagError(externalFlagName);
+          } else {
+            activeFlag = nextFlags[0].namedFlag;
+          }
+          return;
+        }
+      }
+      if (activeFlag) {
+        storeInput(flagInputs, config.caseStyle, activeFlag, input);
+        activeFlag = void 0;
+      } else {
+        if (positional.kind === "tuple") {
+          if (positionalIndex >= positional.parameters.length) {
+            throw new UnexpectedPositionalError(positional.parameters.length, input);
+          }
+        } else {
+          if (typeof positional.maximum === "number" && positionalIndex >= positional.maximum) {
+            throw new UnexpectedPositionalError(positional.maximum, input);
+          }
+        }
+        positionalInputs[positionalIndex] = input;
+        ++positionalIndex;
+      }
+    },
+    parseArguments: async (context) => {
+      const errors = [];
+      let positionalValues_p;
+      if (positional.kind === "array") {
+        if (typeof positional.minimum === "number" && positionalIndex < positional.minimum) {
+          errors.push(
+            new UnsatisfiedPositionalError(getPlaceholder(positional.parameter), [
+              positional.minimum,
+              positionalIndex
+            ])
+          );
+        }
+        positionalValues_p = allSettledOrElse(
+          positionalInputs.map(async (input, i) => {
+            const placeholder = getPlaceholder(positional.parameter, i + 1);
+            return parseInput(placeholder, positional.parameter, input, context);
+          })
+        );
+      } else {
+        positionalValues_p = allSettledOrElse(
+          positional.parameters.map(async (param, i) => {
+            const placeholder = getPlaceholder(param, i + 1);
+            const input = positionalInputs[i];
+            if (typeof input !== "string") {
+              if (typeof param.default === "string") {
+                return parseInput(placeholder, param, param.default, context);
+              }
+              if (param.optional) {
+                return;
+              }
+              throw new UnsatisfiedPositionalError(placeholder);
+            }
+            return parseInput(placeholder, param, input, context);
+          })
+        );
+      }
+      if (activeFlag && activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+        storeInput(flagInputs, config.caseStyle, activeFlag, "");
+        activeFlag = void 0;
+      }
+      const flagEntries_p = allSettledOrElse(
+        Object.entries(flags).map(async (entry) => {
+          const [internalFlagName, flag] = entry;
+          const externalFlagName = asExternal(internalFlagName, config.caseStyle);
+          if (activeFlag && activeFlag[0] === internalFlagName) {
+            throw new UnsatisfiedFlagError(externalFlagName);
+          }
+          const inputs = flagInputs.get(internalFlagName);
+          const value = await parseInputsForFlag(externalFlagName, flag, inputs, config, context);
+          return [internalFlagName, value];
+        })
+      );
+      const [positionalValuesResult, flagEntriesResult] = await Promise.all([positionalValues_p, flagEntries_p]);
+      if (positionalValuesResult.status === "rejected") {
+        for (const reason of positionalValuesResult.reasons) {
+          errors.push(reason);
+        }
+      }
+      if (flagEntriesResult.status === "rejected") {
+        for (const reason of flagEntriesResult.reasons) {
+          errors.push(reason);
+        }
+      }
+      if (errors.length > 0) {
+        return { success: false, errors };
+      }
+      if (positionalValuesResult.status === "rejected") {
+        throw new InternalError("Unknown failure while scanning positional arguments");
+      }
+      if (flagEntriesResult.status === "rejected") {
+        throw new InternalError("Unknown failure while scanning flag arguments");
+      }
+      const parsedFlags = Object.fromEntries(flagEntriesResult.value);
+      return { success: true, arguments: [parsedFlags, ...positionalValuesResult.value] };
+    },
+    proposeCompletions: async ({ partial, completionConfig, text, context, includeVersionFlag }) => {
+      if (activeFlag) {
+        return proposeFlagCompletionsForPartialInput(activeFlag[1], context, partial);
+      }
+      const completions = [];
+      if (!treatInputsAsArguments) {
+        const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(partial);
+        if (completionConfig.includeAliases) {
+          if (partial === "" || partial === "-") {
+            const incompleteAliases = Object.entries(aliases).filter(
+              (entry) => !isFlagSatisfiedByInputs(flags, flagInputs, entry[1])
+            );
+            for (const [alias] of incompleteAliases) {
+              const flag = resolvedAliases[alias];
+              if (flag) {
+                completions.push({
+                  kind: "argument:flag",
+                  completion: `-${alias}`,
+                  brief: flag[1].brief
+                });
+              }
+            }
+          } else if (shorthandMatch) {
+            const partialAliases = Array.from(shorthandMatch[1]);
+            if (partialAliases.includes("h")) {
+              return [];
+            }
+            if (includeVersionFlag && partialAliases.includes("v")) {
+              return [];
+            }
+            const flagInputsIncludingPartial = new Map(flagInputs);
+            for (const alias of partialAliases) {
+              const namedFlag = resolvedAliases[alias];
+              if (!namedFlag) {
+                throw new AliasNotFoundError(alias);
+              }
+              storeInput(
+                flagInputsIncludingPartial,
+                config.caseStyle,
+                namedFlag,
+                namedFlag[1].kind === "boolean" ? "true" : "1"
+              );
+            }
+            const lastAlias = partialAliases[partialAliases.length - 1];
+            if (lastAlias) {
+              const namedFlag = resolvedAliases[lastAlias];
+              if (namedFlag) {
+                completions.push({
+                  kind: "argument:flag",
+                  completion: partial,
+                  brief: namedFlag[1].brief
+                });
+              }
+            }
+            const incompleteAliases = Object.entries(aliases).filter(
+              (entry) => !isFlagSatisfiedByInputs(
+                flags,
+                flagInputsIncludingPartial,
+                entry[1]
+              )
+            );
+            for (const [alias] of incompleteAliases) {
+              const flag = resolvedAliases[alias];
+              if (flag) {
+                completions.push({
+                  kind: "argument:flag",
+                  completion: `${partial}${alias}`,
+                  brief: flag[1].brief
+                });
+              }
+            }
+          }
+        }
+        if (partial === "" || partial === "-" || partial.startsWith("--")) {
+          if (config.allowArgumentEscapeSequence) {
+            completions.push({
+              kind: "argument:flag",
+              completion: "--",
+              brief: text.briefs.argumentEscapeSequence
+            });
+          }
+          let incompleteFlags = Object.entries(flags).filter(
+            ([flagName]) => !isFlagSatisfiedByInputs(flags, flagInputs, flagName)
+          );
+          if (config.caseStyle === "allow-kebab-for-camel") {
+            incompleteFlags = incompleteFlags.map(([flagName, param]) => {
+              return [convertCamelCaseToKebabCase(flagName), param];
+            });
+          }
+          const possibleFlags = incompleteFlags.map(([flagName, param]) => [`--${flagName}`, param]).filter(([flagName]) => flagName.startsWith(partial));
+          completions.push(
+            ...possibleFlags.map(([name, param]) => {
+              return {
+                kind: "argument:flag",
+                completion: name,
+                brief: param.brief
+              };
+            })
+          );
+        }
+      }
+      if (positional.kind === "array") {
+        if (positional.parameter.proposeCompletions) {
+          if (typeof positional.maximum !== "number" || positionalIndex < positional.maximum) {
+            const positionalCompletions = await positional.parameter.proposeCompletions.call(
+              context,
+              partial
+            );
+            completions.push(
+              ...positionalCompletions.map((value) => {
+                return {
+                  kind: "argument:value",
+                  completion: value,
+                  brief: positional.parameter.brief
+                };
+              })
+            );
+          }
+        }
+      } else {
+        const nextPositional = positional.parameters[positionalIndex];
+        if (nextPositional?.proposeCompletions) {
+          const positionalCompletions = await nextPositional.proposeCompletions.call(context, partial);
+          completions.push(
+            ...positionalCompletions.map((value) => {
+              return {
+                kind: "argument:value",
+                completion: value,
+                brief: nextPositional.brief
+              };
+            })
+          );
+        }
+      }
+      return completions.filter(({ completion }) => completion.startsWith(partial));
+    }
+  };
+}
+async function proposeFlagCompletionsForPartialInput(flag, context, partial) {
+  if (typeof flag.variadic === "string") {
+    if (partial.endsWith(flag.variadic)) {
+      return proposeFlagCompletionsForPartialInput(flag, context, "");
+    }
+  }
+  let values;
+  if (flag.kind === "enum") {
+    values = flag.values;
+  } else if (flag.proposeCompletions) {
+    values = await flag.proposeCompletions.call(context, partial);
+  } else {
+    values = [];
+  }
+  return values.map((value) => {
+    return {
+      kind: "argument:value",
+      completion: value,
+      brief: flag.brief
+    };
+  }).filter(({ completion }) => completion.startsWith(partial));
+}
+function listAllRouteNamesAndAliasesForScan(routeMap, scannerCaseStyle, config) {
+  const displayCaseStyle = scannerCaseStyle === "allow-kebab-for-camel" ? "convert-camel-to-kebab" : scannerCaseStyle;
+  let entries = routeMap.getAllEntries();
+  if (!config.includeHiddenRoutes) {
+    entries = entries.filter((entry) => !entry.hidden);
+  }
+  return entries.flatMap((entry) => {
+    const routeName = entry.name[displayCaseStyle];
+    if (config.includeAliases) {
+      return [routeName, ...entry.aliases];
+    }
+    return [routeName];
+  });
+}
+
+// src/text.ts
+var text_en = {
+  headers: {
+    usage: "USAGE",
+    aliases: "ALIASES",
+    commands: "COMMANDS",
+    flags: "FLAGS",
+    arguments: "ARGUMENTS"
+  },
+  keywords: {
+    default: "default =",
+    separator: "separator ="
+  },
+  briefs: {
+    help: "Print help information and exit",
+    helpAll: "Print help information (including hidden commands/flags) and exit",
+    version: "Print version information and exit",
+    argumentEscapeSequence: "All subsequent inputs should be interpreted as arguments"
+  },
+  noCommandRegisteredForInput: ({ input, corrections }) => {
+    const errorMessage = `No command registered for \`${input}\``;
+    if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(corrections, {
+        kind: "conjunctive",
+        conjunction: "or",
+        serialComma: true
+      });
+      return `${errorMessage}, did you mean ${formattedCorrections}?`;
+    } else {
+      return errorMessage;
+    }
+  },
+  noTextAvailableForLocale: ({ requestedLocale, defaultLocale }) => {
+    return `Application does not support "${requestedLocale}" locale, defaulting to "${defaultLocale}"`;
+  },
+  exceptionWhileParsingArguments: (exc) => {
+    if (exc instanceof ArgumentScannerError) {
+      return formatMessageForArgumentScannerError(exc, {});
+    }
+    return `Unable to parse arguments, ${formatException(exc)}`;
+  },
+  exceptionWhileLoadingCommandFunction: (exc) => {
+    return `Unable to load command function, ${formatException(exc)}`;
+  },
+  exceptionWhileLoadingCommandContext: (exc) => {
+    return `Unable to load command context, ${formatException(exc)}`;
+  },
+  exceptionWhileRunningCommand: (exc) => {
+    return `Command failed, ${formatException(exc)}`;
+  },
+  commandErrorResult: (err) => {
+    return err.message;
+  },
+  currentVersionIsNotLatest: ({ currentVersion, latestVersion, upgradeCommand }) => {
+    if (upgradeCommand) {
+      return `Latest available version is ${latestVersion} (currently running ${currentVersion}), upgrade with "${upgradeCommand}"`;
+    }
+    return `Latest available version is ${latestVersion} (currently running ${currentVersion})`;
+  }
+};
+function defaultTextLoader(locale) {
+  if (locale.startsWith("en")) {
+    return text_en;
+  }
+}
+function shouldUseAnsiColor(process, stream, config) {
+  return !config.disableAnsiColor && !checkEnvironmentVariable(process, "STRICLI_NO_COLOR") && (stream.getColorDepth?.(process.env) ?? 1) >= 4;
+}
+
+// src/routing/command/run.ts
+async function runCommand({ loader, parameters }, {
+  context,
+  inputs,
+  scannerConfig,
+  errorFormatting,
+  documentationConfig,
+  determineExitCode
+}) {
+  let parsedArguments;
+  try {
+    const scanner = buildArgumentScanner(parameters, scannerConfig);
+    for (const input of inputs) {
+      scanner.next(input);
+    }
+    const result = await scanner.parseArguments(context);
+    if (result.success) {
+      parsedArguments = result.arguments;
+    } else {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+      for (const error of result.errors) {
+        const errorMessage = errorFormatting.exceptionWhileParsingArguments(error, ansiColor);
+        context.process.stderr.write(
+          ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`
+        );
+      }
+      return ExitCode.InvalidArgument;
+    }
+  } catch (exc) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+    const errorMessage = errorFormatting.exceptionWhileParsingArguments(exc, ansiColor);
+    context.process.stderr.write(
+      ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`
+    );
+    return ExitCode.InvalidArgument;
+  }
+  let commandFunction;
+  try {
+    const loaded = await loader();
+    if (typeof loaded === "function") {
+      commandFunction = loaded;
+    } else {
+      commandFunction = loaded.default;
+    }
+  } catch (exc) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+    const errorMessage = errorFormatting.exceptionWhileLoadingCommandFunction(exc, ansiColor);
+    context.process.stderr.write(
+      ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`
+    );
+    return ExitCode.CommandLoadError;
+  }
+  try {
+    const result = await commandFunction.call(context, ...parsedArguments);
+    if (result instanceof Error) {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+      const errorMessage = errorFormatting.commandErrorResult(result, ansiColor);
+      context.process.stderr.write(
+        ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`
+      );
+      if (determineExitCode) {
+        return determineExitCode(result);
+      }
+      return ExitCode.CommandRunError;
+    }
+  } catch (exc) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+    const errorMessage = errorFormatting.exceptionWhileRunningCommand(exc, ansiColor);
+    context.process.stderr.write(
+      ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`
+    );
+    if (determineExitCode) {
+      return determineExitCode(exc);
+    }
+    return ExitCode.CommandRunError;
+  }
+  return ExitCode.Success;
+}
+
+// src/routing/route-map/types.ts
+var RouteMapSymbol = Symbol("RouteMap");
+
+// src/routing/command/types.ts
+var CommandSymbol = Symbol("Command");
+
+// src/routing/scanner.ts
+function buildRouteScanner(root, config, startingPrefix) {
+  const prefix = [...startingPrefix];
+  const unprocessedInputs = [];
+  let parent;
+  let current = root;
+  let target;
+  let rootLevel = true;
+  let helpRequested = false;
+  return {
+    next: (input) => {
+      if (input === "--help" || input === "-h") {
+        helpRequested = true;
+        if (!target) {
+          target = current;
+        }
+        return;
+      } else if (input === "--helpAll" || input === "--help-all" || input === "-H") {
+        helpRequested = "all";
+        if (!target) {
+          target = current;
+        }
+        return;
+      }
+      if (target) {
+        unprocessedInputs.push(input);
+        return;
+      }
+      if (current.kind === CommandSymbol) {
+        target = current;
+        unprocessedInputs.push(input);
+        return;
+      }
+      const camelCaseRouteName = convertKebabCaseToCamelCase(input);
+      let internalRouteName = input;
+      let next = current.getRoutingTargetForInput(internalRouteName);
+      if (config.caseStyle === "allow-kebab-for-camel" && !next) {
+        next = current.getRoutingTargetForInput(camelCaseRouteName);
+        if (next) {
+          internalRouteName = camelCaseRouteName;
+        }
+      }
+      if (!next) {
+        const defaultCommand = current.getDefaultCommand();
+        if (defaultCommand) {
+          rootLevel = false;
+          parent = [current, ""];
+          unprocessedInputs.push(input);
+          current = defaultCommand;
+          return;
+        }
+        return { input, routeMap: current };
+      }
+      rootLevel = false;
+      parent = [current, input];
+      current = next;
+      prefix.push(input);
+    },
+    finish: () => {
+      target = target ?? current;
+      if (target.kind === RouteMapSymbol && !helpRequested) {
+        const defaultCommand = target.getDefaultCommand();
+        if (defaultCommand) {
+          parent = [target, ""];
+          target = defaultCommand;
+          rootLevel = false;
+        }
+      }
+      const aliases = parent ? parent[0].getOtherAliasesForInput(parent[1], config.caseStyle) : { original: [], "convert-camel-to-kebab": [] };
+      return {
+        target,
+        unprocessedInputs,
+        helpRequested,
+        prefix,
+        rootLevel,
+        aliases
+      };
+    }
+  };
+}
+
+// src/application/run.ts
+async function runApplication({ root, defaultText, config }, rawInputs, context) {
+  let text = defaultText;
+  if (context.locale) {
+    const localeText = config.localization.loadText(context.locale);
+    if (localeText) {
+      text = localeText;
+    } else {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+      const warningMessage = text.noTextAvailableForLocale({
+        requestedLocale: context.locale,
+        defaultLocale: config.localization.defaultLocale,
+        ansiColor
+      });
+      context.process.stderr.write(
+        ansiColor ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
+` : `${warningMessage}
+`
+      );
+    }
+  }
+  if (config.versionInfo?.getLatestVersion && !checkEnvironmentVariable(context.process, "STRICLI_SKIP_VERSION_CHECK")) {
+    let currentVersion;
+    if ("currentVersion" in config.versionInfo) {
+      currentVersion = config.versionInfo.currentVersion;
+    } else {
+      currentVersion = await config.versionInfo.getCurrentVersion.call(context);
+    }
+    const latestVersion = await config.versionInfo.getLatestVersion.call(context, currentVersion);
+    if (latestVersion && currentVersion !== latestVersion) {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+      const warningMessage = text.currentVersionIsNotLatest({
+        currentVersion,
+        latestVersion,
+        upgradeCommand: config.versionInfo.upgradeCommand,
+        ansiColor
+      });
+      context.process.stderr.write(
+        ansiColor ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
+` : `${warningMessage}
+`
+      );
+    }
+  }
+  const inputs = rawInputs.slice();
+  if (config.versionInfo && (inputs[0] === "--version" || inputs[0] === "-v")) {
+    let currentVersion;
+    if ("currentVersion" in config.versionInfo) {
+      currentVersion = config.versionInfo.currentVersion;
+    } else {
+      currentVersion = await config.versionInfo.getCurrentVersion.call(context);
+    }
+    context.process.stdout.write(currentVersion + "\n");
+    return ExitCode.Success;
+  }
+  const scanner = buildRouteScanner(root, config.scanner, [config.name]);
+  let error;
+  while (inputs.length > 0 && !error) {
+    const arg = inputs.shift();
+    error = scanner.next(arg);
+  }
+  if (error) {
+    const routeNames = listAllRouteNamesAndAliasesForScan(
+      error.routeMap,
+      config.scanner.caseStyle,
+      config.completion
+    );
+    const corrections = filterClosestAlternatives(error.input, routeNames, config.scanner.distanceOptions).map(
+      (str) => `\`${str}\``
+    );
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+    const errorMessage = text.noCommandRegisteredForInput({ input: error.input, corrections, ansiColor });
+    context.process.stderr.write(
+      ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`
+    );
+    return ExitCode.UnknownCommand;
+  }
+  const result = scanner.finish();
+  if (result.helpRequested || result.target.kind === RouteMapSymbol) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stdout, config.documentation);
+    context.process.stdout.write(
+      result.target.formatHelp({
+        prefix: result.prefix,
+        includeVersionFlag: Boolean(config.versionInfo) && result.rootLevel,
+        includeArgumentEscapeSequenceFlag: config.scanner.allowArgumentEscapeSequence,
+        includeHelpAllFlag: result.helpRequested === "all" || config.documentation.alwaysShowHelpAllFlag,
+        includeHidden: result.helpRequested === "all",
+        config: config.documentation,
+        aliases: result.aliases[config.documentation.caseStyle],
+        text,
+        ansiColor
+      })
+    );
+    return ExitCode.Success;
+  }
+  let commandContext;
+  if ("forCommand" in context) {
+    try {
+      commandContext = await context.forCommand({ prefix: result.prefix });
+    } catch (exc) {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+      const errorMessage = text.exceptionWhileLoadingCommandContext(exc, ansiColor);
+      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m` : errorMessage);
+      return ExitCode.ContextLoadError;
+    }
+  } else {
+    commandContext = context;
+  }
+  return runCommand(result.target, {
+    context: commandContext,
+    inputs: result.unprocessedInputs,
+    scannerConfig: config.scanner,
+    documentationConfig: config.documentation,
+    errorFormatting: text,
+    determineExitCode: config.determineExitCode
+  });
+}
+
+// src/config.ts
+function formatForDisplay(flagName, displayCaseStyle) {
+  if (displayCaseStyle === "convert-camel-to-kebab") {
+    return convertCamelCaseToKebabCase(flagName);
+  }
+  return flagName;
+}
+function formatAsNegated(flagName, displayCaseStyle) {
+  if (displayCaseStyle === "convert-camel-to-kebab") {
+    return `no-${convertCamelCaseToKebabCase(flagName)}`;
+  }
+  return `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
+}
+function withDefaults(config) {
+  const scannerCaseStyle = config.scanner?.caseStyle ?? "original";
+  let displayCaseStyle;
+  if (config.documentation?.caseStyle) {
+    if (scannerCaseStyle === "original" && config.documentation.caseStyle === "convert-camel-to-kebab") {
+      throw new InternalError("Cannot convert route and flag names on display but scan as original");
+    }
+    displayCaseStyle = config.documentation.caseStyle;
+  } else if (scannerCaseStyle === "allow-kebab-for-camel") {
+    displayCaseStyle = "convert-camel-to-kebab";
+  } else {
+    displayCaseStyle = scannerCaseStyle;
+  }
+  const scannerConfig = {
+    caseStyle: scannerCaseStyle,
+    allowArgumentEscapeSequence: config.scanner?.allowArgumentEscapeSequence ?? false,
+    distanceOptions: config.scanner?.distanceOptions ?? {
+      threshold: 7,
+      weights: {
+        insertion: 1,
+        deletion: 3,
+        substitution: 2,
+        transposition: 0
+      }
+    }
+  };
+  const documentationConfig = {
+    alwaysShowHelpAllFlag: config.documentation?.alwaysShowHelpAllFlag ?? false,
+    useAliasInUsageLine: config.documentation?.useAliasInUsageLine ?? false,
+    onlyRequiredInUsageLine: config.documentation?.onlyRequiredInUsageLine ?? false,
+    caseStyle: displayCaseStyle,
+    disableAnsiColor: config.documentation?.disableAnsiColor ?? false
+  };
+  const completionConfig = {
+    includeAliases: config.completion?.includeAliases ?? documentationConfig.useAliasInUsageLine,
+    includeHiddenRoutes: config.completion?.includeHiddenRoutes ?? false,
+    ...config.completion
+  };
+  return {
+    ...config,
+    scanner: scannerConfig,
+    completion: completionConfig,
+    documentation: documentationConfig,
+    localization: {
+      defaultLocale: "en",
+      loadText: defaultTextLoader,
+      ...config.localization
+    }
+  };
+}
+
+// src/application/builder.ts
+function buildApplication(root, appConfig) {
+  const config = withDefaults(appConfig);
+  if (root.kind === CommandSymbol && config.versionInfo) {
+    if (root.usesFlag("version")) {
+      throw new InternalError("Unable to use command with flag --version as root when version info is supplied");
+    }
+    if (root.usesFlag("v")) {
+      throw new InternalError("Unable to use command with alias -v as root when version info is supplied");
+    }
+  }
+  const defaultText = config.localization.loadText(config.localization.defaultLocale);
+  if (!defaultText) {
+    throw new InternalError(`No text available for the default locale "${config.localization.defaultLocale}"`);
+  }
+  return {
+    root,
+    config,
+    defaultText
+  };
+}
+
+// src/application/documentation.ts
+function* iterateAllCommands(routeMap, prefix, caseStyle) {
+  for (const entry of routeMap.getAllEntries()) {
+    if (entry.hidden) {
+      continue;
+    }
+    const routeName = entry.name[caseStyle];
+    const route = [...prefix, routeName];
+    if (entry.target.kind === RouteMapSymbol) {
+      yield* iterateAllCommands(entry.target, route, caseStyle);
+    } else {
+      yield [route, entry.target, entry.aliases];
+    }
+  }
+}
+function generateHelpTextForAllCommands({ root, defaultText, config }, locale) {
+  let text = defaultText;
+  if (locale) {
+    const localeText = config.localization.loadText(locale);
+    if (localeText) {
+      text = localeText;
+    } else {
+      throw new InternalError(`Application does not support "${locale}" locale`);
+    }
+  }
+  const commands = [];
+  if (root.kind === CommandSymbol) {
+    commands.push([[config.name], root, []]);
+  } else {
+    commands.push(...iterateAllCommands(root, [config.name], config.documentation.caseStyle));
+  }
+  return commands.map(([route, command, aliases]) => {
+    return [
+      route.join(" "),
+      command.formatHelp({
+        prefix: route,
+        config: config.documentation,
+        includeVersionFlag: Boolean(config.versionInfo) && route.length === 1,
+        includeArgumentEscapeSequenceFlag: config.scanner.allowArgumentEscapeSequence,
+        includeHelpAllFlag: config.documentation.alwaysShowHelpAllFlag,
+        includeHidden: false,
+        aliases,
+        text,
+        ansiColor: false
+      })
+    ];
+  });
+}
+
+// src/routing/command/propose-completions.ts
+async function proposeCompletionsForCommand({ parameters }, args) {
+  try {
+    const scanner = buildArgumentScanner(parameters, args.scannerConfig);
+    for (const input of args.inputs) {
+      scanner.next(input);
+    }
+    return await scanner.proposeCompletions(args);
+  } catch {
+    return [];
+  }
+}
+
+// src/routing/route-map/propose-completions.ts
+async function proposeCompletionsForRouteMap(routeMap, { partial, scannerConfig, completionConfig }) {
+  let entries = routeMap.getAllEntries();
+  if (!completionConfig.includeHiddenRoutes) {
+    entries = entries.filter((entry) => !entry.hidden);
+  }
+  const displayCaseStyle = scannerConfig.caseStyle === "allow-kebab-for-camel" ? "convert-camel-to-kebab" : scannerConfig.caseStyle;
+  return entries.flatMap((entry) => {
+    const kind = entry.target.kind === CommandSymbol ? "routing-target:command" : "routing-target:route-map";
+    const brief = entry.target.brief;
+    const targetCompletion = {
+      kind,
+      completion: entry.name[displayCaseStyle],
+      brief
+    };
+    if (completionConfig.includeAliases) {
+      return [
+        targetCompletion,
+        ...entry.aliases.map((alias) => {
+          return {
+            kind,
+            completion: alias,
+            brief
+          };
+        })
+      ];
+    }
+    return [targetCompletion];
+  }).filter(({ completion }) => completion.startsWith(partial));
+}
+
+// src/application/propose-completions.ts
+async function proposeCompletionsForApplication({ root, config, defaultText }, rawInputs, context) {
+  if (rawInputs.length === 0) {
+    return [];
+  }
+  const scanner = buildRouteScanner(root, config.scanner, []);
+  const leadingInputs = rawInputs.slice(0, -1);
+  let error;
+  while (leadingInputs.length > 0 && !error) {
+    const input = leadingInputs.shift();
+    error = scanner.next(input);
+  }
+  if (error) {
+    return [];
+  }
+  const result = scanner.finish();
+  if (result.helpRequested) {
+    return [];
+  }
+  let commandContext;
+  if ("forCommand" in context) {
+    try {
+      commandContext = await context.forCommand({ prefix: result.prefix });
+    } catch {
+      return [];
+    }
+  } else {
+    commandContext = context;
+  }
+  const partial = rawInputs[rawInputs.length - 1];
+  if (result.target.kind === RouteMapSymbol) {
+    return proposeCompletionsForRouteMap(result.target, {
+      context: commandContext,
+      partial,
+      scannerConfig: config.scanner,
+      completionConfig: config.completion
+    });
+  }
+  return proposeCompletionsForCommand(result.target, {
+    context: commandContext,
+    inputs: result.unprocessedInputs,
+    partial,
+    scannerConfig: config.scanner,
+    completionConfig: config.completion,
+    text: defaultText,
+    includeVersionFlag: Boolean(config.versionInfo) && result.rootLevel
+  });
+}
+
+// src/parameter/parser/choice.ts
+function narrowString(choices, value) {
+  return choices.includes(value);
+}
+function buildChoiceParser(choices) {
+  return (input) => {
+    if (!narrowString(choices, input)) {
+      throw new SyntaxError(`${input} is not one of (${choices.join("|")})`);
+    }
+    return input;
+  };
+}
+
+// src/parameter/flag/types.ts
+function hasDefault(flag) {
+  return "default" in flag && typeof flag.default !== "undefined";
+}
+function isOptionalAtRuntime(flag) {
+  return flag.optional ?? hasDefault(flag);
+}
+
+// src/parameter/formatting.ts
+function wrapRequiredFlag(text) {
+  return `(${text})`;
+}
+function wrapOptionalFlag(text) {
+  return `[${text}]`;
+}
+function wrapVariadicFlag(text) {
+  return `${text}...`;
+}
+function wrapRequiredParameter(text) {
+  return `<${text}>`;
+}
+function wrapOptionalParameter(text) {
+  return `[<${text}>]`;
+}
+function wrapVariadicParameter(text) {
+  return `<${text}>...`;
+}
+function formatUsageLineForParameters(parameters, args) {
+  const flagsUsage = Object.entries(parameters.flags ?? {}).filter(([, flag]) => {
+    if (flag.hidden) {
+      return false;
+    }
+    if (args.config.onlyRequiredInUsageLine && isOptionalAtRuntime(flag)) {
+      return false;
+    }
+    return true;
+  }).map(([name, flag]) => {
+    let displayName = args.config.caseStyle === "convert-camel-to-kebab" ? `--${convertCamelCaseToKebabCase(name)}` : `--${name}`;
+    if (parameters.aliases && args.config.useAliasInUsageLine) {
+      const aliases = Object.entries(parameters.aliases).filter((entry) => entry[1] === name);
+      if (aliases.length === 1 && aliases[0]) {
+        displayName = `-${aliases[0][0]}`;
+      }
+    }
+    if (flag.kind === "boolean") {
+      return [flag, displayName];
+    }
+    if (flag.kind === "enum" && typeof flag.placeholder !== "string") {
+      return [flag, `${displayName} ${flag.values.join("|")}`];
+    }
+    const placeholder = flag.placeholder ?? "value";
+    return [flag, `${displayName} ${placeholder}`];
+  }).map(([flag, usage]) => {
+    if (flag.kind === "parsed" && flag.variadic) {
+      if (isOptionalAtRuntime(flag)) {
+        return wrapVariadicFlag(wrapOptionalFlag(usage));
+      }
+      return wrapVariadicFlag(wrapRequiredFlag(usage));
+    }
+    if (isOptionalAtRuntime(flag)) {
+      return wrapOptionalFlag(usage);
+    }
+    return wrapRequiredFlag(usage);
+  });
+  let positionalUsage = [];
+  const positional = parameters.positional;
+  if (positional) {
+    if (positional.kind === "array") {
+      positionalUsage = [wrapVariadicParameter(positional.parameter.placeholder ?? "args")];
+    } else {
+      let parameters2 = positional.parameters;
+      if (args.config.onlyRequiredInUsageLine) {
+        parameters2 = parameters2.filter((param) => !param.optional && typeof param.default === "undefined");
+      }
+      positionalUsage = parameters2.map((param, i) => {
+        const argName = param.placeholder ?? `arg${i + 1}`;
+        return param.optional || typeof param.default !== "undefined" ? wrapOptionalParameter(argName) : wrapRequiredParameter(argName);
+      });
+    }
+  }
+  return [...args.prefix, ...flagsUsage, ...positionalUsage].join(" ");
+}
+
+// src/parameter/flag/formatting.ts
+function formatDocumentationForFlagParameters(flags, aliases, args) {
+  const { keywords, briefs } = args.text;
+  const visibleFlags = Object.entries(flags).filter(([, flag]) => {
+    if (flag.hidden && !args.includeHidden) {
+      return false;
+    }
+    return true;
+  });
+  const atLeastOneOptional = visibleFlags.some(([, flag]) => isOptionalAtRuntime(flag));
+  const rows = visibleFlags.map(([name, flag]) => {
+    const aliasStrings = Object.entries(aliases).filter((entry) => entry[1] === name).map(([alias]) => `-${alias}`);
+    let flagName = "--" + formatForDisplay(name, args.config.caseStyle);
+    if (flag.kind === "boolean" && flag.default !== false && flag.withNegated !== false) {
+      const negatedFlagName = formatAsNegated(name, args.config.caseStyle);
+      flagName = `${flagName}/--${negatedFlagName}`;
+    }
+    if (isOptionalAtRuntime(flag)) {
+      flagName = `[${flagName}]`;
+    } else if (atLeastOneOptional) {
+      flagName = ` ${flagName}`;
+    }
+    if (flag.kind === "parsed" && flag.variadic) {
+      flagName = `${flagName}...`;
+    }
+    const suffixParts = [];
+    if (flag.kind === "enum") {
+      const choices = flag.values.join("|");
+      suffixParts.push(choices);
+    }
+    if (hasDefault(flag)) {
+      const defaultKeyword = args.ansiColor ? `\x1B[2m${keywords.default}\x1B[22m` : keywords.default;
+      let defaultValue;
+      if (Array.isArray(flag.default)) {
+        if (flag.default.length === 0) {
+          defaultValue = "[]";
+        } else {
+          const separator = "variadic" in flag && typeof flag.variadic === "string" ? flag.variadic : " ";
+          defaultValue = flag.default.join(separator);
+        }
+      } else {
+        defaultValue = flag.default === "" ? `""` : String(flag.default);
+      }
+      suffixParts.push(`${defaultKeyword} ${defaultValue}`);
+    }
+    if ("variadic" in flag && typeof flag.variadic === "string") {
+      const separatorKeyword = args.ansiColor ? `\x1B[2m${keywords.separator}\x1B[22m` : keywords.separator;
+      suffixParts.push(`${separatorKeyword} ${flag.variadic}`);
+    }
+    const suffix = suffixParts.length > 0 ? `[${suffixParts.join(", ")}]` : void 0;
+    return {
+      aliases: aliasStrings.join(" "),
+      flagName,
+      brief: flag.brief,
+      suffix,
+      hidden: flag.hidden
+    };
+  });
+  rows.push({
+    aliases: "-h",
+    flagName: atLeastOneOptional ? " --help" : "--help",
+    brief: briefs.help
+  });
+  if (args.includeHelpAllFlag) {
+    const helpAllFlagName = formatForDisplay("helpAll", args.config.caseStyle);
+    rows.push({
+      aliases: "-H",
+      flagName: atLeastOneOptional ? ` --${helpAllFlagName}` : `--${helpAllFlagName}`,
+      brief: briefs.helpAll,
+      hidden: !args.config.alwaysShowHelpAllFlag
+    });
+  }
+  if (args.includeVersionFlag) {
+    rows.push({
+      aliases: "-v",
+      flagName: atLeastOneOptional ? " --version" : "--version",
+      brief: briefs.version
+    });
+  }
+  if (args.includeArgumentEscapeSequenceFlag) {
+    rows.push({
+      aliases: "",
+      flagName: atLeastOneOptional ? " --" : "--",
+      brief: briefs.argumentEscapeSequence
+    });
+  }
+  return formatRowsWithColumns(
+    rows.map((row) => {
+      if (!args.ansiColor) {
+        return [row.aliases, row.flagName, row.brief, row.suffix ?? ""];
+      }
+      return [
+        row.hidden ? `\x1B[2m${row.aliases}\x1B[22m` : `\x1B[1m${row.aliases}\x1B[22m`,
+        row.hidden ? `\x1B[2m${row.flagName}\x1B[22m` : `\x1B[1m${row.flagName}\x1B[22m`,
+        row.hidden ? `\x1B[2;3m${row.brief}\x1B[22;23m` : `\x1B[;;3m${row.brief}\x1B[;;;23m`,
+        row.suffix ?? ""
+      ];
+    }),
+    [" ", "  ", " "]
+  );
+}
+function* generateBuiltInFlagUsageLines(args) {
+  yield args.config.useAliasInUsageLine ? "-h" : "--help";
+  if (args.includeHelpAllFlag) {
+    const helpAllFlagName = formatForDisplay("helpAll", args.config.caseStyle);
+    yield args.config.useAliasInUsageLine ? "-H" : `--${helpAllFlagName}`;
+  }
+  if (args.includeVersionFlag) {
+    yield args.config.useAliasInUsageLine ? "-v" : "--version";
+  }
+}
+
+// src/parameter/positional/formatting.ts
+function formatDocumentationForPositionalParameters(positional, args) {
+  if (positional.kind === "array") {
+    const name = positional.parameter.placeholder ?? "args";
+    const argName = args.ansiColor ? `\x1B[1m${name}...\x1B[22m` : `${name}...`;
+    const brief = args.ansiColor ? `\x1B[3m${positional.parameter.brief}\x1B[23m` : positional.parameter.brief;
+    return formatRowsWithColumns([[argName, brief]], ["  "]);
+  }
+  const { keywords } = args.text;
+  const atLeastOneOptional = positional.parameters.some((def) => def.optional);
+  return formatRowsWithColumns(
+    positional.parameters.map((def, i) => {
+      let name = def.placeholder ?? `arg${i + 1}`;
+      let suffix;
+      if (def.optional) {
+        name = `[${name}]`;
+      } else if (atLeastOneOptional) {
+        name = ` ${name}`;
+      }
+      if (def.default) {
+        const defaultKeyword = args.ansiColor ? `\x1B[2m${keywords.default}\x1B[22m` : keywords.default;
+        suffix = `[${defaultKeyword} ${def.default}]`;
+      }
+      return [
+        args.ansiColor ? `\x1B[1m${name}\x1B[22m` : name,
+        args.ansiColor ? `\x1B[3m${def.brief}\x1B[23m` : def.brief,
+        suffix ?? ""
+      ];
+    }),
+    ["  ", " "]
+  );
+}
+
+// src/routing/command/documentation.ts
+function* generateCommandHelpLines(parameters, docs, args) {
+  const { brief, fullDescription, customUsage } = docs;
+  const { headers } = args.text;
+  const prefix = args.prefix.join(" ");
+  yield args.ansiColor ? `\x1B[4m${headers.usage}\x1B[24m` : headers.usage;
+  if (customUsage) {
+    for (const usage of customUsage) {
+      if (typeof usage === "string") {
+        yield `  ${prefix} ${usage}`;
+      } else {
+        const brief2 = args.ansiColor ? `\x1B[3m${usage.brief}\x1B[23m` : usage.brief;
+        yield `  ${prefix} ${usage.input}
+    ${brief2}`;
+      }
+    }
+  } else {
+    yield `  ${formatUsageLineForParameters(parameters, args)}`;
+  }
+  for (const line of generateBuiltInFlagUsageLines(args)) {
+    yield `  ${prefix} ${line}`;
+  }
+  yield "";
+  yield fullDescription ?? brief;
+  if (args.aliases && args.aliases.length > 0) {
+    const aliasPrefix = args.prefix.slice(0, -1).join(" ");
+    yield "";
+    yield args.ansiColor ? `\x1B[4m${headers.aliases}\x1B[24m` : headers.aliases;
+    for (const alias of args.aliases) {
+      yield `  ${aliasPrefix} ${alias}`;
+    }
+  }
+  yield "";
+  yield args.ansiColor ? `\x1B[4m${headers.flags}\x1B[24m` : headers.flags;
+  for (const line of formatDocumentationForFlagParameters(parameters.flags ?? {}, parameters.aliases ?? {}, args)) {
+    yield `  ${line}`;
+  }
+  const positional = parameters.positional ?? { kind: "tuple", parameters: [] };
+  if (positional.kind === "array" || positional.parameters.length > 0) {
+    yield "";
+    yield args.ansiColor ? `\x1B[4m${headers.arguments}\x1B[24m` : headers.arguments;
+    for (const line of formatDocumentationForPositionalParameters(positional, args)) {
+      yield `  ${line}`;
+    }
+  }
+}
+
+// src/routing/command/builder.ts
+function checkForReservedFlags(flags, reserved) {
+  for (const flag of reserved) {
+    if (flag in flags) {
+      throw new InternalError(`Unable to use reserved flag --${flag}`);
+    }
+  }
+}
+function checkForReservedAliases(aliases, reserved) {
+  for (const alias of reserved) {
+    if (alias in aliases) {
+      throw new InternalError(`Unable to use reserved alias -${alias}`);
+    }
+  }
+}
+function* asNegationFlagNames(flagName) {
+  yield `no-${convertCamelCaseToKebabCase(flagName)}`;
+  yield `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
+}
+function checkForNegationCollisions(flags) {
+  const flagsAllowingNegation = Object.entries(flags).filter(([, flag]) => flag.kind === "boolean" && !flag.optional);
+  for (const [internalFlagName] of flagsAllowingNegation) {
+    for (const negatedFlagName of asNegationFlagNames(internalFlagName)) {
+      if (negatedFlagName in flags) {
+        throw new InternalError(
+          `Unable to allow negation for --${internalFlagName} as it conflicts with --${negatedFlagName}`
+        );
+      }
+    }
+  }
+}
+function checkForInvalidVariadicSeparators(flags) {
+  for (const [internalFlagName, flag] of Object.entries(flags)) {
+    if ("variadic" in flag && typeof flag.variadic === "string") {
+      if (flag.variadic.length < 1) {
+        throw new InternalError(
+          `Unable to use "" as variadic separator for --${internalFlagName} as it is empty`
+        );
+      }
+      if (/\s/.test(flag.variadic)) {
+        throw new InternalError(
+          `Unable to use "${flag.variadic}" as variadic separator for --${internalFlagName} as it contains whitespace`
+        );
+      }
+    }
+  }
+}
+function buildCommand(builderArgs) {
+  const { flags = {}, aliases = {} } = builderArgs.parameters;
+  checkForReservedFlags(flags, ["help", "helpAll", "help-all"]);
+  checkForReservedAliases(aliases, ["h", "H"]);
+  checkForNegationCollisions(flags);
+  checkForInvalidVariadicSeparators(flags);
+  let loader;
+  if ("func" in builderArgs) {
+    loader = async () => builderArgs.func;
+  } else {
+    loader = builderArgs.loader;
+  }
+  return {
+    kind: CommandSymbol,
+    loader,
+    parameters: builderArgs.parameters,
+    get brief() {
+      return builderArgs.docs.brief;
+    },
+    /* v8 ignore next -- @preserve */
+    get fullDescription() {
+      return builderArgs.docs.fullDescription;
+    },
+    formatUsageLine: (args) => {
+      return formatUsageLineForParameters(builderArgs.parameters, args);
+    },
+    formatHelp: (args) => {
+      const lines = [
+        ...generateCommandHelpLines(builderArgs.parameters, builderArgs.docs, args)
+      ];
+      const text = lines.join("\n");
+      return text + "\n";
+    },
+    usesFlag: (flagName) => {
+      return Boolean(flagName in flags || flagName in aliases);
+    }
+  };
+}
+
+// src/routing/route-map/documentation.ts
+function* generateRouteMapHelpLines(routes, docs, args) {
+  const { brief, fullDescription, hideRoute } = docs;
+  const { headers } = args.text;
+  yield args.ansiColor ? `\x1B[4m${headers.usage}\x1B[24m` : headers.usage;
+  for (const [name, route] of Object.entries(routes)) {
+    if (!hideRoute || !hideRoute[name] || args.includeHidden) {
+      const externalRouteName = args.config.caseStyle === "convert-camel-to-kebab" ? convertCamelCaseToKebabCase(name) : name;
+      yield `  ${route.formatUsageLine({
+        ...args,
+        prefix: [...args.prefix, externalRouteName]
+      })}`;
+    }
+  }
+  const prefix = args.prefix.join(" ");
+  for (const line of generateBuiltInFlagUsageLines(args)) {
+    yield `  ${prefix} ${line}`;
+  }
+  yield "";
+  yield fullDescription ?? brief;
+  if (args.aliases && args.aliases.length > 0) {
+    const aliasPrefix = args.prefix.slice(0, -1).join(" ");
+    yield "";
+    yield args.ansiColor ? `\x1B[4m${headers.aliases}\x1B[24m` : headers.aliases;
+    for (const alias of args.aliases) {
+      yield `  ${aliasPrefix} ${alias}`;
+    }
+  }
+  yield "";
+  yield args.ansiColor ? `\x1B[4m${headers.flags}\x1B[24m` : headers.flags;
+  for (const line of formatDocumentationForFlagParameters({}, {}, args)) {
+    yield `  ${line}`;
+  }
+  yield "";
+  yield args.ansiColor ? `\x1B[4m${headers.commands}\x1B[24m` : headers.commands;
+  const visibleRoutes = Object.entries(routes).filter(
+    ([name]) => !hideRoute || !hideRoute[name] || args.includeHidden
+  );
+  const rows = visibleRoutes.map(([internalRouteName, route]) => {
+    const externalRouteName = formatForDisplay(internalRouteName, args.config.caseStyle);
+    return {
+      routeName: externalRouteName,
+      brief: route.brief,
+      hidden: hideRoute && hideRoute[internalRouteName]
+    };
+  });
+  const formattedRows = formatRowsWithColumns(
+    rows.map((row) => {
+      if (!args.ansiColor) {
+        return [row.routeName, row.brief];
+      }
+      return [
+        row.hidden ? `\x1B[2m${row.routeName}\x1B[22m` : `\x1B[1m${row.routeName}\x1B[32m`,
+        row.hidden ? `\x1B[2;3m${row.brief}\x1B[22;23m` : `\x1B[;;3m${row.brief}\x1B[;;;23m`
+      ];
+    }),
+    ["  "]
+  );
+  for (const line of formattedRows) {
+    yield `  ${line}`;
+  }
+}
+
+// src/routing/route-map/builder.ts
+function buildRouteMap({
+  routes,
+  defaultCommand: defaultCommandRoute,
+  docs,
+  aliases
+}) {
+  if (Object.entries(routes).length === 0) {
+    throw new InternalError("Route map must contain at least one route");
+  }
+  const activeAliases = aliases ?? {};
+  const aliasesByRoute = /* @__PURE__ */ new Map();
+  for (const [alias, routeName] of Object.entries(activeAliases)) {
+    if (alias in routes) {
+      throw new InternalError(`Cannot use "${alias}" as an alias when a route with that name already exists`);
+    }
+    const routeAliases = aliasesByRoute.get(routeName) ?? [];
+    aliasesByRoute.set(routeName, [...routeAliases, alias]);
+  }
+  const defaultCommand = defaultCommandRoute ? routes[defaultCommandRoute] : void 0;
+  if (defaultCommand && defaultCommand.kind === RouteMapSymbol) {
+    throw new InternalError(
+      `Cannot use "${defaultCommandRoute}" as the default command because it is not a Command`
+    );
+  }
+  const resolveRouteName = (input) => {
+    if (input in activeAliases) {
+      return activeAliases[input];
+    } else if (input in routes) {
+      return input;
+    }
+  };
+  return {
+    kind: RouteMapSymbol,
+    get brief() {
+      return docs.brief;
+    },
+    /* v8 ignore next -- @preserve */
+    get fullDescription() {
+      return docs.fullDescription;
+    },
+    formatUsageLine(args) {
+      const routeNames = this.getAllEntries().filter((entry) => !entry.hidden).map((entry) => entry.name[args.config.caseStyle]);
+      return `${args.prefix.join(" ")} ${routeNames.join("|")} ...`;
+    },
+    formatHelp: (config) => {
+      const lines = [...generateRouteMapHelpLines(routes, docs, config)];
+      const text = lines.join("\n");
+      return text + "\n";
+    },
+    getDefaultCommand: () => {
+      return defaultCommand;
+    },
+    getOtherAliasesForInput: (input, caseStyle) => {
+      if (defaultCommandRoute) {
+        if (input === defaultCommandRoute) {
+          return {
+            original: [""],
+            "convert-camel-to-kebab": [""]
+          };
+        }
+        if (input === "") {
+          return {
+            original: [defaultCommandRoute],
+            "convert-camel-to-kebab": [defaultCommandRoute]
+          };
+        }
+      }
+      const camelInput = convertKebabCaseToCamelCase(input);
+      let routeName = resolveRouteName(input);
+      if (!routeName && caseStyle === "allow-kebab-for-camel") {
+        routeName = resolveRouteName(camelInput);
+      }
+      if (!routeName) {
+        return {
+          original: [],
+          "convert-camel-to-kebab": []
+        };
+      }
+      const otherAliases = [routeName, ...aliasesByRoute.get(routeName) ?? []].filter(
+        (alias) => alias !== input && alias !== camelInput
+      );
+      return {
+        original: otherAliases,
+        "convert-camel-to-kebab": otherAliases.map(convertCamelCaseToKebabCase)
+      };
+    },
+    getRoutingTargetForInput: (input) => {
+      const routeName = input in activeAliases ? activeAliases[input] : input;
+      return routes[routeName];
+    },
+    getAllEntries() {
+      const hiddenRoutes = docs.hideRoute;
+      return Object.entries(routes).map(([originalRouteName, target]) => {
+        return {
+          name: {
+            original: originalRouteName,
+            "convert-camel-to-kebab": convertCamelCaseToKebabCase(originalRouteName)
+          },
+          target,
+          aliases: aliasesByRoute.get(originalRouteName) ?? [],
+          hidden: hiddenRoutes?.[originalRouteName] ?? false
+        };
+      });
+    }
+  };
+}
+
+// src/index.ts
+async function run(app, inputs, context) {
+  const exitCode = await runApplication(app, inputs, context);
+  context.process.exitCode = exitCode;
+}
+export {
+  AliasNotFoundError,
+  ArgumentParseError,
+  ArgumentScannerError,
+  EnumValidationError,
+  ExitCode,
+  FlagNotFoundError,
+  InvalidNegatedFlagSyntaxError,
+  UnexpectedFlagError,
+  UnexpectedPositionalError,
+  UnsatisfiedFlagError,
+  UnsatisfiedPositionalError,
+  booleanParser,
+  buildApplication,
+  buildChoiceParser,
+  buildCommand,
+  buildRouteMap,
+  formatMessageForArgumentScannerError,
+  generateHelpTextForAllCommands,
+  looseBooleanParser,
+  numberParser,
+  proposeCompletionsForApplication as proposeCompletions,
+  run,
+  text_en
+};
+/* v8 ignore next -- @preserve */
+/* v8 ignore if -- @preserve */
+/* v8 ignore else -- @preserve */