varlock 0.0.0 → 0.0.2

package/dist/chunk-33ROL4J5.js

@@ -0,0 +1,1013 @@
+import { __name, __glob } from './chunk-XN24GZXQ.js';
+
+// ../../node_modules/.pnpm/gunshi@0.26.3/node_modules/gunshi/lib/definition-wq1Kmbvq.js
+function define(definition) {
+  return definition;
+}
+__name(define, "define");
+
+// ../../node_modules/.pnpm/gunshi@0.26.3/node_modules/gunshi/lib/utils-D41C8Abf.js
+var DEFAULT_LOCALE = "en-US";
+var BUILT_IN_PREFIX = "_";
+var ARG_PREFIX = "arg";
+var BUILT_IN_KEY_SEPARATOR = ":";
+var ANONYMOUS_COMMAND_NAME = "(anonymous)";
+var NOOP = /* @__PURE__ */ __name(() => {
+}, "NOOP");
+var COMMON_ARGS = {
+  help: {
+    type: "boolean",
+    short: "h",
+    description: "Display this help message"
+  },
+  version: {
+    type: "boolean",
+    short: "v",
+    description: "Display this version"
+  }
+};
+var COMMAND_OPTIONS_DEFAULT = {
+  name: void 0,
+  description: void 0,
+  version: void 0,
+  cwd: void 0,
+  usageSilent: false,
+  subCommands: void 0,
+  leftMargin: 2,
+  middleMargin: 10,
+  usageOptionType: false,
+  usageOptionValue: true,
+  renderHeader: void 0,
+  renderUsage: void 0,
+  renderValidationErrors: void 0,
+  translationAdapterFactory: void 0
+};
+function isLazyCommand(cmd) {
+  return typeof cmd === "function" && "commandName" in cmd && !!cmd.commandName;
+}
+__name(isLazyCommand, "isLazyCommand");
+async function resolveLazyCommand(cmd, name, needRunResolving = false) {
+  let command;
+  if (isLazyCommand(cmd)) {
+    command = Object.assign(create(), {
+      name: cmd.commandName,
+      description: cmd.description,
+      args: cmd.args,
+      examples: cmd.examples,
+      resource: cmd.resource
+    });
+    if (needRunResolving) {
+      const loaded = await cmd();
+      if (typeof loaded === "function") command.run = loaded;
+      else if (typeof loaded === "object") {
+        if (loaded.run == null) throw new TypeError(`'run' is required in command: ${cmd.name || name}`);
+        command.run = loaded.run;
+        command.name = loaded.name;
+        command.description = loaded.description;
+        command.args = loaded.args;
+        command.examples = loaded.examples;
+        command.resource = loaded.resource;
+      } else throw new TypeError(`Cannot resolve command: ${cmd.name || name}`);
+    }
+  } else command = Object.assign(create(), cmd);
+  if (command.name == null && name) command.name = name;
+  return deepFreeze(command);
+}
+__name(resolveLazyCommand, "resolveLazyCommand");
+function resolveBuiltInKey(key) {
+  return `${BUILT_IN_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+}
+__name(resolveBuiltInKey, "resolveBuiltInKey");
+function resolveArgKey(key) {
+  return `${ARG_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+}
+__name(resolveArgKey, "resolveArgKey");
+async function resolveExamples(ctx, examples) {
+  return typeof examples === "string" ? examples : typeof examples === "function" ? await examples(ctx) : "";
+}
+__name(resolveExamples, "resolveExamples");
+function mapResourceWithBuiltinKey(resource) {
+  return Object.entries(resource).reduce((acc, [key, value]) => {
+    acc[resolveBuiltInKey(key)] = value;
+    return acc;
+  }, create());
+}
+__name(mapResourceWithBuiltinKey, "mapResourceWithBuiltinKey");
+function create(obj = null) {
+  return Object.create(obj);
+}
+__name(create, "create");
+function log(...args) {
+  console.log(...args);
+}
+__name(log, "log");
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === "object" && value !== null) deepFreeze(value);
+  }
+  return Object.freeze(obj);
+}
+__name(deepFreeze, "deepFreeze");
+
+// import("./locales/**/*.json") in ../../node_modules/.pnpm/gunshi@0.26.3/node_modules/gunshi/lib/context-D_EmfRNA.js
+var globImport_locales_json = __glob({
+  "./locales/en-US.json": () => import('./en-US-TSGNDI2P.js'),
+  "./locales/ja-JP.json": () => import('./ja-JP-UBPCQAAD.js')
+});
+
+// ../../node_modules/.pnpm/gunshi@0.26.3/node_modules/gunshi/lib/context-D_EmfRNA.js
+var COMMAND = "COMMAND";
+var COMMANDS = "COMMANDS";
+var SUBCOMMAND = "SUBCOMMAND";
+var USAGE = "USAGE";
+var ARGUMENTS = "ARGUMENTS";
+var OPTIONS = "OPTIONS";
+var EXAMPLES = "EXAMPLES";
+var FORMORE = "For more info, run any command with the `--help` flag:";
+var NEGATABLE = "Negatable of";
+var DEFAULT = "default";
+var CHOICES = "choices";
+var help = "Display this help message";
+var version = "Display this version";
+var en_US_default = {
+  COMMAND,
+  COMMANDS,
+  SUBCOMMAND,
+  USAGE,
+  ARGUMENTS,
+  OPTIONS,
+  EXAMPLES,
+  FORMORE,
+  NEGATABLE,
+  DEFAULT,
+  CHOICES,
+  help,
+  version
+};
+function createTranslationAdapter(options) {
+  return new DefaultTranslation(options);
+}
+__name(createTranslationAdapter, "createTranslationAdapter");
+var DefaultTranslation = class {
+  static {
+    __name(this, "DefaultTranslation");
+  }
+  #resources = /* @__PURE__ */ new Map();
+  #options;
+  constructor(options) {
+    this.#options = options;
+    this.#resources.set(options.locale, create());
+    if (options.locale !== options.fallbackLocale) this.#resources.set(options.fallbackLocale, create());
+  }
+  getResource(locale) {
+    return this.#resources.get(locale);
+  }
+  setResource(locale, resource) {
+    this.#resources.set(locale, resource);
+  }
+  getMessage(locale, key) {
+    const resource = this.getResource(locale);
+    if (resource) return resource[key];
+    return void 0;
+  }
+  translate(locale, key, values = create()) {
+    let message = this.getMessage(locale, key);
+    if (message === void 0 && locale !== this.#options.fallbackLocale) message = this.getMessage(this.#options.fallbackLocale, key);
+    if (message === void 0) return;
+    return message.replaceAll(/\{\{(\w+)\}\}/g, (_, name) => {
+      return values[name] == null ? "" : values[name].toString();
+    });
+  }
+};
+var BUILT_IN_PREFIX_CODE = BUILT_IN_PREFIX.codePointAt(0);
+async function createCommandContext({ args, values, positionals, rest, argv, tokens, command, cliOptions, callMode = "entry", omitted = false }) {
+  const _args = Object.entries(args).reduce((acc, [key, value]) => {
+    acc[key] = Object.assign(create(), value);
+    return acc;
+  }, create());
+  const env = Object.assign(create(), COMMAND_OPTIONS_DEFAULT, cliOptions);
+  const locale = resolveLocale(cliOptions.locale);
+  const localeStr = locale.toString();
+  const translationAdapterFactory = cliOptions.translationAdapterFactory || createTranslationAdapter;
+  const adapter = translationAdapterFactory({
+    locale: localeStr,
+    fallbackLocale: DEFAULT_LOCALE
+  });
+  const localeResources = /* @__PURE__ */ new Map();
+  let builtInLoadedResources;
+  localeResources.set(DEFAULT_LOCALE, mapResourceWithBuiltinKey(en_US_default));
+  if (DEFAULT_LOCALE !== localeStr) try {
+    builtInLoadedResources = (await globImport_locales_json(`./locales/${localeStr}.json`)).default;
+    localeResources.set(localeStr, mapResourceWithBuiltinKey(builtInLoadedResources));
+  } catch {
+  }
+  function translate(key, values$1 = create()) {
+    const strKey = key;
+    if (strKey.codePointAt(0) === BUILT_IN_PREFIX_CODE) {
+      const resource = localeResources.get(localeStr) || localeResources.get(DEFAULT_LOCALE);
+      return resource[strKey] || strKey;
+    } else return adapter.translate(locale.toString(), strKey, values$1) || "";
+  }
+  __name(translate, "translate");
+  let cachedCommands;
+  async function loadCommands() {
+    if (cachedCommands) return cachedCommands;
+    const subCommands = [...cliOptions.subCommands || []];
+    return cachedCommands = await Promise.all(subCommands.map(async ([name, cmd]) => await resolveLazyCommand(cmd, name)));
+  }
+  __name(loadCommands, "loadCommands");
+  const ctx = deepFreeze(Object.assign(create(), {
+    name: getCommandName(command),
+    description: command.description,
+    omitted,
+    callMode,
+    locale,
+    env,
+    args: _args,
+    values,
+    positionals,
+    rest,
+    _: argv,
+    tokens,
+    toKebab: command.toKebab,
+    log: cliOptions.usageSilent ? NOOP : log,
+    loadCommands,
+    translate
+  }));
+  const loadedOptionsResources = Object.entries(args).map(([key, arg]) => {
+    const description = arg.description || "";
+    return [key, description];
+  });
+  const defaultCommandResource = loadedOptionsResources.reduce((res, [key, value]) => {
+    res[resolveArgKey(key)] = value;
+    return res;
+  }, create());
+  defaultCommandResource.description = command.description || "";
+  defaultCommandResource.examples = await resolveExamples(ctx, command.examples);
+  adapter.setResource(DEFAULT_LOCALE, defaultCommandResource);
+  const originalResource = await loadCommandResource(ctx, command);
+  if (originalResource) {
+    const resource = Object.assign(create(), originalResource, { examples: await resolveExamples(ctx, originalResource.examples) });
+    if (builtInLoadedResources) {
+      resource.help = builtInLoadedResources.help;
+      resource.version = builtInLoadedResources.version;
+    }
+    adapter.setResource(localeStr, resource);
+  }
+  return ctx;
+}
+__name(createCommandContext, "createCommandContext");
+function getCommandName(cmd) {
+  if (isLazyCommand(cmd)) return cmd.commandName || cmd.name || ANONYMOUS_COMMAND_NAME;
+  else if (typeof cmd === "object") return cmd.name || ANONYMOUS_COMMAND_NAME;
+  else return ANONYMOUS_COMMAND_NAME;
+}
+__name(getCommandName, "getCommandName");
+function resolveLocale(locale) {
+  return locale instanceof Intl.Locale ? locale : typeof locale === "string" ? new Intl.Locale(locale) : new Intl.Locale(DEFAULT_LOCALE);
+}
+__name(resolveLocale, "resolveLocale");
+async function loadCommandResource(ctx, command) {
+  let resource;
+  try {
+    resource = await command.resource?.(ctx);
+  } catch {
+  }
+  return resource;
+}
+__name(loadCommandResource, "loadCommandResource");
+
+// ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/utils-N7UlhLbz.js
+function kebabnize(str) {
+  return str.replace(/[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase());
+}
+__name(kebabnize, "kebabnize");
+
+// ../../node_modules/.pnpm/gunshi@0.26.3/node_modules/gunshi/lib/renderer-BzRfaLdJ.js
+function renderHeader(ctx) {
+  const title = ctx.env.description || ctx.env.name || "";
+  return Promise.resolve(title ? `${title} (${ctx.env.name || ""}${ctx.env.version ? ` v${ctx.env.version}` : ""})` : title);
+}
+__name(renderHeader, "renderHeader");
+var COMMON_ARGS_KEYS = Object.keys(COMMON_ARGS);
+async function renderUsage(ctx) {
+  const messages = [];
+  if (!ctx.omitted) {
+    const description = resolveDescription(ctx);
+    if (description) messages.push(description, "");
+  }
+  messages.push(...await renderUsageSection(ctx), "");
+  if (ctx.omitted && await hasCommands(ctx)) messages.push(...await renderCommandsSection(ctx), "");
+  if (hasPositionalArgs(ctx)) messages.push(...await renderPositionalArgsSection(ctx), "");
+  if (hasOptionalArgs(ctx)) messages.push(...await renderOptionalArgsSection(ctx), "");
+  const examples = await renderExamplesSection(ctx);
+  if (examples.length > 0) messages.push(...examples, "");
+  return messages.join("\n");
+}
+__name(renderUsage, "renderUsage");
+async function renderPositionalArgsSection(ctx) {
+  const messages = [];
+  messages.push(`${ctx.translate(resolveBuiltInKey("ARGUMENTS"))}:`);
+  messages.push(await generatePositionalArgsUsage(ctx));
+  return messages;
+}
+__name(renderPositionalArgsSection, "renderPositionalArgsSection");
+async function renderOptionalArgsSection(ctx) {
+  const messages = [];
+  messages.push(`${ctx.translate(resolveBuiltInKey("OPTIONS"))}:`);
+  messages.push(await generateOptionalArgsUsage(ctx, getOptionalArgsPairs(ctx)));
+  return messages;
+}
+__name(renderOptionalArgsSection, "renderOptionalArgsSection");
+async function renderExamplesSection(ctx) {
+  const messages = [];
+  const resolvedExamples = await resolveExamples$1(ctx);
+  if (resolvedExamples) {
+    const examples = resolvedExamples.split("\n").map((example) => example.padStart(ctx.env.leftMargin + example.length));
+    messages.push(`${ctx.translate(resolveBuiltInKey("EXAMPLES"))}:`, ...examples);
+  }
+  return messages;
+}
+__name(renderExamplesSection, "renderExamplesSection");
+async function renderUsageSection(ctx) {
+  const messages = [`${ctx.translate(resolveBuiltInKey("USAGE"))}:`];
+  if (ctx.omitted) {
+    const defaultCommand = `${resolveEntry(ctx)}${await hasCommands(ctx) ? ` [${resolveSubCommand(ctx)}]` : ""} ${[generateOptionsSymbols(ctx), generatePositionalSymbols(ctx)].filter(Boolean).join(" ")}`;
+    messages.push(defaultCommand.padStart(ctx.env.leftMargin + defaultCommand.length));
+    if (await hasCommands(ctx)) {
+      const commandsUsage = `${resolveEntry(ctx)} <${ctx.translate(resolveBuiltInKey("COMMANDS"))}>`;
+      messages.push(commandsUsage.padStart(ctx.env.leftMargin + commandsUsage.length));
+    }
+  } else {
+    const usageStr = `${resolveEntry(ctx)} ${resolveSubCommand(ctx)} ${[generateOptionsSymbols(ctx), generatePositionalSymbols(ctx)].filter(Boolean).join(" ")}`;
+    messages.push(usageStr.padStart(ctx.env.leftMargin + usageStr.length));
+  }
+  return messages;
+}
+__name(renderUsageSection, "renderUsageSection");
+async function renderCommandsSection(ctx) {
+  const messages = [`${ctx.translate(resolveBuiltInKey("COMMANDS"))}:`];
+  const loadedCommands = await ctx.loadCommands();
+  const commandMaxLength = Math.max(...loadedCommands.map((cmd) => (cmd.name || "").length));
+  const commandsStr = await Promise.all(loadedCommands.map((cmd) => {
+    const key = cmd.name || "";
+    const desc = cmd.description || "";
+    const command = `${key.padEnd(commandMaxLength + ctx.env.middleMargin)}${desc} `;
+    return `${command.padStart(ctx.env.leftMargin + command.length)} `;
+  }));
+  messages.push(...commandsStr, "", ctx.translate(resolveBuiltInKey("FORMORE")));
+  messages.push(...loadedCommands.map((cmd) => {
+    const commandHelp = `${ctx.env.name} ${cmd.name} --help`;
+    return `${commandHelp.padStart(ctx.env.leftMargin + commandHelp.length)}`;
+  }));
+  return messages;
+}
+__name(renderCommandsSection, "renderCommandsSection");
+function resolveEntry(ctx) {
+  return ctx.env.name || ctx.translate(resolveBuiltInKey("COMMAND"));
+}
+__name(resolveEntry, "resolveEntry");
+function resolveSubCommand(ctx) {
+  return ctx.name || ctx.translate(resolveBuiltInKey("SUBCOMMAND"));
+}
+__name(resolveSubCommand, "resolveSubCommand");
+function resolveDescription(ctx) {
+  return ctx.translate("description") || ctx.description || "";
+}
+__name(resolveDescription, "resolveDescription");
+async function resolveExamples$1(ctx) {
+  const ret = ctx.translate("examples");
+  if (ret) return ret;
+  const command = ctx.env.subCommands?.get(ctx.name || "");
+  return await resolveExamples(ctx, command?.examples);
+}
+__name(resolveExamples$1, "resolveExamples$1");
+async function hasCommands(ctx) {
+  const loadedCommands = await ctx.loadCommands();
+  return loadedCommands.length > 1;
+}
+__name(hasCommands, "hasCommands");
+function hasOptionalArgs(ctx) {
+  return !!(ctx.args && Object.values(ctx.args).some((arg) => arg.type !== "positional"));
+}
+__name(hasOptionalArgs, "hasOptionalArgs");
+function hasPositionalArgs(ctx) {
+  return !!(ctx.args && Object.values(ctx.args).some((arg) => arg.type === "positional"));
+}
+__name(hasPositionalArgs, "hasPositionalArgs");
+function hasAllDefaultOptions(ctx) {
+  return !!(ctx.args && Object.values(ctx.args).every((arg) => arg.default));
+}
+__name(hasAllDefaultOptions, "hasAllDefaultOptions");
+function generateOptionsSymbols(ctx) {
+  return hasOptionalArgs(ctx) ? hasAllDefaultOptions(ctx) ? `[${ctx.translate(resolveBuiltInKey("OPTIONS"))}]` : `<${ctx.translate(resolveBuiltInKey("OPTIONS"))}>` : "";
+}
+__name(generateOptionsSymbols, "generateOptionsSymbols");
+function makeShortLongOptionPair(schema, name, toKebab) {
+  const displayName = toKebab || schema.toKebab ? kebabnize(name) : name;
+  let key = `--${displayName}`;
+  if (schema.short) key = `-${schema.short}, ${key}`;
+  return key;
+}
+__name(makeShortLongOptionPair, "makeShortLongOptionPair");
+function getOptionalArgsPairs(ctx) {
+  return Object.entries(ctx.args).reduce((acc, [name, schema]) => {
+    if (schema.type === "positional") return acc;
+    let key = makeShortLongOptionPair(schema, name, ctx.toKebab);
+    if (schema.type !== "boolean") {
+      const displayName = ctx.toKebab || schema.toKebab ? kebabnize(name) : name;
+      key = schema.default ? `${key} [${displayName}]` : `${key} <${displayName}>`;
+    }
+    acc[name] = key;
+    if (schema.type === "boolean" && schema.negatable && !COMMON_ARGS_KEYS.includes(name)) {
+      const displayName = ctx.toKebab || schema.toKebab ? kebabnize(name) : name;
+      acc[`no-${name}`] = `--no-${displayName}`;
+    }
+    return acc;
+  }, create());
+}
+__name(getOptionalArgsPairs, "getOptionalArgsPairs");
+var resolveNegatableKey = /* @__PURE__ */ __name((key) => key.split("no-")[1], "resolveNegatableKey");
+function resolveNegatableType(key, ctx) {
+  return ctx.args[key.startsWith("no-") ? resolveNegatableKey(key) : key].type;
+}
+__name(resolveNegatableType, "resolveNegatableType");
+function generateDefaultDisplayValue(ctx, schema) {
+  return `${ctx.translate(resolveBuiltInKey("DEFAULT"))}: ${schema.default}`;
+}
+__name(generateDefaultDisplayValue, "generateDefaultDisplayValue");
+function resolveDisplayValue(ctx, key) {
+  if (COMMON_ARGS_KEYS.includes(key)) return "";
+  const schema = ctx.args[key];
+  if ((schema.type === "boolean" || schema.type === "number" || schema.type === "string" || schema.type === "custom") && schema.default !== void 0) return `(${generateDefaultDisplayValue(ctx, schema)})`;
+  if (schema.type === "enum") {
+    const _default = schema.default !== void 0 ? generateDefaultDisplayValue(ctx, schema) : "";
+    const choices = `${ctx.translate(resolveBuiltInKey("CHOICES"))}: ${schema.choices.join(" | ")}`;
+    return `(${_default ? `${_default}, ${choices}` : choices})`;
+  }
+  return "";
+}
+__name(resolveDisplayValue, "resolveDisplayValue");
+async function generateOptionalArgsUsage(ctx, optionsPairs) {
+  const optionsMaxLength = Math.max(...Object.entries(optionsPairs).map(([_, value]) => value.length));
+  const optionSchemaMaxLength = ctx.env.usageOptionType ? Math.max(...Object.entries(optionsPairs).map(([key]) => resolveNegatableType(key, ctx).length)) : 0;
+  const usages = await Promise.all(Object.entries(optionsPairs).map(([key, value]) => {
+    let rawDesc = ctx.translate(resolveArgKey(key));
+    if (!rawDesc && key.startsWith("no-")) {
+      const name = resolveNegatableKey(key);
+      const schema = ctx.args[name];
+      const optionKey = makeShortLongOptionPair(schema, name, ctx.toKebab);
+      rawDesc = `${ctx.translate(resolveBuiltInKey("NEGATABLE"))} ${optionKey}`;
+    }
+    const optionsSchema = ctx.env.usageOptionType ? `[${resolveNegatableType(key, ctx)}] ` : "";
+    const valueDesc = key.startsWith("no-") ? "" : resolveDisplayValue(ctx, key);
+    const desc = `${optionsSchema ? optionsSchema.padEnd(optionSchemaMaxLength + 3) : ""}${rawDesc}`;
+    const option = `${value.padEnd(optionsMaxLength + ctx.env.middleMargin)}${desc}${valueDesc ? ` ${valueDesc}` : ""}`;
+    return `${option.padStart(ctx.env.leftMargin + option.length)}`;
+  }));
+  return usages.join("\n");
+}
+__name(generateOptionalArgsUsage, "generateOptionalArgsUsage");
+function getPositionalArgs(ctx) {
+  return Object.entries(ctx.args).filter(([_, schema]) => schema.type === "positional");
+}
+__name(getPositionalArgs, "getPositionalArgs");
+async function generatePositionalArgsUsage(ctx) {
+  const positionals = getPositionalArgs(ctx);
+  const argsMaxLength = Math.max(...positionals.map(([name]) => name.length));
+  const usages = await Promise.all(positionals.map(([name]) => {
+    const desc = ctx.translate(resolveArgKey(name)) || ctx.args[name].description || "";
+    const arg = `${name.padEnd(argsMaxLength + ctx.env.middleMargin)} ${desc}`;
+    return `${arg.padStart(ctx.env.leftMargin + arg.length)}`;
+  }));
+  return usages.join("\n");
+}
+__name(generatePositionalArgsUsage, "generatePositionalArgsUsage");
+function generatePositionalSymbols(ctx) {
+  return hasPositionalArgs(ctx) ? getPositionalArgs(ctx).map(([name]) => `<${name}>`).join(" ") : "";
+}
+__name(generatePositionalSymbols, "generatePositionalSymbols");
+function renderValidationErrors(_ctx, error) {
+  const messages = [];
+  for (const err of error.errors) messages.push(err.message);
+  return Promise.resolve(messages.join("\n"));
+}
+__name(renderValidationErrors, "renderValidationErrors");
+
+// ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/parser-Dr4iAGaX.js
+var HYPHEN_CHAR = "-";
+var HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
+var EQUAL_CHAR = "=";
+var EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
+var TERMINATOR = "--";
+var SHORT_OPTION_PREFIX = HYPHEN_CHAR;
+var LONG_OPTION_PREFIX = "--";
+function parseArgs(args, options = {}) {
+  const { allowCompatible = false } = options;
+  const tokens = [];
+  const remainings = [...args];
+  let index = -1;
+  let groupCount = 0;
+  let hasShortValueSeparator = false;
+  while (remainings.length > 0) {
+    const arg = remainings.shift();
+    if (arg == void 0) break;
+    const nextArg = remainings[0];
+    if (groupCount > 0) groupCount--;
+    else index++;
+    if (arg === TERMINATOR) {
+      tokens.push({
+        kind: "option-terminator",
+        index
+      });
+      const mapped = remainings.map((arg$1) => {
+        return {
+          kind: "positional",
+          index: ++index,
+          value: arg$1
+        };
+      });
+      tokens.push(...mapped);
+      break;
+    }
+    if (isShortOption(arg)) {
+      const shortOption = arg.charAt(1);
+      let value;
+      let inlineValue;
+      if (groupCount) {
+        tokens.push({
+          kind: "option",
+          name: shortOption,
+          rawName: arg,
+          index,
+          value,
+          inlineValue
+        });
+        if (groupCount === 1 && hasOptionValue(nextArg)) {
+          value = remainings.shift();
+          if (hasShortValueSeparator) {
+            inlineValue = true;
+            hasShortValueSeparator = false;
+          }
+          tokens.push({
+            kind: "option",
+            index,
+            value,
+            inlineValue
+          });
+        }
+      } else tokens.push({
+        kind: "option",
+        name: shortOption,
+        rawName: arg,
+        index,
+        value,
+        inlineValue
+      });
+      if (value != null) ++index;
+      continue;
+    }
+    if (isShortOptionGroup(arg)) {
+      const expanded = [];
+      let shortValue = "";
+      for (let i = 1; i < arg.length; i++) {
+        const shortableOption = arg.charAt(i);
+        if (hasShortValueSeparator) shortValue += shortableOption;
+        else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) hasShortValueSeparator = true;
+        else expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
+      }
+      if (shortValue) expanded.push(shortValue);
+      remainings.unshift(...expanded);
+      groupCount = expanded.length;
+      continue;
+    }
+    if (isLongOption(arg)) {
+      const longOption = arg.slice(2);
+      tokens.push({
+        kind: "option",
+        name: longOption,
+        rawName: arg,
+        index,
+        value: void 0,
+        inlineValue: void 0
+      });
+      continue;
+    }
+    if (isLongOptionAndValue(arg)) {
+      const equalIndex = arg.indexOf(EQUAL_CHAR);
+      const longOption = arg.slice(2, equalIndex);
+      const value = arg.slice(equalIndex + 1);
+      tokens.push({
+        kind: "option",
+        name: longOption,
+        rawName: `${LONG_OPTION_PREFIX}${longOption}`,
+        index,
+        value,
+        inlineValue: true
+      });
+      continue;
+    }
+    tokens.push({
+      kind: "positional",
+      index,
+      value: arg
+    });
+  }
+  return tokens;
+}
+__name(parseArgs, "parseArgs");
+function isShortOption(arg) {
+  return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
+}
+__name(isShortOption, "isShortOption");
+function isShortOptionGroup(arg) {
+  if (arg.length <= 2) return false;
+  if (arg.codePointAt(0) !== HYPHEN_CODE) return false;
+  if (arg.codePointAt(1) === HYPHEN_CODE) return false;
+  return true;
+}
+__name(isShortOptionGroup, "isShortOptionGroup");
+function isLongOption(arg) {
+  return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
+}
+__name(isLongOption, "isLongOption");
+function isLongOptionAndValue(arg) {
+  return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
+}
+__name(isLongOptionAndValue, "isLongOptionAndValue");
+function hasLongOptionPrefix(arg) {
+  return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
+}
+__name(hasLongOptionPrefix, "hasLongOptionPrefix");
+function hasOptionValue(value) {
+  return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
+}
+__name(hasOptionValue, "hasOptionValue");
+
+// ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/resolver-Q4k2fgTW.js
+var SKIP_POSITIONAL_DEFAULT = -1;
+function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKIP_POSITIONAL_DEFAULT, toKebab = false } = {}) {
+  const skipPositionalIndex = typeof skipPositional === "number" ? Math.max(skipPositional, SKIP_POSITIONAL_DEFAULT) : SKIP_POSITIONAL_DEFAULT;
+  const rest = [];
+  const optionTokens = [];
+  const positionalTokens = [];
+  let currentLongOption;
+  let currentShortOption;
+  const expandableShortOptions = [];
+  function toShortValue() {
+    if (expandableShortOptions.length === 0) return void 0;
+    else {
+      const value = expandableShortOptions.map((token) => token.name).join("");
+      expandableShortOptions.length = 0;
+      return value;
+    }
+  }
+  __name(toShortValue, "toShortValue");
+  function applyLongOptionValue(value = void 0) {
+    if (currentLongOption) {
+      currentLongOption.value = value;
+      optionTokens.push({ ...currentLongOption });
+      currentLongOption = void 0;
+    }
+  }
+  __name(applyLongOptionValue, "applyLongOptionValue");
+  function applyShortOptionValue(value = void 0) {
+    if (currentShortOption) {
+      currentShortOption.value = value || toShortValue();
+      optionTokens.push({ ...currentShortOption });
+      currentShortOption = void 0;
+    }
+  }
+  __name(applyShortOptionValue, "applyShortOptionValue");
+  const schemas = Object.values(args);
+  let terminated = false;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.kind === "positional") {
+      if (terminated && token.value) {
+        rest.push(token.value);
+        continue;
+      }
+      if (currentShortOption) {
+        const found = schemas.find((schema) => schema.short === currentShortOption.name && schema.type === "boolean");
+        if (found) positionalTokens.push({ ...token });
+      } else if (currentLongOption) {
+        const found = args[currentLongOption.name]?.type === "boolean";
+        if (found) positionalTokens.push({ ...token });
+      } else positionalTokens.push({ ...token });
+      applyLongOptionValue(token.value);
+      applyShortOptionValue(token.value);
+    } else if (token.kind === "option") if (token.rawName) {
+      if (hasLongOptionPrefix(token.rawName)) {
+        applyLongOptionValue();
+        if (token.inlineValue) optionTokens.push({ ...token });
+        else currentLongOption = { ...token };
+        applyShortOptionValue();
+      } else if (isShortOption(token.rawName)) if (currentShortOption) {
+        if (currentShortOption.index === token.index) if (shortGrouping) {
+          currentShortOption.value = token.value;
+          optionTokens.push({ ...currentShortOption });
+          currentShortOption = { ...token };
+        } else expandableShortOptions.push({ ...token });
+        else {
+          currentShortOption.value = toShortValue();
+          optionTokens.push({ ...currentShortOption });
+          currentShortOption = { ...token };
+        }
+        applyLongOptionValue();
+      } else {
+        currentShortOption = { ...token };
+        applyLongOptionValue();
+      }
+    } else {
+      if (currentShortOption && currentShortOption.index == token.index && token.inlineValue) {
+        currentShortOption.value = token.value;
+        optionTokens.push({ ...currentShortOption });
+        currentShortOption = void 0;
+      }
+      applyLongOptionValue();
+    }
+    else {
+      if (token.kind === "option-terminator") terminated = true;
+      applyLongOptionValue();
+      applyShortOptionValue();
+    }
+  }
+  applyLongOptionValue();
+  applyShortOptionValue();
+  const values = /* @__PURE__ */ Object.create(null);
+  const errors = [];
+  function checkTokenName(option, schema, token) {
+    return token.name === (schema.type === "boolean" ? schema.negatable && token.name?.startsWith("no-") ? `no-${option}` : option : option);
+  }
+  __name(checkTokenName, "checkTokenName");
+  const positionalItemCount = tokens.filter((token) => token.kind === "positional").length;
+  function getPositionalSkipIndex() {
+    return Math.min(skipPositionalIndex, positionalItemCount);
+  }
+  __name(getPositionalSkipIndex, "getPositionalSkipIndex");
+  let positionalsCount = 0;
+  for (const [rawArg, schema] of Object.entries(args)) {
+    const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+    if (schema.required) {
+      const found = optionTokens.find((token) => {
+        return schema.short && token.name === schema.short || token.rawName && hasLongOptionPrefix(token.rawName) && token.name === arg;
+      });
+      if (!found) {
+        errors.push(createRequireError(arg, schema));
+        continue;
+      }
+    }
+    if (schema.type === "positional") {
+      if (skipPositionalIndex > SKIP_POSITIONAL_DEFAULT) while (positionalsCount <= getPositionalSkipIndex()) positionalsCount++;
+      const positional = positionalTokens[positionalsCount];
+      if (positional != null) values[rawArg] = positional.value;
+      else errors.push(createRequireError(arg, schema));
+      positionalsCount++;
+      continue;
+    }
+    for (let i = 0; i < optionTokens.length; i++) {
+      const token = optionTokens[i];
+      if (checkTokenName(arg, schema, token) && token.rawName != void 0 && hasLongOptionPrefix(token.rawName) || schema.short === token.name && token.rawName != void 0 && isShortOption(token.rawName)) {
+        const invalid = validateRequire(token, arg, schema);
+        if (invalid) {
+          errors.push(invalid);
+          continue;
+        }
+        if (schema.type === "boolean") token.value = void 0;
+        const [parsedValue, error] = parse(token, arg, schema);
+        if (error) errors.push(error);
+        else if (schema.multiple) {
+          values[rawArg] ||= [];
+          values[rawArg].push(parsedValue);
+        } else values[rawArg] = parsedValue;
+      }
+    }
+    if (values[rawArg] == null && schema.default != null) values[rawArg] = schema.default;
+  }
+  return {
+    values,
+    positionals: positionalTokens.map((token) => token.value),
+    rest,
+    error: errors.length > 0 ? new AggregateError(errors) : void 0
+  };
+}
+__name(resolveArgs, "resolveArgs");
+function parse(token, option, schema) {
+  switch (schema.type) {
+    case "string":
+      return typeof token.value === "string" ? [token.value || schema.default, void 0] : [void 0, createTypeError(option, schema)];
+    case "boolean":
+      return token.value ? [token.value || schema.default, void 0] : [!(schema.negatable && token.name.startsWith("no-")), void 0];
+    case "number": {
+      if (!isNumeric(token.value)) return [void 0, createTypeError(option, schema)];
+      return token.value ? [+token.value, void 0] : [+(schema.default || ""), void 0];
+    }
+    case "enum": {
+      if (schema.choices && !schema.choices.includes(token.value)) return [void 0, new ArgResolveError(`Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be chosen from '${schema.type}' [${schema.choices.map((c) => JSON.stringify(c)).join(", ")}] values`, option, "type", schema)];
+      return [token.value || schema.default, void 0];
+    }
+    case "custom": {
+      if (typeof schema.parse !== "function") throw new TypeError(`argument '${option}' should have a 'parse' function`);
+      try {
+        return [schema.parse(token.value || String(schema.default || "")), void 0];
+      } catch (error) {
+        return [void 0, error];
+      }
+    }
+    default:
+      throw new Error(`Unsupported argument type '${schema.type}' for option '${option}'`);
+  }
+}
+__name(parse, "parse");
+function createRequireError(option, schema) {
+  const message = schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`;
+  return new ArgResolveError(message, option, "required", schema);
+}
+__name(createRequireError, "createRequireError");
+var ArgResolveError = class extends Error {
+  static {
+    __name(this, "ArgResolveError");
+  }
+  name;
+  schema;
+  type;
+  constructor(message, name, type, schema) {
+    super(message);
+    this.name = name;
+    this.type = type;
+    this.schema = schema;
+  }
+};
+function validateRequire(token, option, schema) {
+  if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(option, schema);
+}
+__name(validateRequire, "validateRequire");
+function isNumeric(str) {
+  return str.trim() !== "" && !isNaN(str);
+}
+__name(isNumeric, "isNumeric");
+function createTypeError(option, schema) {
+  return new ArgResolveError(`Optional argument '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be '${schema.type}'`, option, "type", schema);
+}
+__name(createTypeError, "createTypeError");
+
+// ../../node_modules/.pnpm/gunshi@0.26.3/node_modules/gunshi/lib/cli-DVGNVw3h.js
+async function cli(argv, entry, options = {}) {
+  const cliOptions = resolveCliOptions(options, entry);
+  const tokens = parseArgs(argv);
+  const subCommand = getSubCommand(tokens);
+  const { commandName: name, command, callMode } = await resolveCommand(subCommand, entry, cliOptions);
+  if (!command) throw new Error(`Command not found: ${name || ""}`);
+  const args = resolveArguments(getCommandArgs(command));
+  const { values, positionals, rest, error } = resolveArgs(args, tokens, {
+    shortGrouping: true,
+    toKebab: command.toKebab,
+    skipPositional: cliOptions.subCommands.size > 0 ? 0 : -1
+  });
+  const omitted = !subCommand;
+  const ctx = await createCommandContext({
+    args,
+    values,
+    positionals,
+    rest,
+    argv,
+    tokens,
+    omitted,
+    callMode,
+    command,
+    cliOptions
+  });
+  if (values.version) {
+    showVersion(ctx);
+    return;
+  }
+  const usageBuffer = [];
+  const header = await showHeader(ctx);
+  if (header) usageBuffer.push(header);
+  if (values.help) {
+    const usage = await showUsage(ctx);
+    if (usage) usageBuffer.push(usage);
+    return usageBuffer.join("\n");
+  }
+  if (error) {
+    await showValidationErrors(ctx, error);
+    return;
+  }
+  await executeCommand(command, ctx, name || "");
+}
+__name(cli, "cli");
+function getCommandArgs(cmd) {
+  if (isLazyCommand(cmd)) return cmd.args || create();
+  else if (typeof cmd === "object") return cmd.args || create();
+  else return create();
+}
+__name(getCommandArgs, "getCommandArgs");
+function resolveArguments(args) {
+  return Object.assign(create(), args, COMMON_ARGS);
+}
+__name(resolveArguments, "resolveArguments");
+function resolveCliOptions(options, entry) {
+  const subCommands = new Map(options.subCommands);
+  if (options.subCommands) {
+    if (isLazyCommand(entry)) subCommands.set(entry.commandName, entry);
+    else if (typeof entry === "object" && entry.name) subCommands.set(entry.name, entry);
+  }
+  const resolvedOptions = Object.assign(create(), COMMAND_OPTIONS_DEFAULT, options, { subCommands });
+  return resolvedOptions;
+}
+__name(resolveCliOptions, "resolveCliOptions");
+function getSubCommand(tokens) {
+  const firstToken = tokens[0];
+  return firstToken && firstToken.kind === "positional" && firstToken.index === 0 && firstToken.value ? firstToken.value : "";
+}
+__name(getSubCommand, "getSubCommand");
+async function showUsage(ctx) {
+  if (ctx.env.renderUsage === null) return;
+  const usage = await (ctx.env.renderUsage || renderUsage)(ctx);
+  if (usage) {
+    ctx.log(usage);
+    return usage;
+  }
+}
+__name(showUsage, "showUsage");
+function showVersion(ctx) {
+  ctx.log(ctx.env.version);
+}
+__name(showVersion, "showVersion");
+async function showHeader(ctx) {
+  if (ctx.env.renderHeader === null) return;
+  const header = await (ctx.env.renderHeader || renderHeader)(ctx);
+  if (header) {
+    ctx.log(header);
+    ctx.log();
+    return header;
+  }
+}
+__name(showHeader, "showHeader");
+async function showValidationErrors(ctx, error) {
+  if (ctx.env.renderValidationErrors === null) return;
+  const render = ctx.env.renderValidationErrors || renderValidationErrors;
+  ctx.log(await render(ctx, error));
+}
+__name(showValidationErrors, "showValidationErrors");
+var CANNOT_RESOLVE_COMMAND = { callMode: "unexpected" };
+async function resolveCommand(sub, entry, options) {
+  const omitted = !sub;
+  async function doResolveCommand() {
+    if (typeof entry === "function") if ("commandName" in entry && entry.commandName) return {
+      commandName: entry.commandName,
+      command: entry,
+      callMode: "entry"
+    };
+    else return {
+      command: { run: entry },
+      callMode: "entry"
+    };
+    else if (typeof entry === "object") return {
+      commandName: resolveEntryName(entry),
+      command: entry,
+      callMode: "entry"
+    };
+    else return CANNOT_RESOLVE_COMMAND;
+  }
+  __name(doResolveCommand, "doResolveCommand");
+  if (omitted || options.subCommands?.size === 0) return doResolveCommand();
+  const cmd = options.subCommands?.get(sub);
+  if (cmd == null) return {
+    commandName: sub,
+    callMode: "unexpected"
+  };
+  if (isLazyCommand(cmd) && cmd.commandName == null) cmd.commandName = sub;
+  else if (typeof cmd === "object" && cmd.name == null) cmd.name = sub;
+  return {
+    commandName: sub,
+    command: cmd,
+    callMode: "subCommand"
+  };
+}
+__name(resolveCommand, "resolveCommand");
+function resolveEntryName(entry) {
+  return entry.name || ANONYMOUS_COMMAND_NAME;
+}
+__name(resolveEntryName, "resolveEntryName");
+async function executeCommand(cmd, ctx, name) {
+  const resolved = isLazyCommand(cmd) ? await resolveLazyCommand(cmd, name, true) : cmd;
+  if (resolved.run == null) throw new Error(`'run' not found on Command \`${name}\``);
+  await resolved.run(ctx);
+}
+__name(executeCommand, "executeCommand");
+/*! Bundled license information:
+
+args-tokens/lib/utils-N7UlhLbz.js:
+  (**
+  * @author kazuya kawaguchi (a.k.a. kazupon)
+  * @license MIT
+  *)
+*/
+
+export { cli, define };
+//# sourceMappingURL=chunk-33ROL4J5.js.map
+//# sourceMappingURL=chunk-33ROL4J5.js.map