@stricli/core 1.2.4 → 1.2.5

package/dist/index.cjs

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