zod-args-parser 2.0.0-beta.1 → 2.0.0-beta.2

package/lib/mjs/parse/context/object-context-builder.mjs

@@ -1,2 +1,62 @@
-function buildObjectContext(o,e){const t={subcommand:"cliName"in e?void 0:e.name};return e.options&&buildForOptionsOrArguments(e.options,t,o.options,"options"),e.arguments&&buildForOptionsOrArguments(e.arguments,t,o.arguments,"arguments"),e.allowPositionals&&(t.positionals??(t.positionals=o.positionals)),t}function buildForOptionsOrArguments(o,e,t,n){const i=Object.entries(o);for(const[o,r]of i){if(!r._preparedType)throw new Error(`internal error: missing prepared type for ${n.slice(0,-1)} "${o}"`);const{schema:i,optional:s,defaultValue:a}=r._preparedType;if(t&&o in t){const r=t[o];e[n]??(e[n]={}),e[n][o]=void 0===r?{schema:i,optional:s,defaultValue:a,source:"default"}:{schema:i,optional:s,defaultValue:a,passedValue:r,source:"programmatic"};continue}if(!s)throw new Error(`the ${n.slice(0,-1)} "${o}" is required`);e[n]??(e[n]={}),e[n][o]={schema:i,optional:s,defaultValue:a,source:"default"}}}export{buildObjectContext};
-//# sourceMappingURL=object-context-builder.mjs.map
+// src/parse/context/object-context-builder.ts
+import { CliError } from "../../cli-error/cli-error.mjs";
+import { ErrorCause } from "../../cli-error/error-cause.mjs";
+import { InternalErrorCode } from "../../cli-error/error-code/internal-error-code.mjs";
+import { ParseErrorCode } from "../../cli-error/error-code/parse-error-code.mjs";
+function buildObjectContext(inputValues, commandDefinition) {
+  const context = {
+    subcommand: "cliName" in commandDefinition ? void 0 : commandDefinition.name
+  };
+  buildForOptionsOrArguments(commandDefinition, context, inputValues.options, "options");
+  buildForOptionsOrArguments(commandDefinition, context, inputValues.arguments, "arguments");
+  if (commandDefinition.allowPositionals) {
+    context.positionals ??= inputValues.positionals;
+  }
+  return context;
+}
+function buildForOptionsOrArguments(commandDefinition, context, inputRecord, type) {
+  if (!commandDefinition[type]) return;
+  const optionOrArgumentDefinitions = commandDefinition[type];
+  const kind = type.slice(0, -1);
+  const commandKind = "cliName" in commandDefinition ? "command" : "subcommand";
+  const commandName = "cliName" in commandDefinition ? commandDefinition.cliName : commandDefinition.name;
+  const definitionEntries = Object.entries(optionOrArgumentDefinitions);
+  for (const [name, definition] of definitionEntries) {
+    if (!definition._preparedType) {
+      throw new CliError({
+        cause: ErrorCause.Internal,
+        code: InternalErrorCode.MissingPreparedTypes,
+        context: { commandKind, commandName, kind, name }
+      });
+    }
+    const { schema, optional, defaultValue } = definition._preparedType;
+    if (inputRecord && name in inputRecord) {
+      const passedValue = inputRecord[name];
+      context[type] ??= {};
+      context[type][name] = passedValue === void 0 ? { schema, optional, defaultValue, source: "default" } : { schema, optional, defaultValue, passedValue, source: "programmatic" };
+      continue;
+    }
+    if (!optional) {
+      if (kind === "option") {
+        throw new CliError({
+          cause: ErrorCause.Parse,
+          code: ParseErrorCode.MissingRequiredOption,
+          context: { commandKind, commandName, optionName: name }
+        });
+      }
+      if (kind === "argument") {
+        throw new CliError({
+          cause: ErrorCause.Parse,
+          code: ParseErrorCode.MissingRequiredArgument,
+          context: { commandKind, commandName, argumentName: name }
+        });
+      }
+    }
+    context[type] ??= {};
+    context[type][name] = { schema, optional, defaultValue, source: "default" };
+  }
+}
+export {
+  buildObjectContext
+};
+//# sourceMappingURL=object-context-builder.mjs.map

package/lib/mjs/parse/context/object-context-builder.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["buildObjectContext","inputValues","commandDefinition","context","subcommand","name","options","buildForOptionsOrArguments","arguments","allowPositionals","positionals","definitionRecord","inputRecord","type","definitionEntries","Object","entries","definition","_preparedType","Error","slice","schema","optional","defaultValue","passedValue","source"],"sources":["../../../../src/parse/context/object-context-builder.ts"],"sourcesContent":["import type { ContextWide } from \"../../types/context-types.ts\";\nimport type { Argument, Cli, Option, Subcommand } from \"../../types/definitions-types.ts\";\nimport type { InputTypeWide } from \"../../types/io-types.ts\";\n\n/** @throws {Error} */\nexport function buildObjectContext(inputValues: InputTypeWide, commandDefinition: Subcommand | Cli) {\n  const context: ContextWide = {\n    subcommand: \"cliName\" in commandDefinition ? undefined : commandDefinition.name,\n  };\n\n  if (commandDefinition.options) {\n    buildForOptionsOrArguments(commandDefinition.options, context, inputValues.options, \"options\");\n  }\n\n  if (commandDefinition.arguments) {\n    buildForOptionsOrArguments(commandDefinition.arguments, context, inputValues.arguments, \"arguments\");\n  }\n\n  if (commandDefinition.allowPositionals) {\n    context.positionals ??= inputValues.positionals;\n  }\n\n  return context;\n}\n\nfunction buildForOptionsOrArguments(\n  definitionRecord: Record<string, Option> | Record<string, Argument>,\n  context: ContextWide,\n  inputRecord: Record<string, unknown> | undefined,\n  type: \"options\" | \"arguments\",\n) {\n  const definitionEntries = Object.entries(definitionRecord) as [string, Option][] | [string, Argument][];\n\n  for (const [name, definition] of definitionEntries) {\n    if (!definition._preparedType) {\n      throw new Error(`internal error: missing prepared type for ${type.slice(0, -1)} \"${name}\"`);\n    }\n\n    const { schema, optional, defaultValue } = definition._preparedType;\n\n    // Case the value is passed\n    if (inputRecord && name in inputRecord) {\n      const passedValue = inputRecord[name];\n\n      context[type] ??= {};\n      context[type][name] =\n        passedValue === undefined\n          ? { schema, optional, defaultValue, source: \"default\" }\n          : { schema, optional, defaultValue, passedValue, source: \"programmatic\" };\n\n      continue;\n    }\n\n    // case the value is not passed\n    if (!optional) {\n      throw new Error(`the ${type.slice(0, -1)} \"${name}\" is required`);\n    }\n\n    // case the value is optional\n    context[type] ??= {};\n    context[type][name] = { schema, optional, defaultValue, source: \"default\" };\n  }\n}\n"],"mappings":"AAKO,SAASA,mBAAmBC,EAA4BC,GAC7D,MAAMC,EAAuB,CAC3BC,WAAY,YAAaF,OAAoB,EAAYA,EAAkBG,MAe7E,OAZIH,EAAkBI,SACpBC,2BAA2BL,EAAkBI,QAASH,EAASF,EAAYK,QAAS,WAGlFJ,EAAkBM,WACpBD,2BAA2BL,EAAkBM,UAAWL,EAASF,EAAYO,UAAW,aAGtFN,EAAkBO,mBACpBN,EAAQO,cAARP,EAAQO,YAAgBT,EAAYS,cAG/BP,CACT,CAEA,SAASI,2BACPI,EACAR,EACAS,EACAC,GAEA,MAAMC,EAAoBC,OAAOC,QAAQL,GAEzC,UAAYN,EAAMY,KAAeH,EAAmB,CAClD,IAAKG,EAAWC,cACd,MAAM,IAAIC,MAAM,6CAA6CN,EAAKO,MAAM,GAAG,OAAQf,MAGrF,MAAMgB,OAAEA,EAAAC,SAAQA,EAAAC,aAAUA,GAAiBN,EAAWC,cAGtD,GAAIN,GAAeP,KAAQO,EAAa,CACtC,MAAMY,EAAcZ,EAAYP,GAEhCF,EAAAU,KAAAV,EAAAU,GAAkB,CAAC,GACnBV,EAAQU,GAAMR,QACI,IAAhBmB,EACI,CAAEH,SAAQC,WAAUC,eAAcE,OAAQ,WAC1C,CAAEJ,SAAQC,WAAUC,eAAcC,cAAaC,OAAQ,gBAE7D,QACF,CAGA,IAAKH,EACH,MAAM,IAAIH,MAAM,OAAON,EAAKO,MAAM,GAAG,OAAQf,kBAI/CF,EAAAU,KAAAV,EAAAU,GAAkB,CAAC,GACnBV,EAAQU,GAAMR,GAAQ,CAAEgB,SAAQC,WAAUC,eAAcE,OAAQ,UAClE,CACF,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../../src/parse/context/object-context-builder.ts"],
+  "sourcesContent": ["import { CliError } from \"../../cli-error/cli-error.ts\";\nimport { ErrorCause } from \"../../cli-error/error-cause.ts\";\nimport { InternalErrorCode } from \"../../cli-error/error-code/internal-error-code.ts\";\nimport { ParseErrorCode } from \"../../cli-error/error-code/parse-error-code.ts\";\n\nimport type { ContextWide } from \"../../types/context-types.ts\";\nimport type { Argument, Cli, Option, Subcommand } from \"../../types/definitions-types.ts\";\nimport type { InputTypeWide } from \"../../types/io-types.ts\";\n\n/** @throws {CliError} */\nexport function buildObjectContext(inputValues: InputTypeWide, commandDefinition: Subcommand | Cli) {\n  const context: ContextWide = {\n    subcommand: \"cliName\" in commandDefinition ? undefined : commandDefinition.name,\n  };\n\n  buildForOptionsOrArguments(commandDefinition, context, inputValues.options, \"options\");\n\n  buildForOptionsOrArguments(commandDefinition, context, inputValues.arguments, \"arguments\");\n\n  if (commandDefinition.allowPositionals) {\n    context.positionals ??= inputValues.positionals;\n  }\n\n  return context;\n}\n\nfunction buildForOptionsOrArguments(\n  commandDefinition: Subcommand | Cli,\n  context: ContextWide,\n  inputRecord: Record<string, unknown> | undefined,\n  type: \"options\" | \"arguments\",\n) {\n  if (!commandDefinition[type]) return;\n\n  const optionOrArgumentDefinitions = commandDefinition[type];\n  const kind = type.slice(0, -1) as \"option\" | \"argument\";\n  const commandKind = \"cliName\" in commandDefinition ? \"command\" : \"subcommand\";\n  const commandName = \"cliName\" in commandDefinition ? commandDefinition.cliName : commandDefinition.name;\n\n  const definitionEntries = Object.entries(optionOrArgumentDefinitions) as [string, Option][] | [string, Argument][];\n\n  for (const [name, definition] of definitionEntries) {\n    if (!definition._preparedType) {\n      throw new CliError({\n        cause: ErrorCause.Internal,\n        code: InternalErrorCode.MissingPreparedTypes,\n        context: { commandKind, commandName, kind, name },\n      });\n    }\n\n    const { schema, optional, defaultValue } = definition._preparedType;\n\n    // Case the value is passed\n    if (inputRecord && name in inputRecord) {\n      const passedValue = inputRecord[name];\n\n      context[type] ??= {};\n      context[type][name] =\n        passedValue === undefined\n          ? { schema, optional, defaultValue, source: \"default\" }\n          : { schema, optional, defaultValue, passedValue, source: \"programmatic\" };\n\n      continue;\n    }\n\n    // case the value is not passed\n    if (!optional) {\n      if (kind === \"option\") {\n        throw new CliError({\n          cause: ErrorCause.Parse,\n          code: ParseErrorCode.MissingRequiredOption,\n          context: { commandKind, commandName, optionName: name },\n        });\n      }\n\n      if (kind === \"argument\") {\n        throw new CliError({\n          cause: ErrorCause.Parse,\n          code: ParseErrorCode.MissingRequiredArgument,\n          context: { commandKind, commandName, argumentName: name },\n        });\n      }\n    }\n\n    // case the value is optional\n    context[type] ??= {};\n    context[type][name] = { schema, optional, defaultValue, source: \"default\" };\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,yBAAyB;AAClC,SAAS,sBAAsB;AAOxB,SAAS,mBAAmB,aAA4B,mBAAqC;AAClG,QAAM,UAAuB;AAAA,IAC3B,YAAY,aAAa,oBAAoB,SAAY,kBAAkB;AAAA,EAC7E;AAEA,6BAA2B,mBAAmB,SAAS,YAAY,SAAS,SAAS;AAErF,6BAA2B,mBAAmB,SAAS,YAAY,WAAW,WAAW;AAEzF,MAAI,kBAAkB,kBAAkB;AACtC,YAAQ,gBAAgB,YAAY;AAAA,EACtC;AAEA,SAAO;AACT;AAEA,SAAS,2BACP,mBACA,SACA,aACA,MACA;AACA,MAAI,CAAC,kBAAkB,IAAI,EAAG;AAE9B,QAAM,8BAA8B,kBAAkB,IAAI;AAC1D,QAAM,OAAO,KAAK,MAAM,GAAG,EAAE;AAC7B,QAAM,cAAc,aAAa,oBAAoB,YAAY;AACjE,QAAM,cAAc,aAAa,oBAAoB,kBAAkB,UAAU,kBAAkB;AAEnG,QAAM,oBAAoB,OAAO,QAAQ,2BAA2B;AAEpE,aAAW,CAAC,MAAM,UAAU,KAAK,mBAAmB;AAClD,QAAI,CAAC,WAAW,eAAe;AAC7B,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,kBAAkB;AAAA,QACxB,SAAS,EAAE,aAAa,aAAa,MAAM,KAAK;AAAA,MAClD,CAAC;AAAA,IACH;AAEA,UAAM,EAAE,QAAQ,UAAU,aAAa,IAAI,WAAW;AAGtD,QAAI,eAAe,QAAQ,aAAa;AACtC,YAAM,cAAc,YAAY,IAAI;AAEpC,cAAQ,IAAI,MAAM,CAAC;AACnB,cAAQ,IAAI,EAAE,IAAI,IAChB,gBAAgB,SACZ,EAAE,QAAQ,UAAU,cAAc,QAAQ,UAAU,IACpD,EAAE,QAAQ,UAAU,cAAc,aAAa,QAAQ,eAAe;AAE5E;AAAA,IACF;AAGA,QAAI,CAAC,UAAU;AACb,UAAI,SAAS,UAAU;AACrB,cAAM,IAAI,SAAS;AAAA,UACjB,OAAO,WAAW;AAAA,UAClB,MAAM,eAAe;AAAA,UACrB,SAAS,EAAE,aAAa,aAAa,YAAY,KAAK;AAAA,QACxD,CAAC;AAAA,MACH;AAEA,UAAI,SAAS,YAAY;AACvB,cAAM,IAAI,SAAS;AAAA,UACjB,OAAO,WAAW;AAAA,UAClB,MAAM,eAAe;AAAA,UACrB,SAAS,EAAE,aAAa,aAAa,cAAc,KAAK;AAAA,QAC1D,CAAC;AAAA,MACH;AAAA,IACF;AAGA,YAAQ,IAAI,MAAM,CAAC;AACnB,YAAQ,IAAI,EAAE,IAAI,IAAI,EAAE,QAAQ,UAAU,cAAc,QAAQ,UAAU;AAAA,EAC5E;AACF;",
+  "names": []
+}

package/lib/mjs/parse/parser-utilities.mjs

@@ -1,2 +1,108 @@
-function findSubcommandDefinition(e,n){return void 0===e?n:n.subcommands?n.subcommands.find(n=>n.name===e||e&&n.aliases&&n.aliases.includes(e)):void 0}function findOption(e,n){const t=optionArgumentToVariableNames(e),o=e.startsWith("--no-");return Object.entries(n).find(([e,n])=>{if(t.has(e))return!0;const a=n._preparedType&&"boolean"===n._preparedType.coerceTo;return!!(o&&a&&t.has(negateOption(e)))||!!n.aliases&&(!!n.aliases.some(e=>t.has(e))||!!(o&&a&&n.aliases.map(e=>negateOption(e)).some(e=>t.has(e))))})}function decoupleFlags(e){const n=/^-[a-z0-9]{2,}$/i,t=[];for(const o of e){if(!n.test(o)){t.push(o);continue}const e=o.slice(1).split("").map(e=>"-"+e);t.push(...e)}return t}function optionArgumentToVariableNames(e){if(!e.startsWith("-"))throw new Error(`invalid option name: ${e}`);e=(e=e.startsWith("--")?e.slice(2):e.slice(1)).toLowerCase();const n=new Set,t=e.replace(/-(.)/g,e=>e[1].toUpperCase());n.add(t),n.add(t.replace(/^(.)/,e=>e.toUpperCase()));const o=e.replace(/-(.)/g,e=>"_"+e[1]);return n.add(o),n.add(o.toUpperCase()),n}function isFlagArgument(e){return/^-[A-Za-z]$/.test(e)}function isLongArgument(e){return/^--[A-Za-z-]+[A-Za-z0-9]$/.test(e)}function isOptionArgument(e){return"string"==typeof e&&(isFlagArgument(e)||isLongArgument(e))}function negateOption(e){return"no"+e.replace(/^[a-z]/,e=>e.toUpperCase())}function transformOptionToArgument(e){return 1===e.length?`-${e.toLowerCase()}`:/^[a-z_]+$/.test(e)||/^[A-Z_]+$/.test(e)?`--${(e=e.replace(/_/g,"-")).toLowerCase()}`:`--${(e=e.replace(/[A-Z]/g,(e,n)=>n>0?"-"+e:e)).toLowerCase()}`}export{decoupleFlags,findOption,findSubcommandDefinition,isFlagArgument,isOptionArgument,negateOption,optionArgumentToVariableNames,transformOptionToArgument};
-//# sourceMappingURL=parser-utilities.mjs.map
+// src/parse/parser-utilities.ts
+function findSubcommandDefinition(subcommandName, cliDefinition) {
+  if (subcommandName === void 0) {
+    return cliDefinition;
+  }
+  if (!cliDefinition.subcommands) {
+    return;
+  }
+  return cliDefinition.subcommands.find((c) => {
+    if (c.name === subcommandName) {
+      return true;
+    }
+    return subcommandName && c.aliases && c.aliases.includes(subcommandName);
+  });
+}
+function findOption(optionArgument, options) {
+  const validVariableNames = optionArgumentToVariableNames(optionArgument);
+  const isNegated = optionArgument.startsWith("--no-");
+  const option = Object.entries(options).find(([optionName, option2]) => {
+    if (validVariableNames.has(optionName)) {
+      return true;
+    }
+    if (isNegated && validVariableNames.has(negateOption(optionName))) {
+      return true;
+    }
+    if (!option2.aliases) {
+      return false;
+    }
+    if (option2.aliases.some((a) => validVariableNames.has(a))) {
+      return true;
+    }
+    if (isNegated && option2.aliases.map((alias) => negateOption(alias)).some((a) => validVariableNames.has(a))) {
+      return true;
+    }
+    return false;
+  });
+  return option;
+}
+function decoupleFlags(arguments_) {
+  const flagsRe = /^-[a-z0-9]{2,}$/i;
+  const result = [];
+  for (const argument of arguments_) {
+    const isCoupled = flagsRe.test(argument);
+    if (!isCoupled) {
+      result.push(argument);
+      continue;
+    }
+    const decoupledArray = argument.slice(1).split("").map((c) => "-" + c);
+    result.push(...decoupledArray);
+  }
+  return result;
+}
+function optionArgumentToVariableNames(name) {
+  name = name.startsWith("--") ? name.slice(2) : name.slice(1);
+  name = name.toLowerCase();
+  const results = /* @__PURE__ */ new Set();
+  const camelCase = name.replace(/-(.)/g, (m) => m[1].toUpperCase());
+  results.add(camelCase);
+  results.add(camelCase.replace(/^(.)/, (m) => m.toUpperCase()));
+  const snake_case = name.replace(/-(.)/g, (g) => "_" + g[1]);
+  results.add(snake_case);
+  results.add(snake_case.toUpperCase());
+  return results;
+}
+function isFlagArgument(name) {
+  return /^-[A-Za-z]$/.test(name);
+}
+function isLongArgument(name) {
+  return /^--.{2,}/.test(name);
+}
+function isOptionArgument(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return isFlagArgument(name) || isLongArgument(name);
+}
+function negateOption(name) {
+  return "no" + name.replace(/^[a-z]/, (g) => g.toUpperCase());
+}
+function transformOptionToArgument(name) {
+  if (name.length === 1) {
+    return `-${name.toLowerCase()}`;
+  }
+  if (/^[a-z_]+$/.test(name) || /^[A-Z_]+$/.test(name)) {
+    name = name.replace(/_/g, "-");
+    return `--${name.toLowerCase()}`;
+  }
+  name = name.replace(/[A-Z]/g, (match, index) => index > 0 ? "-" + match : match);
+  return `--${name.toLowerCase()}`;
+}
+function splitAndGetKeys(option) {
+  const parts = option.split(".");
+  const optionName = parts[0];
+  const keys = parts.slice(1).filter(Boolean);
+  return [optionName, keys];
+}
+export {
+  decoupleFlags,
+  findOption,
+  findSubcommandDefinition,
+  isFlagArgument,
+  isOptionArgument,
+  negateOption,
+  optionArgumentToVariableNames,
+  splitAndGetKeys,
+  transformOptionToArgument
+};
+//# sourceMappingURL=parser-utilities.mjs.map

package/lib/mjs/parse/parser-utilities.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["findSubcommandDefinition","subcommandName","cliDefinition","subcommands","find","c","name","aliases","includes","findOption","optionArgument","options","validVariableNames","optionArgumentToVariableNames","isNegated","startsWith","Object","entries","optionName","option","has","isBool","_preparedType","coerceTo","negateOption","some","a","map","alias","decoupleFlags","arguments_","flagsRe","result","argument","test","push","decoupledArray","slice","split","Error","toLowerCase","results","Set","camelCase","replace","m","toUpperCase","add","snake_case","g","isFlagArgument","isLongArgument","isOptionArgument","transformOptionToArgument","length","match","index"],"sources":["../../../src/parse/parser-utilities.ts"],"sourcesContent":["import type { Cli, Option, Subcommand } from \"../types/definitions-types.ts\";\n\n/**\n * Retrieves a subcommand object from an array of subcommands by matching the provided subcommand name against the\n * subcommand's name or its aliases.\n *\n * @param subcommandName - The name or alias of the subcommand to search for.\n * @param subcommandArr - An array of `Subcommand` objects to search within.\n * @returns The matching `Subcommand` object if found; otherwise, `undefined`.\n */\nexport function findSubcommandDefinition(\n  subcommandName: string | undefined,\n  cliDefinition: Cli,\n): Subcommand | Cli | undefined {\n  if (subcommandName === undefined) {\n    return cliDefinition;\n  }\n\n  if (!cliDefinition.subcommands) {\n    return;\n  }\n\n  return cliDefinition.subcommands.find(c => {\n    // match for undefined too\n    if (c.name === subcommandName) {\n      return true;\n    }\n\n    // match for aliases\n    return subcommandName && c.aliases && c.aliases.includes(subcommandName);\n  });\n}\n\n/**\n * Finds and returns an `Option` object from the provided list that matches the given argument string.\n *\n * The function supports matching by option name, aliases, and their negated forms (e.g., `--no-` prefix).\n *\n * @param optionArgument - The argument string to match (e.g., `--foo`, `--no-bar`, `-f`).\n * @param options - An array of `Option` objects to search through.\n * @returns The matching `Option` object if found; otherwise, `undefined`.\n */\nexport function findOption(optionArgument: string, options: Record<string, Option>): [string, Option] | undefined {\n  const validVariableNames = optionArgumentToVariableNames(optionArgument);\n  const isNegated = optionArgument.startsWith(\"--no-\");\n\n  const option = Object.entries(options).find(([optionName, option]) => {\n    if (validVariableNames.has(optionName)) {\n      return true;\n    }\n\n    const isBool = option._preparedType && option._preparedType.coerceTo === \"boolean\";\n\n    if (isNegated && isBool && validVariableNames.has(negateOption(optionName))) {\n      return true;\n    }\n\n    if (!option.aliases) {\n      return false;\n    }\n\n    if (option.aliases.some(a => validVariableNames.has(a))) {\n      return true;\n    }\n\n    if (isNegated && isBool && option.aliases.map(alias => negateOption(alias)).some(a => validVariableNames.has(a))) {\n      return true;\n    }\n\n    return false;\n  });\n\n  return option;\n}\n\n/** - Decouple flags E.g. `-rf` -> `-r, -f` */\nexport function decoupleFlags(arguments_: string[]): string[] {\n  const flagsRe = /^-[a-z0-9]{2,}$/i;\n\n  const result = [];\n  for (const argument of arguments_) {\n    const isCoupled = flagsRe.test(argument);\n\n    if (!isCoupled) {\n      result.push(argument);\n      continue;\n    }\n\n    const decoupledArray = argument\n      .slice(1)\n      .split(\"\")\n      .map(c => \"-\" + c);\n\n    result.push(...decoupledArray);\n  }\n\n  return result;\n}\n\n/**\n * Transforms an option name to a set of variants: `camelCase`, `PascalCase`, `snake_case`, `SCREAMING_SNAKE_CASE`.\n *\n * **Example** for `--input-dir`\n *\n * - CamelCase: `inputDir`\n * - PascalCase: `InputDir`\n * - Snake_case: `input_dir`\n * - SCREAMING_SNAKE_CASE: `INPUT_DIR`\n *\n * @param name - Should start with `'--'` or `'-'`\n */\nexport function optionArgumentToVariableNames(name: string): Set<string> {\n  if (!name.startsWith(\"-\")) {\n    throw new Error(`invalid option name: ${name}`);\n  }\n\n  name = name.startsWith(\"--\") ? name.slice(2) : name.slice(1); // remove prefix\n  name = name.toLowerCase(); // lowercase\n\n  const results = new Set<string>();\n\n  // camelCase\n  const camelCase = name.replace(/-(.)/g, m => m[1].toUpperCase());\n  results.add(camelCase);\n\n  // PascalCase (UpperCamelCase)\n  results.add(camelCase.replace(/^(.)/, m => m.toUpperCase()));\n\n  // snake_case\n  const snake_case = name.replace(/-(.)/g, g => \"_\" + g[1]);\n  results.add(snake_case);\n\n  // SCREAMING_SNAKE_CASE\n  results.add(snake_case.toUpperCase());\n\n  return results;\n}\n\n/** - Check if an arg string is a short arg. E.g. `-i` -> `true` */\nexport function isFlagArgument(name: string): boolean {\n  return /^-[A-Za-z]$/.test(name);\n}\n\n/** - Check if an arg string is a long arg. E.g. `--input-dir` -> `true` */\nfunction isLongArgument(name: string): boolean {\n  return /^--[A-Za-z-]+[A-Za-z0-9]$/.test(name);\n}\n\n/** - Check if an arg string is an options arg. E.g. `--input-dir` -> `true` , `-i` -> `true` */\nexport function isOptionArgument(name: string | boolean): boolean {\n  if (typeof name !== \"string\") {\n    return false;\n  }\n\n  return isFlagArgument(name) || isLongArgument(name);\n}\n\n/**\n * Transform option name to no name.\n *\n * - `verbose` -> `noVerbose`\n * - `v` -> `noV`\n */\nexport function negateOption(name: string): string {\n  return \"no\" + name.replace(/^[a-z]/, g => g.toUpperCase());\n}\n\n/** - Reverse of `transformArg`. E.g. `InputDir` -> `--input-dir` , `i` -> `-i` */\nexport function transformOptionToArgument(name: string): string {\n  // single letter option name\n  if (name.length === 1) {\n    return `-${name.toLowerCase()}`;\n  }\n\n  // snake_case, SCREAMING_SNAKE_CASE\n  if (/^[a-z_]+$/.test(name) || /^[A-Z_]+$/.test(name)) {\n    name = name.replace(/_/g, \"-\");\n    return `--${name.toLowerCase()}`;\n  }\n\n  // camelCase, PascalCase\n\n  // add \"-\" before camel case letters except for the first letter\n  name = name.replace(/[A-Z]/g, (match, index: number) => (index > 0 ? \"-\" + match : match));\n\n  return `--${name.toLowerCase()}`;\n}\n"],"mappings":"AAUO,SAASA,yBACdC,EACAC,GAEA,YAAuB,IAAnBD,EACKC,EAGJA,EAAcC,YAIZD,EAAcC,YAAYC,KAAKC,GAEhCA,EAAEC,OAASL,GAKRA,GAAkBI,EAAEE,SAAWF,EAAEE,QAAQC,SAASP,SAX3D,CAaF,CAWO,SAASQ,WAAWC,EAAwBC,GACjD,MAAMC,EAAqBC,8BAA8BH,GACnDI,EAAYJ,EAAeK,WAAW,SA4B5C,OA1BeC,OAAOC,QAAQN,GAASP,KAAK,EAAEc,EAAYC,MACxD,GAAIP,EAAmBQ,IAAIF,GACzB,OAAO,EAGT,MAAMG,EAASF,EAAOG,eAAmD,YAAlCH,EAAOG,cAAcC,SAE5D,SAAIT,GAAaO,GAAUT,EAAmBQ,IAAII,aAAaN,QAI1DC,EAAOZ,YAIRY,EAAOZ,QAAQkB,KAAKC,GAAKd,EAAmBQ,IAAIM,QAIhDZ,GAAaO,GAAUF,EAAOZ,QAAQoB,IAAIC,GAASJ,aAAaI,IAAQH,KAAKC,GAAKd,EAAmBQ,IAAIM,OAQjH,CAGO,SAASG,cAAcC,GAC5B,MAAMC,EAAU,mBAEVC,EAAS,GACf,UAAWC,KAAYH,EAAY,CAGjC,IAFkBC,EAAQG,KAAKD,GAEf,CACdD,EAAOG,KAAKF,GACZ,QACF,CAEA,MAAMG,EAAiBH,EACpBI,MAAM,GACNC,MAAM,IACNX,IAAItB,GAAK,IAAMA,GAElB2B,EAAOG,QAAQC,EACjB,CAEA,OAAOJ,CACT,CAcO,SAASnB,8BAA8BP,GAC5C,IAAKA,EAAKS,WAAW,KACnB,MAAM,IAAIwB,MAAM,wBAAwBjC,KAI1CA,GADAA,EAAOA,EAAKS,WAAW,MAAQT,EAAK+B,MAAM,GAAK/B,EAAK+B,MAAM,IAC9CG,cAEZ,MAAMC,EAAU,IAAIC,IAGdC,EAAYrC,EAAKsC,QAAQ,QAASC,GAAKA,EAAE,GAAGC,eAClDL,EAAQM,IAAIJ,GAGZF,EAAQM,IAAIJ,EAAUC,QAAQ,OAAQC,GAAKA,EAAEC,gBAG7C,MAAME,EAAa1C,EAAKsC,QAAQ,QAASK,GAAK,IAAMA,EAAE,IAMtD,OALAR,EAAQM,IAAIC,GAGZP,EAAQM,IAAIC,EAAWF,eAEhBL,CACT,CAGO,SAASS,eAAe5C,GAC7B,MAAO,cAAc4B,KAAK5B,EAC5B,CAGA,SAAS6C,eAAe7C,GACtB,MAAO,4BAA4B4B,KAAK5B,EAC1C,CAGO,SAAS8C,iBAAiB9C,GAC/B,MAAoB,iBAATA,IAIJ4C,eAAe5C,IAAS6C,eAAe7C,GAChD,CAQO,SAASkB,aAAalB,GAC3B,MAAO,KAAOA,EAAKsC,QAAQ,SAAUK,GAAKA,EAAEH,cAC9C,CAGO,SAASO,0BAA0B/C,GAExC,OAAoB,IAAhBA,EAAKgD,OACA,IAAIhD,EAAKkC,gBAId,YAAYN,KAAK5B,IAAS,YAAY4B,KAAK5B,GAEtC,MADPA,EAAOA,EAAKsC,QAAQ,KAAM,MACTJ,gBAQZ,MAFPlC,EAAOA,EAAKsC,QAAQ,SAAU,CAACW,EAAOC,IAAmBA,EAAQ,EAAI,IAAMD,EAAQA,IAElEf,eACnB,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../src/parse/parser-utilities.ts"],
+  "sourcesContent": ["import type { Cli, Option, Subcommand } from \"../types/definitions-types.ts\";\n\n/**\n * Retrieves a subcommand object from an array of subcommands by matching the provided subcommand name against the\n * subcommand's name or its aliases.\n *\n * @param subcommandName - The name or alias of the subcommand to search for.\n * @param subcommandArr - An array of `Subcommand` objects to search within.\n * @returns The matching `Subcommand` object if found; otherwise, `undefined`.\n */\nexport function findSubcommandDefinition(\n  subcommandName: string | undefined,\n  cliDefinition: Cli,\n): Subcommand | Cli | undefined {\n  if (subcommandName === undefined) {\n    return cliDefinition;\n  }\n\n  if (!cliDefinition.subcommands) {\n    return;\n  }\n\n  return cliDefinition.subcommands.find(c => {\n    // match for undefined too\n    if (c.name === subcommandName) {\n      return true;\n    }\n\n    // match for aliases\n    return subcommandName && c.aliases && c.aliases.includes(subcommandName);\n  });\n}\n\n/**\n * Finds and returns an `Option` object from the provided list that matches the given argument string.\n *\n * The function supports matching by option name, aliases, and their negated forms (e.g., `--no-` prefix).\n *\n * @param optionArgument - The argument string to match (e.g., `--foo`, `--no-bar`, `-f`).\n * @param options - An array of `Option` objects to search through.\n * @returns The matching `Option` object if found; otherwise, `undefined`.\n */\nexport function findOption(optionArgument: string, options: Record<string, Option>): [string, Option] | undefined {\n  const validVariableNames = optionArgumentToVariableNames(optionArgument);\n  const isNegated = optionArgument.startsWith(\"--no-\");\n\n  const option = Object.entries(options).find(([optionName, option]) => {\n    if (validVariableNames.has(optionName)) {\n      return true;\n    }\n\n    if (isNegated && validVariableNames.has(negateOption(optionName))) {\n      return true;\n    }\n\n    if (!option.aliases) {\n      return false;\n    }\n\n    if (option.aliases.some(a => validVariableNames.has(a))) {\n      return true;\n    }\n\n    if (isNegated && option.aliases.map(alias => negateOption(alias)).some(a => validVariableNames.has(a))) {\n      return true;\n    }\n\n    return false;\n  });\n\n  return option;\n}\n\n/** - Decouple flags E.g. `-rf` -> `-r, -f` */\nexport function decoupleFlags(arguments_: string[]): string[] {\n  const flagsRe = /^-[a-z0-9]{2,}$/i;\n\n  const result = [];\n  for (const argument of arguments_) {\n    const isCoupled = flagsRe.test(argument);\n\n    if (!isCoupled) {\n      result.push(argument);\n      continue;\n    }\n\n    const decoupledArray = argument\n      .slice(1)\n      .split(\"\")\n      .map(c => \"-\" + c);\n\n    result.push(...decoupledArray);\n  }\n\n  return result;\n}\n\n/**\n * Transforms an option name to a set of variants: `camelCase`, `PascalCase`, `snake_case`, `SCREAMING_SNAKE_CASE`.\n *\n * **Example** for `--input-dir`\n *\n * - CamelCase: `inputDir`\n * - PascalCase: `InputDir`\n * - Snake_case: `input_dir`\n * - SCREAMING_SNAKE_CASE: `INPUT_DIR`\n *\n * @param name - Should start with `'--'` or `'-'`\n */\nexport function optionArgumentToVariableNames(name: string): Set<string> {\n  name = name.startsWith(\"--\") ? name.slice(2) : name.slice(1); // remove prefix\n  name = name.toLowerCase(); // lowercase\n\n  const results = new Set<string>();\n\n  // camelCase\n  const camelCase = name.replace(/-(.)/g, m => m[1].toUpperCase());\n  results.add(camelCase);\n\n  // PascalCase (UpperCamelCase)\n  results.add(camelCase.replace(/^(.)/, m => m.toUpperCase()));\n\n  // snake_case\n  const snake_case = name.replace(/-(.)/g, g => \"_\" + g[1]);\n  results.add(snake_case);\n\n  // SCREAMING_SNAKE_CASE\n  results.add(snake_case.toUpperCase());\n\n  return results;\n}\n\n/** - Check if an arg string is a short arg. E.g. `-i` -> `true` */\nexport function isFlagArgument(name: string): boolean {\n  return /^-[A-Za-z]$/.test(name);\n}\n\n/**\n * - Check if an arg string is a long arg.\n * - `--input-dir` -> `true`\n * - `-h` -> `false`\n * - `--db.https` -> `true`\n */\nfunction isLongArgument(name: string): boolean {\n  return /^--.{2,}/.test(name);\n}\n\n/** - Check if an arg string is an options arg. E.g. `--input-dir` -> `true` , `-i` -> `true` */\nexport function isOptionArgument(name: string | boolean): boolean {\n  if (typeof name !== \"string\") {\n    return false;\n  }\n\n  return isFlagArgument(name) || isLongArgument(name);\n}\n\n/**\n * Transform option name to no name.\n *\n * - `verbose` -> `noVerbose`\n * - `v` -> `noV`\n */\nexport function negateOption(name: string): string {\n  return \"no\" + name.replace(/^[a-z]/, g => g.toUpperCase());\n}\n\n/** - Reverse of `transformArg`. E.g. `InputDir` -> `--input-dir` , `i` -> `-i` */\nexport function transformOptionToArgument(name: string): string {\n  // single letter option name\n  if (name.length === 1) {\n    return `-${name.toLowerCase()}`;\n  }\n\n  // snake_case, SCREAMING_SNAKE_CASE\n  if (/^[a-z_]+$/.test(name) || /^[A-Z_]+$/.test(name)) {\n    name = name.replace(/_/g, \"-\");\n    return `--${name.toLowerCase()}`;\n  }\n\n  // camelCase, PascalCase\n\n  // add \"-\" before camel case letters except for the first letter\n  name = name.replace(/[A-Z]/g, (match, index: number) => (index > 0 ? \"-\" + match : match));\n\n  return `--${name.toLowerCase()}`;\n}\n\n/**\n * Split an option with keys into name and a set of keys\n *\n * - `--foo` -> `[--foo, []]`\n * - `--foo.bar` -> `[--foo, [\"bar\"]]`\n * - `--foo.bar.baz` -> `[--foo, [\"bar\", \"baz\"]]`\n * - `--foo.bar.` -> `[--foo, Set(1) [\"bar\"]]`\n */\nexport function splitAndGetKeys(option: string): [string, string[]] {\n  const parts = option.split(\".\");\n  const optionName = parts[0];\n  const keys = parts.slice(1).filter(Boolean);\n  return [optionName, keys];\n}\n"],
+  "mappings": ";AAUO,SAAS,yBACd,gBACA,eAC8B;AAC9B,MAAI,mBAAmB,QAAW;AAChC,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,cAAc,aAAa;AAC9B;AAAA,EACF;AAEA,SAAO,cAAc,YAAY,KAAK,OAAK;AAEzC,QAAI,EAAE,SAAS,gBAAgB;AAC7B,aAAO;AAAA,IACT;AAGA,WAAO,kBAAkB,EAAE,WAAW,EAAE,QAAQ,SAAS,cAAc;AAAA,EACzE,CAAC;AACH;AAWO,SAAS,WAAW,gBAAwB,SAA+D;AAChH,QAAM,qBAAqB,8BAA8B,cAAc;AACvE,QAAM,YAAY,eAAe,WAAW,OAAO;AAEnD,QAAM,SAAS,OAAO,QAAQ,OAAO,EAAE,KAAK,CAAC,CAAC,YAAYA,OAAM,MAAM;AACpE,QAAI,mBAAmB,IAAI,UAAU,GAAG;AACtC,aAAO;AAAA,IACT;AAEA,QAAI,aAAa,mBAAmB,IAAI,aAAa,UAAU,CAAC,GAAG;AACjE,aAAO;AAAA,IACT;AAEA,QAAI,CAACA,QAAO,SAAS;AACnB,aAAO;AAAA,IACT;AAEA,QAAIA,QAAO,QAAQ,KAAK,OAAK,mBAAmB,IAAI,CAAC,CAAC,GAAG;AACvD,aAAO;AAAA,IACT;AAEA,QAAI,aAAaA,QAAO,QAAQ,IAAI,WAAS,aAAa,KAAK,CAAC,EAAE,KAAK,OAAK,mBAAmB,IAAI,CAAC,CAAC,GAAG;AACtG,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT,CAAC;AAED,SAAO;AACT;AAGO,SAAS,cAAc,YAAgC;AAC5D,QAAM,UAAU;AAEhB,QAAM,SAAS,CAAC;AAChB,aAAW,YAAY,YAAY;AACjC,UAAM,YAAY,QAAQ,KAAK,QAAQ;AAEvC,QAAI,CAAC,WAAW;AACd,aAAO,KAAK,QAAQ;AACpB;AAAA,IACF;AAEA,UAAM,iBAAiB,SACpB,MAAM,CAAC,EACP,MAAM,EAAE,EACR,IAAI,OAAK,MAAM,CAAC;AAEnB,WAAO,KAAK,GAAG,cAAc;AAAA,EAC/B;AAEA,SAAO;AACT;AAcO,SAAS,8BAA8B,MAA2B;AACvE,SAAO,KAAK,WAAW,IAAI,IAAI,KAAK,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC;AAC3D,SAAO,KAAK,YAAY;AAExB,QAAM,UAAU,oBAAI,IAAY;AAGhC,QAAM,YAAY,KAAK,QAAQ,SAAS,OAAK,EAAE,CAAC,EAAE,YAAY,CAAC;AAC/D,UAAQ,IAAI,SAAS;AAGrB,UAAQ,IAAI,UAAU,QAAQ,QAAQ,OAAK,EAAE,YAAY,CAAC,CAAC;AAG3D,QAAM,aAAa,KAAK,QAAQ,SAAS,OAAK,MAAM,EAAE,CAAC,CAAC;AACxD,UAAQ,IAAI,UAAU;AAGtB,UAAQ,IAAI,WAAW,YAAY,CAAC;AAEpC,SAAO;AACT;AAGO,SAAS,eAAe,MAAuB;AACpD,SAAO,cAAc,KAAK,IAAI;AAChC;AAQA,SAAS,eAAe,MAAuB;AAC7C,SAAO,WAAW,KAAK,IAAI;AAC7B;AAGO,SAAS,iBAAiB,MAAiC;AAChE,MAAI,OAAO,SAAS,UAAU;AAC5B,WAAO;AAAA,EACT;AAEA,SAAO,eAAe,IAAI,KAAK,eAAe,IAAI;AACpD;AAQO,SAAS,aAAa,MAAsB;AACjD,SAAO,OAAO,KAAK,QAAQ,UAAU,OAAK,EAAE,YAAY,CAAC;AAC3D;AAGO,SAAS,0BAA0B,MAAsB;AAE9D,MAAI,KAAK,WAAW,GAAG;AACrB,WAAO,IAAI,KAAK,YAAY,CAAC;AAAA,EAC/B;AAGA,MAAI,YAAY,KAAK,IAAI,KAAK,YAAY,KAAK,IAAI,GAAG;AACpD,WAAO,KAAK,QAAQ,MAAM,GAAG;AAC7B,WAAO,KAAK,KAAK,YAAY,CAAC;AAAA,EAChC;AAKA,SAAO,KAAK,QAAQ,UAAU,CAAC,OAAO,UAAmB,QAAQ,IAAI,MAAM,QAAQ,KAAM;AAEzF,SAAO,KAAK,KAAK,YAAY,CAAC;AAChC;AAUO,SAAS,gBAAgB,QAAoC;AAClE,QAAM,QAAQ,OAAO,MAAM,GAAG;AAC9B,QAAM,aAAa,MAAM,CAAC;AAC1B,QAAM,OAAO,MAAM,MAAM,CAAC,EAAE,OAAO,OAAO;AAC1C,SAAO,CAAC,YAAY,IAAI;AAC1B;",
+  "names": ["option"]
+}

package/lib/mjs/parse/safe-parse.mjs

@@ -1,2 +1,57 @@
-import{validateCliDefinition}from"../definitions/validate-cli-definition.mjs";import{parseArgv}from"../utilities.mjs";import{buildCliContext}from"./context/cli-context-builder.mjs";import{findSubcommandDefinition}from"./parser-utilities.mjs";import{validate}from"./validation/validate-context.mjs";function safeParse(r,e){const t=safeParseCore(r,e);if(t.error)return{error:t.error};const{validateResult:o,subcommandObject:i}=t;if(i._onExecute)for(const r of i._onExecute)r(o);return{error:void 0,value:o}}async function safeParseAsync(r,e){const t=safeParseCore(r,e);if(t.error)return{error:t.error};const{validateResult:o,subcommandObject:i}=t;if(i._onExecute)for(const r of i._onExecute)await r(o);return{error:void 0,value:o}}function safeParseCore(r,e){const t="string"==typeof r?parseArgv(r):r;try{validateCliDefinition(e)}catch(r){return{error:r}}let o;try{o=buildCliContext(t,e)}catch(r){return{error:r}}const i=findSubcommandDefinition(o.subcommand,e);if(!i){return{error:new Error(`Subcommand "${o.subcommand}" does not exist`)}}let n;try{n=validate(o,i)}catch(r){return{error:r}}return{error:void 0,validateResult:n,subcommandObject:i}}export{safeParse,safeParseAsync};
-//# sourceMappingURL=safe-parse.mjs.map
+// src/parse/safe-parse.ts
+import { validateCliDefinition } from "../definitions/validate-cli-definition.mjs";
+import { parseArgv } from "../utilities/parse-argv.mjs";
+import { buildCliContext } from "./context/cli-context-builder.mjs";
+import { findSubcommandDefinition } from "./parser-utilities.mjs";
+import { validate } from "./validation/validate-context.mjs";
+function safeParse(stringOrArgv, cliDefinition) {
+  const core = safeParseCore(stringOrArgv, cliDefinition);
+  if (core.error) return { error: core.error };
+  const { validateResult, subcommandObject } = core;
+  if (subcommandObject._onExecute) {
+    for (const handler of subcommandObject._onExecute) {
+      void handler(validateResult);
+    }
+  }
+  return { error: void 0, value: validateResult };
+}
+async function safeParseAsync(stringOrArgv, cliDefinition) {
+  const core = safeParseCore(stringOrArgv, cliDefinition);
+  if (core.error) return { error: core.error };
+  const { validateResult, subcommandObject } = core;
+  if (subcommandObject._onExecute) {
+    await Promise.all(subcommandObject._onExecute.map(async (handler) => await handler(validateResult)));
+  }
+  return { error: void 0, value: validateResult };
+}
+function safeParseCore(stringOrArgv, cliDefinition) {
+  const argv = typeof stringOrArgv === "string" ? parseArgv(stringOrArgv) : stringOrArgv;
+  try {
+    validateCliDefinition(cliDefinition);
+  } catch (error) {
+    return { error };
+  }
+  let cliContext;
+  try {
+    cliContext = buildCliContext(argv, cliDefinition);
+  } catch (error) {
+    return { error };
+  }
+  const subcommandObject = findSubcommandDefinition(cliContext.subcommand, cliDefinition);
+  if (!subcommandObject) {
+    const error = new Error(`Subcommand "${cliContext.subcommand}" does not exist`);
+    return { error };
+  }
+  let validateResult;
+  try {
+    validateResult = validate(cliContext, subcommandObject);
+  } catch (error) {
+    return { error };
+  }
+  return { error: void 0, validateResult, subcommandObject };
+}
+export {
+  safeParse,
+  safeParseAsync
+};
+//# sourceMappingURL=safe-parse.mjs.map

package/lib/mjs/parse/safe-parse.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["validateCliDefinition","parseArgv","buildCliContext","findSubcommandDefinition","validate","safeParse","stringOrArgv","cliDefinition","core","safeParseCore","error","validateResult","subcommandObject","_onExecute","handler","value","async","safeParseAsync","argv","cliContext","subcommand","Error"],"sources":["../../../src/parse/safe-parse.ts"],"sourcesContent":["import { validateCliDefinition } from \"../definitions/validate-cli-definition.ts\";\nimport { parseArgv } from \"../utilities.ts\";\nimport { buildCliContext } from \"./context/cli-context-builder.ts\";\nimport { findSubcommandDefinition } from \"./parser-utilities.ts\";\nimport { validate } from \"./validation/validate-context.ts\";\n\nimport type { Cli } from \"../types/definitions-types.ts\";\nimport type { CliParseResultWide } from \"../types/types.ts\";\n\nexport function safeParse(stringOrArgv: string | string[], cliDefinition: Cli): CliParseResultWide {\n  const core = safeParseCore(stringOrArgv, cliDefinition);\n  if (core.error) return { error: core.error };\n\n  const { validateResult, subcommandObject } = core;\n\n  // Fire action (throw errors caused by the usage of the action hook)\n  if (subcommandObject._onExecute) {\n    for (const handler of subcommandObject._onExecute) {\n      handler(validateResult);\n    }\n  }\n\n  return { error: undefined, value: validateResult };\n}\n\nexport async function safeParseAsync(stringOrArgv: string | string[], cliDefinition: Cli): Promise<CliParseResultWide> {\n  const core = safeParseCore(stringOrArgv, cliDefinition);\n  if (core.error) return { error: core.error };\n\n  const { validateResult, subcommandObject } = core;\n\n  // Fire action (throw errors caused by the usage of the action hook)\n  if (subcommandObject._onExecute) {\n    for (const handler of subcommandObject._onExecute) {\n      // eslint-disable-next-line @typescript-eslint/await-thenable\n      await handler(validateResult);\n    }\n  }\n\n  return { error: undefined, value: validateResult };\n}\n\nfunction safeParseCore(stringOrArgv: string | string[], cliDefinition: Cli) {\n  const argv = typeof stringOrArgv === \"string\" ? parseArgv(stringOrArgv) : stringOrArgv;\n\n  // validate cli definition\n  try {\n    validateCliDefinition(cliDefinition);\n  } catch (error) {\n    return { error: error as Error };\n  }\n\n  // Parse\n  let cliContext;\n  try {\n    cliContext = buildCliContext(argv, cliDefinition);\n  } catch (error) {\n    return { error: error as Error };\n  }\n\n  const subcommandObject = findSubcommandDefinition(cliContext.subcommand, cliDefinition);\n  if (!subcommandObject) {\n    const error = new Error(`Subcommand \"${cliContext.subcommand}\" does not exist`);\n    return { error };\n  }\n\n  // Validate context\n  let validateResult;\n  try {\n    validateResult = validate(cliContext, subcommandObject);\n  } catch (error) {\n    return { error: error as Error };\n  }\n\n  return { error: undefined, validateResult, subcommandObject };\n}\n"],"mappings":"OAASA,0BAA6B,oDAC7BC,cAAiB,0BACjBC,oBAAuB,2CACvBC,6BAAgC,gCAChCC,aAAgB,oCAKlB,SAASC,UAAUC,EAAiCC,GACzD,MAAMC,EAAOC,cAAcH,EAAcC,GACzC,GAAIC,EAAKE,MAAO,MAAO,CAAEA,MAAOF,EAAKE,OAErC,MAAMC,eAAEA,EAAAC,iBAAgBA,GAAqBJ,EAG7C,GAAII,EAAiBC,WACnB,UAAWC,KAAWF,EAAiBC,WACrCC,EAAQH,GAIZ,MAAO,CAAED,WAAO,EAAWK,MAAOJ,EACpC,CAEAK,eAAsBC,eAAeX,EAAiCC,GACpE,MAAMC,EAAOC,cAAcH,EAAcC,GACzC,GAAIC,EAAKE,MAAO,MAAO,CAAEA,MAAOF,EAAKE,OAErC,MAAMC,eAAEA,EAAAC,iBAAgBA,GAAqBJ,EAG7C,GAAII,EAAiBC,WACnB,UAAWC,KAAWF,EAAiBC,iBAE/BC,EAAQH,GAIlB,MAAO,CAAED,WAAO,EAAWK,MAAOJ,EACpC,CAEA,SAASF,cAAcH,EAAiCC,GACtD,MAAMW,EAA+B,iBAAjBZ,EAA4BL,UAAUK,GAAgBA,EAG1E,IACEN,sBAAsBO,EACxB,OAASG,GACP,MAAO,CAAEA,QACX,CAGA,IAAIS,EACJ,IACEA,EAAajB,gBAAgBgB,EAAMX,EACrC,OAASG,GACP,MAAO,CAAEA,QACX,CAEA,MAAME,EAAmBT,yBAAyBgB,EAAWC,WAAYb,GACzE,IAAKK,EAAkB,CAErB,MAAO,CAAEF,MADK,IAAIW,MAAM,eAAeF,EAAWC,8BAEpD,CAGA,IAAIT,EACJ,IACEA,EAAiBP,SAASe,EAAYP,EACxC,OAASF,GACP,MAAO,CAAEA,QACX,CAEA,MAAO,CAAEA,WAAO,EAAWC,iBAAgBC,mBAC7C,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../src/parse/safe-parse.ts"],
+  "sourcesContent": ["import { validateCliDefinition } from \"../definitions/validate-cli-definition.ts\";\nimport { parseArgv } from \"../utilities/parse-argv.ts\";\nimport { buildCliContext } from \"./context/cli-context-builder.ts\";\nimport { findSubcommandDefinition } from \"./parser-utilities.ts\";\nimport { validate } from \"./validation/validate-context.ts\";\n\nimport type { Cli } from \"../types/definitions-types.ts\";\nimport type { CliParseResultWide } from \"../types/types.ts\";\n\nexport function safeParse(stringOrArgv: string | string[], cliDefinition: Cli): CliParseResultWide {\n  const core = safeParseCore(stringOrArgv, cliDefinition);\n  if (core.error) return { error: core.error };\n\n  const { validateResult, subcommandObject } = core;\n\n  // Fire action (throw errors caused by the usage of the action hook)\n  if (subcommandObject._onExecute) {\n    for (const handler of subcommandObject._onExecute) {\n      void handler(validateResult);\n    }\n  }\n\n  return { error: undefined, value: validateResult };\n}\n\nexport async function safeParseAsync(stringOrArgv: string | string[], cliDefinition: Cli): Promise<CliParseResultWide> {\n  const core = safeParseCore(stringOrArgv, cliDefinition);\n  if (core.error) return { error: core.error };\n\n  const { validateResult, subcommandObject } = core;\n\n  // Fire action (throw errors caused by the usage of the action hook)\n  if (subcommandObject._onExecute) {\n    await Promise.all(subcommandObject._onExecute.map(async handler => await handler(validateResult)));\n  }\n\n  return { error: undefined, value: validateResult };\n}\n\nfunction safeParseCore(stringOrArgv: string | string[], cliDefinition: Cli) {\n  const argv = typeof stringOrArgv === \"string\" ? parseArgv(stringOrArgv) : stringOrArgv;\n\n  // validate cli definition\n  try {\n    validateCliDefinition(cliDefinition);\n  } catch (error) {\n    return { error: error as Error };\n  }\n\n  // Parse\n  let cliContext;\n  try {\n    cliContext = buildCliContext(argv, cliDefinition);\n  } catch (error) {\n    return { error: error as Error };\n  }\n\n  const subcommandObject = findSubcommandDefinition(cliContext.subcommand, cliDefinition);\n  if (!subcommandObject) {\n    const error = new Error(`Subcommand \"${cliContext.subcommand}\" does not exist`);\n    return { error };\n  }\n\n  // Validate context\n  let validateResult;\n  try {\n    validateResult = validate(cliContext, subcommandObject);\n  } catch (error) {\n    return { error: error as Error };\n  }\n\n  return { error: undefined, validateResult, subcommandObject };\n}\n"],
+  "mappings": ";AAAA,SAAS,6BAA6B;AACtC,SAAS,iBAAiB;AAC1B,SAAS,uBAAuB;AAChC,SAAS,gCAAgC;AACzC,SAAS,gBAAgB;AAKlB,SAAS,UAAU,cAAiC,eAAwC;AACjG,QAAM,OAAO,cAAc,cAAc,aAAa;AACtD,MAAI,KAAK,MAAO,QAAO,EAAE,OAAO,KAAK,MAAM;AAE3C,QAAM,EAAE,gBAAgB,iBAAiB,IAAI;AAG7C,MAAI,iBAAiB,YAAY;AAC/B,eAAW,WAAW,iBAAiB,YAAY;AACjD,WAAK,QAAQ,cAAc;AAAA,IAC7B;AAAA,EACF;AAEA,SAAO,EAAE,OAAO,QAAW,OAAO,eAAe;AACnD;AAEA,eAAsB,eAAe,cAAiC,eAAiD;AACrH,QAAM,OAAO,cAAc,cAAc,aAAa;AACtD,MAAI,KAAK,MAAO,QAAO,EAAE,OAAO,KAAK,MAAM;AAE3C,QAAM,EAAE,gBAAgB,iBAAiB,IAAI;AAG7C,MAAI,iBAAiB,YAAY;AAC/B,UAAM,QAAQ,IAAI,iBAAiB,WAAW,IAAI,OAAM,YAAW,MAAM,QAAQ,cAAc,CAAC,CAAC;AAAA,EACnG;AAEA,SAAO,EAAE,OAAO,QAAW,OAAO,eAAe;AACnD;AAEA,SAAS,cAAc,cAAiC,eAAoB;AAC1E,QAAM,OAAO,OAAO,iBAAiB,WAAW,UAAU,YAAY,IAAI;AAG1E,MAAI;AACF,0BAAsB,aAAa;AAAA,EACrC,SAAS,OAAO;AACd,WAAO,EAAE,MAAsB;AAAA,EACjC;AAGA,MAAI;AACJ,MAAI;AACF,iBAAa,gBAAgB,MAAM,aAAa;AAAA,EAClD,SAAS,OAAO;AACd,WAAO,EAAE,MAAsB;AAAA,EACjC;AAEA,QAAM,mBAAmB,yBAAyB,WAAW,YAAY,aAAa;AACtF,MAAI,CAAC,kBAAkB;AACrB,UAAM,QAAQ,IAAI,MAAM,eAAe,WAAW,UAAU,kBAAkB;AAC9E,WAAO,EAAE,MAAM;AAAA,EACjB;AAGA,MAAI;AACJ,MAAI;AACF,qBAAiB,SAAS,YAAY,gBAAgB;AAAA,EACxD,SAAS,OAAO;AACd,WAAO,EAAE,MAAsB;AAAA,EACjC;AAEA,SAAO,EAAE,OAAO,QAAW,gBAAgB,iBAAiB;AAC9D;",
+  "names": []
+}

package/lib/mjs/parse/validation/validate-context.mjs

@@ -1,2 +1,17 @@
-import{validateArguments}from"./validators/arguments.mjs";import{validateOptions}from"./validators/options.mjs";function validate(t,o){const i={subcommand:t.subcommand,positionals:t.positionals,context:t};return validateOptions({commandDefinition:o,context:t,output:i}),validateArguments({commandDefinition:o,context:t,output:i}),i}export{validate};
-//# sourceMappingURL=validate-context.mjs.map
+// src/parse/validation/validate-context.ts
+import { validateArguments } from "./validators/arguments.mjs";
+import { validateOptions } from "./validators/options.mjs";
+function validate(context, commandDefinition) {
+  const output = {
+    subcommand: context.subcommand,
+    positionals: context.positionals,
+    context
+  };
+  validateOptions({ commandDefinition, context, output });
+  validateArguments({ commandDefinition, context, output });
+  return output;
+}
+export {
+  validate
+};
+//# sourceMappingURL=validate-context.mjs.map

package/lib/mjs/parse/validation/validate-context.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["validateArguments","validateOptions","validate","context","commandDefinition","output","subcommand","positionals"],"sources":["../../../../src/parse/validation/validate-context.ts"],"sourcesContent":["import { validateArguments } from \"./validators/arguments.ts\";\nimport { validateOptions } from \"./validators/options.ts\";\n\nimport type { ContextWide } from \"../../types/context-types.ts\";\nimport type { Cli, Subcommand } from \"../../types/definitions-types.ts\";\nimport type { OutputTypeWide } from \"../../types/io-types.ts\";\n\n/** @throws {Error} */\nexport function validate(context: ContextWide, commandDefinition: Subcommand | Cli) {\n  const output: OutputTypeWide = {\n    subcommand: context.subcommand,\n    positionals: context.positionals,\n    context: context,\n  };\n\n  // validate options\n  validateOptions({ commandDefinition, context, output });\n\n  // validate arguments\n  validateArguments({ commandDefinition, context, output });\n\n  return output;\n}\n"],"mappings":"OAASA,sBAAyB,oCACzBC,oBAAuB,2BAOzB,SAASC,SAASC,EAAsBC,GAC7C,MAAMC,EAAyB,CAC7BC,WAAYH,EAAQG,WACpBC,YAAaJ,EAAQI,YACrBJ,WASF,OALAF,gBAAgB,CAAEG,oBAAmBD,UAASE,WAG9CL,kBAAkB,CAAEI,oBAAmBD,UAASE,WAEzCA,CACT,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../../src/parse/validation/validate-context.ts"],
+  "sourcesContent": ["import { validateArguments } from \"./validators/arguments.ts\";\nimport { validateOptions } from \"./validators/options.ts\";\n\nimport type { ContextWide } from \"../../types/context-types.ts\";\nimport type { Cli, Subcommand } from \"../../types/definitions-types.ts\";\nimport type { OutputTypeWide } from \"../../types/io-types.ts\";\n\n/** @throws {CliError} */\nexport function validate(context: ContextWide, commandDefinition: Subcommand | Cli) {\n  const output: OutputTypeWide = {\n    subcommand: context.subcommand,\n    positionals: context.positionals,\n    context: context,\n  };\n\n  // validate options\n  validateOptions({ commandDefinition, context, output });\n\n  // validate arguments\n  validateArguments({ commandDefinition, context, output });\n\n  return output;\n}\n"],
+  "mappings": ";AAAA,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAOzB,SAAS,SAAS,SAAsB,mBAAqC;AAClF,QAAM,SAAyB;AAAA,IAC7B,YAAY,QAAQ;AAAA,IACpB,aAAa,QAAQ;AAAA,IACrB;AAAA,EACF;AAGA,kBAAgB,EAAE,mBAAmB,SAAS,OAAO,CAAC;AAGtD,oBAAkB,EAAE,mBAAmB,SAAS,OAAO,CAAC;AAExD,SAAO;AACT;",
+  "names": []
+}

package/lib/mjs/parse/validation/validators/arguments.mjs

@@ -1,2 +1,67 @@
-import{validateSync}from"../../../utilities.mjs";import{validateConflictWith}from"./conflict.mjs";import{validateExclusive}from"./exclusive.mjs";import{validateRequires}from"./requires.mjs";function validateArguments({commandDefinition:e,context:t,output:r}){if(!t.arguments)return;r.arguments??(r.arguments={});const n=e.arguments;if(!n)throw new Error(`Subcommand "${t.subcommand}" does not have arguments`);for(const[r,o]of Object.entries(n))validateRequires({name:r,commandDefinition:e,optionOrArgument:o,context:t,type:"option"}),validateExclusive({name:r,optionOrArgument:o,context:t,type:"option"}),validateConflictWith({name:r,optionOrArgument:o,context:t,type:"option"});const o=Object.entries(t.arguments);for(const[e,{passedValue:i,stringValue:a,source:m,schema:s}]of o){const o="programmatic"===m,u=n[e];if(!u)throw new Error(`Subcommand "${t.subcommand}" does not have the argument "${e}"`);if(!u._preparedType)throw new Error(`internal error: missing prepared type for the argument "${e}"`);const c=o?validateSync(s,i):u._preparedType.validate(a);if(c.issues)throw new Error(`The argument ${e} argument ${o?"":`"${a}"`} is invalid: ${c.issues.map(e=>e.message).join(", ")}`);r.arguments[e]=c.value}}export{validateArguments};
-//# sourceMappingURL=arguments.mjs.map
+// src/parse/validation/validators/arguments.ts
+import { CliError } from "../../../cli-error/cli-error.mjs";
+import { ErrorCause } from "../../../cli-error/error-cause.mjs";
+import { InternalErrorCode } from "../../../cli-error/error-code/internal-error-code.mjs";
+import { ValidationErrorCode } from "../../../cli-error/error-code/validation-error-code.mjs";
+import { validateSync } from "../../../utilities/schema-utilities.mjs";
+import { validateConflictWith } from "./conflict.mjs";
+import { validateExclusive } from "./exclusive.mjs";
+import { validateRequires } from "./requires.mjs";
+function validateArguments({ commandDefinition, context, output }) {
+  if (!context.arguments) return;
+  output.arguments ??= {};
+  const commandKind = "cliName" in commandDefinition ? "command" : "subcommand";
+  const commandName = "cliName" in commandDefinition ? commandDefinition.cliName : commandDefinition.name;
+  const argumentsDefinition = commandDefinition.arguments;
+  if (!argumentsDefinition) {
+    throw new CliError({
+      cause: ErrorCause.Validation,
+      code: ValidationErrorCode.NoArgumentsToValidate,
+      context: { commandKind, commandName }
+    });
+  }
+  for (const [argumentName, argument] of Object.entries(argumentsDefinition)) {
+    validateRequires({ name: argumentName, commandDefinition, optionOrArgument: argument, context, kind: "option" });
+    validateExclusive({ name: argumentName, optionOrArgument: argument, context, kind: "option" });
+    validateConflictWith({ name: argumentName, optionOrArgument: argument, context, kind: "option" });
+  }
+  const argumentContextEntries = Object.entries(context.arguments);
+  for (const [argumentName, { passedValue, stringValue, source, schema }] of argumentContextEntries) {
+    const isProgrammatic = source === "programmatic";
+    const argument = argumentsDefinition[argumentName];
+    if (!argument) {
+      throw new CliError({
+        cause: ErrorCause.Validation,
+        code: ValidationErrorCode.UnknownArgumentValidation,
+        context: { commandKind, commandName, argumentName }
+      });
+    }
+    if (!argument._preparedType) {
+      throw new CliError({
+        cause: ErrorCause.Internal,
+        code: InternalErrorCode.MissingPreparedTypes,
+        context: { commandKind, commandName, kind: "argument", name: argumentName }
+      });
+    }
+    const safeParseResult = isProgrammatic ? validateSync(schema, passedValue) : argument._preparedType.validate(stringValue);
+    if (safeParseResult.issues) {
+      throw new CliError({
+        cause: ErrorCause.Validation,
+        code: ValidationErrorCode.SchemaValidationFailed,
+        context: {
+          commandKind,
+          commandName,
+          kind: "option",
+          name: argumentName,
+          inputValue: isProgrammatic ? passedValue : stringValue,
+          issues: safeParseResult.issues
+        }
+      });
+    }
+    output.arguments[argumentName] = safeParseResult.value;
+  }
+}
+export {
+  validateArguments
+};
+//# sourceMappingURL=arguments.mjs.map

package/lib/mjs/parse/validation/validators/arguments.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["validateSync","validateConflictWith","validateExclusive","validateRequires","validateArguments","commandDefinition","context","output","arguments","argumentsDefinition","Error","subcommand","argumentName","argument","Object","entries","name","optionOrArgument","type","argumentContextEntries","passedValue","stringValue","source","schema","isProgrammatic","_preparedType","safeParseResult","validate","issues","map","issue","message","join","value"],"sources":["../../../../../src/parse/validation/validators/arguments.ts"],"sourcesContent":["import { validateSync } from \"../../../utilities.ts\";\nimport { validateConflictWith } from \"./conflict.ts\";\nimport { validateExclusive } from \"./exclusive.ts\";\nimport { validateRequires } from \"./requires.ts\";\n\nimport type { ContextWide } from \"../../../types/context-types.ts\";\nimport type { Cli, Subcommand } from \"../../../types/definitions-types.ts\";\nimport type { OutputTypeWide } from \"../../../types/io-types.ts\";\n\ninterface ValidateArgument {\n  commandDefinition: Subcommand | Cli;\n  context: ContextWide;\n  output: OutputTypeWide;\n}\n\n/** @throws {Error} */\nexport function validateArguments({ commandDefinition, context, output }: ValidateArgument) {\n  if (!context.arguments) return;\n\n  output.arguments ??= {};\n\n  const argumentsDefinition = commandDefinition.arguments;\n  if (!argumentsDefinition) {\n    throw new Error(`Subcommand \"${context.subcommand}\" does not have arguments`);\n  }\n\n  for (const [argumentName, argument] of Object.entries(argumentsDefinition)) {\n    validateRequires({ name: argumentName, commandDefinition, optionOrArgument: argument, context, type: \"option\" });\n    validateExclusive({ name: argumentName, optionOrArgument: argument, context, type: \"option\" });\n    validateConflictWith({ name: argumentName, optionOrArgument: argument, context, type: \"option\" });\n  }\n\n  const argumentContextEntries = Object.entries(context.arguments);\n\n  for (const [name, { passedValue, stringValue, source, schema }] of argumentContextEntries) {\n    const isProgrammatic = source === \"programmatic\";\n\n    const argument = argumentsDefinition[name];\n    if (!argument) {\n      throw new Error(`Subcommand \"${context.subcommand}\" does not have the argument \"${name}\"`);\n    }\n\n    if (!argument._preparedType) {\n      throw new Error(`internal error: missing prepared type for the argument \"${name}\"`);\n    }\n\n    const safeParseResult = isProgrammatic\n      ? validateSync(schema, passedValue)\n      : argument._preparedType.validate(stringValue);\n\n    if (safeParseResult.issues) {\n      throw new Error(\n        `The argument ${name} argument ${isProgrammatic ? \"\" : `\"${stringValue}\"`} is invalid: ${safeParseResult.issues.map(issue => issue.message).join(\", \")}`,\n      );\n    }\n\n    output.arguments[name] = safeParseResult.value;\n  }\n}\n"],"mappings":"OAASA,iBAAoB,gCACpBC,yBAA4B,wBAC5BC,sBAAyB,yBACzBC,qBAAwB,iBAa1B,SAASC,mBAAkBC,kBAAEA,EAAAC,QAAmBA,EAAAC,OAASA,IAC9D,IAAKD,EAAQE,UAAW,OAExBD,EAAOC,YAAPD,EAAOC,UAAc,CAAC,GAEtB,MAAMC,EAAsBJ,EAAkBG,UAC9C,IAAKC,EACH,MAAM,IAAIC,MAAM,eAAeJ,EAAQK,uCAGzC,UAAYC,EAAcC,KAAaC,OAAOC,QAAQN,GACpDN,iBAAiB,CAAEa,KAAMJ,EAAcP,oBAAmBY,iBAAkBJ,EAAUP,UAASY,KAAM,WACrGhB,kBAAkB,CAAEc,KAAMJ,EAAcK,iBAAkBJ,EAAUP,UAASY,KAAM,WACnFjB,qBAAqB,CAAEe,KAAMJ,EAAcK,iBAAkBJ,EAAUP,UAASY,KAAM,WAGxF,MAAMC,EAAyBL,OAAOC,QAAQT,EAAQE,WAEtD,UAAYQ,GAAMI,YAAEA,EAAAC,YAAaA,EAAAC,OAAaA,EAAAC,OAAQA,MAAaJ,EAAwB,CACzF,MAAMK,EAA4B,iBAAXF,EAEjBT,EAAWJ,EAAoBO,GACrC,IAAKH,EACH,MAAM,IAAIH,MAAM,eAAeJ,EAAQK,2CAA2CK,MAGpF,IAAKH,EAASY,cACZ,MAAM,IAAIf,MAAM,2DAA2DM,MAG7E,MAAMU,EAAkBF,EACpBxB,aAAauB,EAAQH,GACrBP,EAASY,cAAcE,SAASN,GAEpC,GAAIK,EAAgBE,OAClB,MAAM,IAAIlB,MACR,gBAAgBM,cAAiBQ,EAAiB,GAAK,IAAIH,oBAA8BK,EAAgBE,OAAOC,IAAIC,GAASA,EAAMC,SAASC,KAAK,SAIrJzB,EAAOC,UAAUQ,GAAQU,EAAgBO,KAC3C,CACF,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../../../src/parse/validation/validators/arguments.ts"],
+  "sourcesContent": ["import { CliError } from \"../../../cli-error/cli-error.ts\";\nimport { ErrorCause } from \"../../../cli-error/error-cause.ts\";\nimport { InternalErrorCode } from \"../../../cli-error/error-code/internal-error-code.ts\";\nimport { ValidationErrorCode } from \"../../../cli-error/error-code/validation-error-code.ts\";\nimport { validateSync } from \"../../../utilities/schema-utilities.ts\";\nimport { validateConflictWith } from \"./conflict.ts\";\nimport { validateExclusive } from \"./exclusive.ts\";\nimport { validateRequires } from \"./requires.ts\";\n\nimport type { ContextWide } from \"../../../types/context-types.ts\";\nimport type { Cli, Subcommand } from \"../../../types/definitions-types.ts\";\nimport type { OutputTypeWide } from \"../../../types/io-types.ts\";\n\ninterface ValidateArgument {\n  commandDefinition: Subcommand | Cli;\n  context: ContextWide;\n  output: OutputTypeWide;\n}\n\n/** @throws {CliError} */\nexport function validateArguments({ commandDefinition, context, output }: ValidateArgument) {\n  if (!context.arguments) return;\n\n  output.arguments ??= {};\n\n  const commandKind = \"cliName\" in commandDefinition ? \"command\" : \"subcommand\";\n  const commandName = \"cliName\" in commandDefinition ? commandDefinition.cliName : commandDefinition.name;\n\n  const argumentsDefinition = commandDefinition.arguments;\n  if (!argumentsDefinition) {\n    throw new CliError({\n      cause: ErrorCause.Validation,\n      code: ValidationErrorCode.NoArgumentsToValidate,\n      context: { commandKind, commandName },\n    });\n  }\n\n  for (const [argumentName, argument] of Object.entries(argumentsDefinition)) {\n    validateRequires({ name: argumentName, commandDefinition, optionOrArgument: argument, context, kind: \"option\" });\n    validateExclusive({ name: argumentName, optionOrArgument: argument, context, kind: \"option\" });\n    validateConflictWith({ name: argumentName, optionOrArgument: argument, context, kind: \"option\" });\n  }\n\n  const argumentContextEntries = Object.entries(context.arguments);\n\n  for (const [argumentName, { passedValue, stringValue, source, schema }] of argumentContextEntries) {\n    const isProgrammatic = source === \"programmatic\";\n\n    const argument = argumentsDefinition[argumentName];\n    if (!argument) {\n      throw new CliError({\n        cause: ErrorCause.Validation,\n        code: ValidationErrorCode.UnknownArgumentValidation,\n        context: { commandKind, commandName, argumentName },\n      });\n    }\n\n    if (!argument._preparedType) {\n      throw new CliError({\n        cause: ErrorCause.Internal,\n        code: InternalErrorCode.MissingPreparedTypes,\n        context: { commandKind, commandName, kind: \"argument\", name: argumentName },\n      });\n    }\n\n    const safeParseResult = isProgrammatic\n      ? validateSync(schema, passedValue)\n      : argument._preparedType.validate(stringValue);\n\n    if (safeParseResult.issues) {\n      throw new CliError({\n        cause: ErrorCause.Validation,\n        code: ValidationErrorCode.SchemaValidationFailed,\n        context: {\n          commandKind,\n          commandName,\n          kind: \"option\",\n          name: argumentName,\n          inputValue: isProgrammatic ? passedValue : stringValue,\n          issues: safeParseResult.issues,\n        },\n      });\n    }\n\n    output.arguments[argumentName] = safeParseResult.value;\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,yBAAyB;AAClC,SAAS,2BAA2B;AACpC,SAAS,oBAAoB;AAC7B,SAAS,4BAA4B;AACrC,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AAa1B,SAAS,kBAAkB,EAAE,mBAAmB,SAAS,OAAO,GAAqB;AAC1F,MAAI,CAAC,QAAQ,UAAW;AAExB,SAAO,cAAc,CAAC;AAEtB,QAAM,cAAc,aAAa,oBAAoB,YAAY;AACjE,QAAM,cAAc,aAAa,oBAAoB,kBAAkB,UAAU,kBAAkB;AAEnG,QAAM,sBAAsB,kBAAkB;AAC9C,MAAI,CAAC,qBAAqB;AACxB,UAAM,IAAI,SAAS;AAAA,MACjB,OAAO,WAAW;AAAA,MAClB,MAAM,oBAAoB;AAAA,MAC1B,SAAS,EAAE,aAAa,YAAY;AAAA,IACtC,CAAC;AAAA,EACH;AAEA,aAAW,CAAC,cAAc,QAAQ,KAAK,OAAO,QAAQ,mBAAmB,GAAG;AAC1E,qBAAiB,EAAE,MAAM,cAAc,mBAAmB,kBAAkB,UAAU,SAAS,MAAM,SAAS,CAAC;AAC/G,sBAAkB,EAAE,MAAM,cAAc,kBAAkB,UAAU,SAAS,MAAM,SAAS,CAAC;AAC7F,yBAAqB,EAAE,MAAM,cAAc,kBAAkB,UAAU,SAAS,MAAM,SAAS,CAAC;AAAA,EAClG;AAEA,QAAM,yBAAyB,OAAO,QAAQ,QAAQ,SAAS;AAE/D,aAAW,CAAC,cAAc,EAAE,aAAa,aAAa,QAAQ,OAAO,CAAC,KAAK,wBAAwB;AACjG,UAAM,iBAAiB,WAAW;AAElC,UAAM,WAAW,oBAAoB,YAAY;AACjD,QAAI,CAAC,UAAU;AACb,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,oBAAoB;AAAA,QAC1B,SAAS,EAAE,aAAa,aAAa,aAAa;AAAA,MACpD,CAAC;AAAA,IACH;AAEA,QAAI,CAAC,SAAS,eAAe;AAC3B,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,kBAAkB;AAAA,QACxB,SAAS,EAAE,aAAa,aAAa,MAAM,YAAY,MAAM,aAAa;AAAA,MAC5E,CAAC;AAAA,IACH;AAEA,UAAM,kBAAkB,iBACpB,aAAa,QAAQ,WAAW,IAChC,SAAS,cAAc,SAAS,WAAW;AAE/C,QAAI,gBAAgB,QAAQ;AAC1B,YAAM,IAAI,SAAS;AAAA,QACjB,OAAO,WAAW;AAAA,QAClB,MAAM,oBAAoB;AAAA,QAC1B,SAAS;AAAA,UACP;AAAA,UACA;AAAA,UACA,MAAM;AAAA,UACN,MAAM;AAAA,UACN,YAAY,iBAAiB,cAAc;AAAA,UAC3C,QAAQ,gBAAgB;AAAA,QAC1B;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WAAO,UAAU,YAAY,IAAI,gBAAgB;AAAA,EACnD;AACF;",
+  "names": []
+}

package/lib/mjs/parse/validation/validators/conflict.mjs

@@ -1,2 +1,38 @@
-import{isOptionOrArgumentExplicitlyPassed}from"./explicitly-passed.mjs";function validateConflictWith({name:t,optionOrArgument:e,context:n,type:i}){const o=e.conflictWith;if(!o||0===o.length)return;if(!isOptionOrArgumentExplicitlyPassed(t,n))return;const s=[],r=[];if(n.options)for(const[e,i]of Object.entries(n.options))e!==t&&o.includes(e)&&"default"!==i.source&&s.push(e);if(n.arguments)for(const[e,i]of Object.entries(n.arguments))e!==t&&o.includes(e)&&"default"!==i.source&&r.push(e);if(0===s.length&&0===r.length)return;const c=[];if(s.length>0){const t=s.map(t=>`"${t}"`).join(", "),e=s.length>1?"s":"";c.push(`option${e} ${t}`)}if(r.length>0){const t=r.map(t=>`"${t}"`).join(", "),e=r.length>1?"s":"";c.push(`argument${e} ${t}`)}const l=c.join(" and ");throw new Error(`${i} "${t}" cannot be used with the ${l} because they are mutually exclusive.`)}export{validateConflictWith};
-//# sourceMappingURL=conflict.mjs.map
+// src/parse/validation/validators/conflict.ts
+import { CliError } from "../../../cli-error/cli-error.mjs";
+import { ErrorCause } from "../../../cli-error/error-cause.mjs";
+import { ValidationErrorCode } from "../../../cli-error/error-code/validation-error-code.mjs";
+import { isOptionOrArgumentExplicitlyPassed } from "./explicitly-passed.mjs";
+function validateConflictWith({ name, optionOrArgument, context, kind }) {
+  const conflictWith = optionOrArgument.conflictWith;
+  if (!conflictWith || conflictWith.length === 0) return;
+  if (!isOptionOrArgumentExplicitlyPassed(name, context)) return;
+  const conflictedOptions = [];
+  const conflictedArguments = [];
+  if (context.options) {
+    for (const [optionName, optionContext] of Object.entries(context.options)) {
+      if (optionName === name) continue;
+      if (!conflictWith.includes(optionName)) continue;
+      if (optionContext.source === "default") continue;
+      conflictedOptions.push(optionName);
+    }
+  }
+  if (context.arguments) {
+    for (const [argumentName, argumentContext] of Object.entries(context.arguments)) {
+      if (argumentName === name) continue;
+      if (!conflictWith.includes(argumentName)) continue;
+      if (argumentContext.source === "default") continue;
+      conflictedArguments.push(argumentName);
+    }
+  }
+  if (conflictedOptions.length === 0 && conflictedArguments.length === 0) return;
+  throw new CliError({
+    cause: ErrorCause.Validation,
+    code: ValidationErrorCode.MutuallyExclusiveConflict,
+    context: { kind, name, conflictedOptions, conflictedArguments }
+  });
+}
+export {
+  validateConflictWith
+};
+//# sourceMappingURL=conflict.mjs.map

package/lib/mjs/parse/validation/validators/conflict.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["isOptionOrArgumentExplicitlyPassed","validateConflictWith","name","optionOrArgument","context","type","conflictWith","length","conflictedOptions","conflictedArguments","options","optionName","optionContext","Object","entries","includes","source","push","arguments","argumentName","argumentContext","parts","formatted","map","o","join","s","a","joinedParts","Error"],"sources":["../../../../../src/parse/validation/validators/conflict.ts"],"sourcesContent":["import { isOptionOrArgumentExplicitlyPassed } from \"./explicitly-passed.ts\";\n\nimport type { ContextWide } from \"../../../types/context-types.ts\";\nimport type { Argument, Option } from \"../../../types/definitions-types.ts\";\n\ninterface ValidateConflictOptions {\n  /** The option or argument name to check its `requires` */\n  name: string;\n\n  /** The option or argument to check */\n  optionOrArgument: Option | Argument;\n\n  /** The parsed context */\n  context: ContextWide;\n\n  /** What we're checking */\n  type: \"option\" | \"argument\";\n}\n\n/** @throws {Error} */\nexport function validateConflictWith({ name, optionOrArgument, context, type }: ValidateConflictOptions) {\n  const conflictWith = optionOrArgument.conflictWith;\n  if (!conflictWith || conflictWith.length === 0) return;\n\n  // Check if the options/argument is passed\n  if (!isOptionOrArgumentExplicitlyPassed(name, context)) return;\n\n  const conflictedOptions: string[] = [];\n  const conflictedArguments: string[] = [];\n\n  if (context.options) {\n    for (const [optionName, optionContext] of Object.entries(context.options)) {\n      if (optionName === name) continue; // don't check self\n      if (!conflictWith.includes(optionName)) continue; // not a conflict\n      if (optionContext.source === \"default\") continue; // not explicitly passed\n      conflictedOptions.push(optionName);\n    }\n  }\n\n  if (context.arguments) {\n    for (const [argumentName, argumentContext] of Object.entries(context.arguments)) {\n      if (argumentName === name) continue; // don't check self\n      if (!conflictWith.includes(argumentName)) continue; // not a conflict\n      if (argumentContext.source === \"default\") continue; // not explicitly passed\n      conflictedArguments.push(argumentName);\n    }\n  }\n\n  if (conflictedOptions.length === 0 && conflictedArguments.length === 0) return; // OK\n\n  const parts: string[] = [];\n\n  if (conflictedOptions.length > 0) {\n    const formatted = conflictedOptions.map(o => `\"${o}\"`).join(\", \");\n    const s = conflictedOptions.length > 1 ? \"s\" : \"\";\n    parts.push(`option${s} ${formatted}`);\n  }\n\n  if (conflictedArguments.length > 0) {\n    const formatted = conflictedArguments.map(a => `\"${a}\"`).join(\", \");\n    const s = conflictedArguments.length > 1 ? \"s\" : \"\";\n    parts.push(`argument${s} ${formatted}`);\n  }\n\n  const joinedParts = parts.join(\" and \");\n\n  throw new Error(`${type} \"${name}\" cannot be used with the ${joinedParts} because they are mutually exclusive.`);\n}\n"],"mappings":"OAASA,uCAA0C,0BAoB5C,SAASC,sBAAqBC,KAAEA,EAAAC,iBAAMA,EAAAC,QAAkBA,EAAAC,KAASA,IACtE,MAAMC,EAAeH,EAAiBG,aACtC,IAAKA,GAAwC,IAAxBA,EAAaC,OAAc,OAGhD,IAAKP,mCAAmCE,EAAME,GAAU,OAExD,MAAMI,EAA8B,GAC9BC,EAAgC,GAEtC,GAAIL,EAAQM,QACV,UAAYC,EAAYC,KAAkBC,OAAOC,QAAQV,EAAQM,SAC3DC,IAAeT,GACdI,EAAaS,SAASJ,IACE,YAAzBC,EAAcI,QAClBR,EAAkBS,KAAKN,GAI3B,GAAIP,EAAQc,UACV,UAAYC,EAAcC,KAAoBP,OAAOC,QAAQV,EAAQc,WAC/DC,IAAiBjB,GAChBI,EAAaS,SAASI,IACI,YAA3BC,EAAgBJ,QACpBP,EAAoBQ,KAAKE,GAI7B,GAAiC,IAA7BX,EAAkBD,QAA+C,IAA/BE,EAAoBF,OAAc,OAExE,MAAMc,EAAkB,GAExB,GAAIb,EAAkBD,OAAS,EAAG,CAChC,MAAMe,EAAYd,EAAkBe,IAAIC,GAAK,IAAIA,MAAMC,KAAK,MACtDC,EAAIlB,EAAkBD,OAAS,EAAI,IAAM,GAC/Cc,EAAMJ,KAAK,SAASS,KAAKJ,IAC3B,CAEA,GAAIb,EAAoBF,OAAS,EAAG,CAClC,MAAMe,EAAYb,EAAoBc,IAAII,GAAK,IAAIA,MAAMF,KAAK,MACxDC,EAAIjB,EAAoBF,OAAS,EAAI,IAAM,GACjDc,EAAMJ,KAAK,WAAWS,KAAKJ,IAC7B,CAEA,MAAMM,EAAcP,EAAMI,KAAK,SAE/B,MAAM,IAAII,MAAM,GAAGxB,MAASH,8BAAiC0B,yCAC/D,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../../../src/parse/validation/validators/conflict.ts"],
+  "sourcesContent": ["import { CliError } from \"../../../cli-error/cli-error.ts\";\nimport { ErrorCause } from \"../../../cli-error/error-cause.ts\";\nimport { ValidationErrorCode } from \"../../../cli-error/error-code/validation-error-code.ts\";\nimport { isOptionOrArgumentExplicitlyPassed } from \"./explicitly-passed.ts\";\n\nimport type { ContextWide } from \"../../../types/context-types.ts\";\nimport type { Argument, Option } from \"../../../types/definitions-types.ts\";\n\ninterface ValidateConflictOptions {\n  /** The option or argument name to check its `requires` */\n  name: string;\n\n  /** The option or argument to check */\n  optionOrArgument: Option | Argument;\n\n  /** The parsed context */\n  context: ContextWide;\n\n  /** What we're checking */\n  kind: \"option\" | \"argument\";\n}\n\n/** @throws {CliError} */\nexport function validateConflictWith({ name, optionOrArgument, context, kind }: ValidateConflictOptions) {\n  const conflictWith = optionOrArgument.conflictWith;\n  if (!conflictWith || conflictWith.length === 0) return;\n\n  // Check if the options/argument is passed\n  if (!isOptionOrArgumentExplicitlyPassed(name, context)) return;\n\n  const conflictedOptions: string[] = [];\n  const conflictedArguments: string[] = [];\n\n  if (context.options) {\n    for (const [optionName, optionContext] of Object.entries(context.options)) {\n      if (optionName === name) continue; // don't check self\n      if (!conflictWith.includes(optionName)) continue; // not a conflict\n      if (optionContext.source === \"default\") continue; // not explicitly passed\n      conflictedOptions.push(optionName);\n    }\n  }\n\n  if (context.arguments) {\n    for (const [argumentName, argumentContext] of Object.entries(context.arguments)) {\n      if (argumentName === name) continue; // don't check self\n      if (!conflictWith.includes(argumentName)) continue; // not a conflict\n      if (argumentContext.source === \"default\") continue; // not explicitly passed\n      conflictedArguments.push(argumentName);\n    }\n  }\n\n  if (conflictedOptions.length === 0 && conflictedArguments.length === 0) return; // OK\n\n  throw new CliError({\n    cause: ErrorCause.Validation,\n    code: ValidationErrorCode.MutuallyExclusiveConflict,\n    context: { kind, name, conflictedOptions, conflictedArguments },\n  });\n}\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,2BAA2B;AACpC,SAAS,0CAA0C;AAoB5C,SAAS,qBAAqB,EAAE,MAAM,kBAAkB,SAAS,KAAK,GAA4B;AACvG,QAAM,eAAe,iBAAiB;AACtC,MAAI,CAAC,gBAAgB,aAAa,WAAW,EAAG;AAGhD,MAAI,CAAC,mCAAmC,MAAM,OAAO,EAAG;AAExD,QAAM,oBAA8B,CAAC;AACrC,QAAM,sBAAgC,CAAC;AAEvC,MAAI,QAAQ,SAAS;AACnB,eAAW,CAAC,YAAY,aAAa,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AACzE,UAAI,eAAe,KAAM;AACzB,UAAI,CAAC,aAAa,SAAS,UAAU,EAAG;AACxC,UAAI,cAAc,WAAW,UAAW;AACxC,wBAAkB,KAAK,UAAU;AAAA,IACnC;AAAA,EACF;AAEA,MAAI,QAAQ,WAAW;AACrB,eAAW,CAAC,cAAc,eAAe,KAAK,OAAO,QAAQ,QAAQ,SAAS,GAAG;AAC/E,UAAI,iBAAiB,KAAM;AAC3B,UAAI,CAAC,aAAa,SAAS,YAAY,EAAG;AAC1C,UAAI,gBAAgB,WAAW,UAAW;AAC1C,0BAAoB,KAAK,YAAY;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,kBAAkB,WAAW,KAAK,oBAAoB,WAAW,EAAG;AAExE,QAAM,IAAI,SAAS;AAAA,IACjB,OAAO,WAAW;AAAA,IAClB,MAAM,oBAAoB;AAAA,IAC1B,SAAS,EAAE,MAAM,MAAM,mBAAmB,oBAAoB;AAAA,EAChE,CAAC;AACH;",
+  "names": []
+}

package/lib/mjs/parse/validation/validators/exclusive.mjs

@@ -1,2 +1,39 @@
-import{isOptionOrArgumentExplicitlyPassed}from"./explicitly-passed.mjs";function validateExclusive({name:e,optionOrArgument:t,context:n,type:s}){if(!t.exclusive)return;if(!isOptionOrArgumentExplicitlyPassed(e,n))return;const i=t.requires??[],o=[],r=[];if(n.options)for(const[t,s]of Object.entries(n.options))t!==e&&(i.includes(t)||"default"!==s.source&&o.push(t));if(n.arguments)for(const[t,s]of Object.entries(n.arguments))t!==e&&(i.includes(t)||"default"!==s.source&&r.push(t));if(0===o.length&&0===r.length)return;const u=[];if(o.length>0){const e=o.map(e=>`"${e}"`).join(", "),t=o.length>1?"s":"";u.push(`option${t} ${e}`)}if(r.length>0){const e=r.map(e=>`"${e}"`).join(", "),t=r.length>1?"s":"";u.push(`argument${t} ${e}`)}const c=u.join(" and ");throw new Error(`${s} "${e}" cannot be used with the ${c} because they are mutually exclusive.`)}export{validateExclusive};
-//# sourceMappingURL=exclusive.mjs.map
+// src/parse/validation/validators/exclusive.ts
+import { CliError } from "../../../cli-error/cli-error.mjs";
+import { ErrorCause } from "../../../cli-error/error-cause.mjs";
+import { ValidationErrorCode } from "../../../cli-error/error-code/validation-error-code.mjs";
+import { isOptionOrArgumentExplicitlyPassed } from "./explicitly-passed.mjs";
+function validateExclusive({ name, optionOrArgument, context, kind }) {
+  const exclusive = optionOrArgument.exclusive;
+  if (!exclusive) return;
+  if (!isOptionOrArgumentExplicitlyPassed(name, context)) return;
+  const requires = optionOrArgument.requires ?? [];
+  const conflictedOptions = [];
+  const conflictedArguments = [];
+  if (context.options) {
+    for (const [optionName, optionContext] of Object.entries(context.options)) {
+      if (optionName === name) continue;
+      if (requires.includes(optionName)) continue;
+      if (optionContext.source === "default") continue;
+      conflictedOptions.push(optionName);
+    }
+  }
+  if (context.arguments) {
+    for (const [argumentName, argumentContext] of Object.entries(context.arguments)) {
+      if (argumentName === name) continue;
+      if (requires.includes(argumentName)) continue;
+      if (argumentContext.source === "default") continue;
+      conflictedArguments.push(argumentName);
+    }
+  }
+  if (conflictedOptions.length === 0 && conflictedArguments.length === 0) return;
+  throw new CliError({
+    cause: ErrorCause.Validation,
+    code: ValidationErrorCode.MutuallyExclusiveConflict,
+    context: { kind, name, conflictedOptions, conflictedArguments }
+  });
+}
+export {
+  validateExclusive
+};
+//# sourceMappingURL=exclusive.mjs.map

package/lib/mjs/parse/validation/validators/exclusive.mjs.map

@@ -1 +1,7 @@
-{"version":3,"names":["isOptionOrArgumentExplicitlyPassed","validateExclusive","name","optionOrArgument","context","type","exclusive","requires","mutuallyExclusiveOptions","mutuallyExclusiveArguments","options","optionName","optionContext","Object","entries","includes","source","push","arguments","argumentName","argumentContext","length","parts","formatted","map","o","join","s","a","joinedParts","Error"],"sources":["../../../../../src/parse/validation/validators/exclusive.ts"],"sourcesContent":["import { isOptionOrArgumentExplicitlyPassed } from \"./explicitly-passed.ts\";\n\nimport type { ContextWide } from \"../../../types/context-types.ts\";\nimport type { Argument, Option } from \"../../../types/definitions-types.ts\";\n\ninterface ValidateExclusiveOptions {\n  /** The option or argument name to check its `requires` */\n  name: string;\n\n  /** The option or argument to check */\n  optionOrArgument: Option | Argument;\n\n  /** The parsed context */\n  context: ContextWide;\n\n  /** What we're checking */\n  type: \"option\" | \"argument\";\n}\n\n/** @throws {Error} */\nexport function validateExclusive({ name, optionOrArgument, context, type }: ValidateExclusiveOptions) {\n  const exclusive = optionOrArgument.exclusive;\n  if (!exclusive) return;\n\n  // Check if the options/argument is passed\n  if (!isOptionOrArgumentExplicitlyPassed(name, context)) return;\n\n  const requires = optionOrArgument.requires ?? [];\n\n  const mutuallyExclusiveOptions: string[] = [];\n  const mutuallyExclusiveArguments: string[] = [];\n\n  if (context.options) {\n    for (const [optionName, optionContext] of Object.entries(context.options)) {\n      if (optionName === name) continue; // don't check self\n      if (requires.includes(optionName)) continue; // allow required options\n      if (optionContext.source === \"default\") continue; // not explicitly passed\n      mutuallyExclusiveOptions.push(optionName);\n    }\n  }\n\n  if (context.arguments) {\n    for (const [argumentName, argumentContext] of Object.entries(context.arguments)) {\n      if (argumentName === name) continue; // don't check self\n      if (requires.includes(argumentName)) continue; // allow required arguments\n      if (argumentContext.source === \"default\") continue; // not explicitly passed\n      mutuallyExclusiveArguments.push(argumentName);\n    }\n  }\n\n  if (mutuallyExclusiveOptions.length === 0 && mutuallyExclusiveArguments.length === 0) return;\n\n  const parts: string[] = [];\n\n  if (mutuallyExclusiveOptions.length > 0) {\n    const formatted = mutuallyExclusiveOptions.map(o => `\"${o}\"`).join(\", \");\n    const s = mutuallyExclusiveOptions.length > 1 ? \"s\" : \"\";\n    parts.push(`option${s} ${formatted}`);\n  }\n\n  if (mutuallyExclusiveArguments.length > 0) {\n    const formatted = mutuallyExclusiveArguments.map(a => `\"${a}\"`).join(\", \");\n    const s = mutuallyExclusiveArguments.length > 1 ? \"s\" : \"\";\n    parts.push(`argument${s} ${formatted}`);\n  }\n\n  const joinedParts = parts.join(\" and \");\n\n  throw new Error(`${type} \"${name}\" cannot be used with the ${joinedParts} because they are mutually exclusive.`);\n}\n"],"mappings":"OAASA,uCAA0C,0BAoB5C,SAASC,mBAAkBC,KAAEA,EAAAC,iBAAMA,EAAAC,QAAkBA,EAAAC,KAASA,IAEnE,IADkBF,EAAiBG,UACnB,OAGhB,IAAKN,mCAAmCE,EAAME,GAAU,OAExD,MAAMG,EAAWJ,EAAiBI,UAAY,GAExCC,EAAqC,GACrCC,EAAuC,GAE7C,GAAIL,EAAQM,QACV,UAAYC,EAAYC,KAAkBC,OAAOC,QAAQV,EAAQM,SAC3DC,IAAeT,IACfK,EAASQ,SAASJ,IACO,YAAzBC,EAAcI,QAClBR,EAAyBS,KAAKN,IAIlC,GAAIP,EAAQc,UACV,UAAYC,EAAcC,KAAoBP,OAAOC,QAAQV,EAAQc,WAC/DC,IAAiBjB,IACjBK,EAASQ,SAASI,IACS,YAA3BC,EAAgBJ,QACpBP,EAA2BQ,KAAKE,IAIpC,GAAwC,IAApCX,EAAyBa,QAAsD,IAAtCZ,EAA2BY,OAAc,OAEtF,MAAMC,EAAkB,GAExB,GAAId,EAAyBa,OAAS,EAAG,CACvC,MAAME,EAAYf,EAAyBgB,IAAIC,GAAK,IAAIA,MAAMC,KAAK,MAC7DC,EAAInB,EAAyBa,OAAS,EAAI,IAAM,GACtDC,EAAML,KAAK,SAASU,KAAKJ,IAC3B,CAEA,GAAId,EAA2BY,OAAS,EAAG,CACzC,MAAME,EAAYd,EAA2Be,IAAII,GAAK,IAAIA,MAAMF,KAAK,MAC/DC,EAAIlB,EAA2BY,OAAS,EAAI,IAAM,GACxDC,EAAML,KAAK,WAAWU,KAAKJ,IAC7B,CAEA,MAAMM,EAAcP,EAAMI,KAAK,SAE/B,MAAM,IAAII,MAAM,GAAGzB,MAASH,8BAAiC2B,yCAC/D,Q","ignoreList":[]}
+{
+  "version": 3,
+  "sources": ["../../../../../src/parse/validation/validators/exclusive.ts"],
+  "sourcesContent": ["import { CliError } from \"../../../cli-error/cli-error.ts\";\nimport { ErrorCause } from \"../../../cli-error/error-cause.ts\";\nimport { ValidationErrorCode } from \"../../../cli-error/error-code/validation-error-code.ts\";\nimport { isOptionOrArgumentExplicitlyPassed } from \"./explicitly-passed.ts\";\n\nimport type { ContextWide } from \"../../../types/context-types.ts\";\nimport type { Argument, Option } from \"../../../types/definitions-types.ts\";\n\ninterface ValidateExclusiveOptions {\n  /** The option or argument name to check its `requires` */\n  name: string;\n\n  /** The option or argument to check */\n  optionOrArgument: Option | Argument;\n\n  /** The parsed context */\n  context: ContextWide;\n\n  /** What we're checking */\n  kind: \"option\" | \"argument\";\n}\n\n/** @throws {CliError} */\nexport function validateExclusive({ name, optionOrArgument, context, kind }: ValidateExclusiveOptions) {\n  const exclusive = optionOrArgument.exclusive;\n  if (!exclusive) return;\n\n  // Check if the options/argument is passed\n  if (!isOptionOrArgumentExplicitlyPassed(name, context)) return;\n\n  const requires = optionOrArgument.requires ?? [];\n\n  const conflictedOptions: string[] = [];\n  const conflictedArguments: string[] = [];\n\n  if (context.options) {\n    for (const [optionName, optionContext] of Object.entries(context.options)) {\n      if (optionName === name) continue; // don't check self\n      if (requires.includes(optionName)) continue; // allow required options\n      if (optionContext.source === \"default\") continue; // not explicitly passed\n      conflictedOptions.push(optionName);\n    }\n  }\n\n  if (context.arguments) {\n    for (const [argumentName, argumentContext] of Object.entries(context.arguments)) {\n      if (argumentName === name) continue; // don't check self\n      if (requires.includes(argumentName)) continue; // allow required arguments\n      if (argumentContext.source === \"default\") continue; // not explicitly passed\n      conflictedArguments.push(argumentName);\n    }\n  }\n\n  if (conflictedOptions.length === 0 && conflictedArguments.length === 0) return;\n\n  throw new CliError({\n    cause: ErrorCause.Validation,\n    code: ValidationErrorCode.MutuallyExclusiveConflict,\n    context: { kind, name, conflictedOptions, conflictedArguments },\n  });\n}\n"],
+  "mappings": ";AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,2BAA2B;AACpC,SAAS,0CAA0C;AAoB5C,SAAS,kBAAkB,EAAE,MAAM,kBAAkB,SAAS,KAAK,GAA6B;AACrG,QAAM,YAAY,iBAAiB;AACnC,MAAI,CAAC,UAAW;AAGhB,MAAI,CAAC,mCAAmC,MAAM,OAAO,EAAG;AAExD,QAAM,WAAW,iBAAiB,YAAY,CAAC;AAE/C,QAAM,oBAA8B,CAAC;AACrC,QAAM,sBAAgC,CAAC;AAEvC,MAAI,QAAQ,SAAS;AACnB,eAAW,CAAC,YAAY,aAAa,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AACzE,UAAI,eAAe,KAAM;AACzB,UAAI,SAAS,SAAS,UAAU,EAAG;AACnC,UAAI,cAAc,WAAW,UAAW;AACxC,wBAAkB,KAAK,UAAU;AAAA,IACnC;AAAA,EACF;AAEA,MAAI,QAAQ,WAAW;AACrB,eAAW,CAAC,cAAc,eAAe,KAAK,OAAO,QAAQ,QAAQ,SAAS,GAAG;AAC/E,UAAI,iBAAiB,KAAM;AAC3B,UAAI,SAAS,SAAS,YAAY,EAAG;AACrC,UAAI,gBAAgB,WAAW,UAAW;AAC1C,0BAAoB,KAAK,YAAY;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,kBAAkB,WAAW,KAAK,oBAAoB,WAAW,EAAG;AAExE,QAAM,IAAI,SAAS;AAAA,IACjB,OAAO,WAAW;AAAA,IAClB,MAAM,oBAAoB;AAAA,IAC1B,SAAS,EAAE,MAAM,MAAM,mBAAmB,oBAAoB;AAAA,EAChE,CAAC;AACH;",
+  "names": []
+}