@shell-shock/core 0.7.0 → 0.8.1

package/dist/components/options-parser-logic.d.cts

@@ -1,15 +1,19 @@
-import { CommandOption, CommandTree, CommandTreePath } from "../types/command.cjs";
-import * as _alloy_js_core4 from "@alloy-js/core";
+import { CommandOption, CommandTree } from "../types/command.cjs";
+import * as _alloy_js_core5 from "@alloy-js/core";
 
 //#region src/components/options-parser-logic.d.ts
-interface DynamicPathSegmentsParserLogicProps {
+interface DynamicSegmentsParserLogicProps {
   /**
-   * The command path to generate the dynamic path segments parser logic for.
+   * The command to generate the dynamic path segments parser logic for. This is used to access the command options and parameters when generating the parser logic for dynamic path segments.
    */
-  path: CommandTreePath;
+  command: CommandTree;
+  /**
+   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command-line arguments to option names and aliases.
+   */
+  isCaseSensitive: boolean;
 }
-declare function DynamicPathSegmentsParserLogic(props: DynamicPathSegmentsParserLogicProps): _alloy_js_core4.Children;
-interface PositionalParametersParserLogicProps {
+declare function DynamicSegmentsParserLogic(props: DynamicSegmentsParserLogicProps): _alloy_js_core5.Children;
+interface ArgumentsParserLogicProps {
   /**
    * The command to generate the positional parameters parser logic for.
    */
@@ -18,8 +22,12 @@ interface PositionalParametersParserLogicProps {
    * The environment variable prefix to use for options that have an associated environment variable. This prefix will be used in the generated code to access the environment variables (e.g., `env.${envPrefix}_OPTION_NAME`).
    */
   envPrefix: string;
+  /**
+   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command-line arguments to option names and aliases.
+   */
+  isCaseSensitive: boolean;
 }
-declare function PositionalParametersParserLogic(props: PositionalParametersParserLogicProps): _alloy_js_core4.Children;
+declare function ArgumentsParserLogic(props: ArgumentsParserLogicProps): _alloy_js_core5.Children;
 /**
  * The command option interface property.
  */
@@ -27,7 +35,7 @@ declare function OptionsMember({
   option
 }: {
   option: CommandOption;
-}): _alloy_js_core4.Children;
+}): _alloy_js_core5.Children;
 interface OptionsMemberParserLogicProps {
   /**
    * The option name to generate the parser logic for.
@@ -47,27 +55,27 @@ interface OptionsMemberParserLogicProps {
 /**
  * The command option property parser logic.
  */
-declare function OptionsMemberParserLogic(props: OptionsMemberParserLogicProps): _alloy_js_core4.Children;
+declare function OptionsMemberParserLogic(props: OptionsMemberParserLogicProps): _alloy_js_core5.Children;
 interface OptionsMemberParserConditionProps {
   /**
    * The option name to generate the parser logic for.
    */
   name: string;
   /**
-   * Aliases for the option, which will also be parsed in the generated code. This will affect how the generated code compares command-line arguments to option names and aliases.
+   * Aliases for the option, which will also be parsed in the generated code. This will affect how the generated code compares command line arguments to option names and aliases.
    */
   alias?: string[];
   /**
-   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command-line arguments to option names and aliases.
+   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command line arguments to option names and aliases.
    *
    * @defaultValue false
    */
   isCaseSensitive: boolean;
 }
-declare function OptionsMemberParserCondition(props: OptionsMemberParserConditionProps): _alloy_js_core4.Children;
+declare function OptionsMemberParserCondition(props: OptionsMemberParserConditionProps): _alloy_js_core5.Children;
 declare function OptionsInterfaceDeclaration(props: {
   command: CommandTree;
-}): _alloy_js_core4.Children;
+}): _alloy_js_core5.Children;
 interface OptionsParserLogicProps {
   /**
    * The command to generate the options parser logic for.
@@ -87,7 +95,7 @@ interface OptionsParserLogicProps {
 /**
  * The command options parser logic.
  */
-declare function OptionsParserLogic(props: OptionsParserLogicProps): _alloy_js_core4.Children;
+declare function OptionsParserLogic(props: OptionsParserLogicProps): _alloy_js_core5.Children;
 interface CommandParserLogicProps {
   /**
    * The command to generate the parser logic for.
@@ -107,7 +115,7 @@ interface CommandParserLogicProps {
 /**
  * The command parser logic, which includes parsing dynamic path segments, positional parameters, and options.
  */
-declare function CommandParserLogic(props: CommandParserLogicProps): _alloy_js_core4.Children;
+declare function CommandParserLogic(props: CommandParserLogicProps): _alloy_js_core5.Children;
 //#endregion
-export { CommandParserLogic, CommandParserLogicProps, DynamicPathSegmentsParserLogic, DynamicPathSegmentsParserLogicProps, OptionsInterfaceDeclaration, OptionsMember, OptionsMemberParserCondition, OptionsMemberParserConditionProps, OptionsMemberParserLogic, OptionsMemberParserLogicProps, OptionsParserLogic, OptionsParserLogicProps, PositionalParametersParserLogic, PositionalParametersParserLogicProps };
+export { ArgumentsParserLogic, ArgumentsParserLogicProps, CommandParserLogic, CommandParserLogicProps, DynamicSegmentsParserLogic, DynamicSegmentsParserLogicProps, OptionsInterfaceDeclaration, OptionsMember, OptionsMemberParserCondition, OptionsMemberParserConditionProps, OptionsMemberParserLogic, OptionsMemberParserLogicProps, OptionsParserLogic, OptionsParserLogicProps };
 //# sourceMappingURL=options-parser-logic.d.cts.map

package/dist/components/options-parser-logic.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"options-parser-logic.d.cts","names":[],"sources":["../../src/components/options-parser-logic.tsx"],"sourcesContent":[],"mappings":";;;;UA6CiB,mCAAA;;;AAAjB;EAOgB,IAAA,EAHR,eAGQ;AAoDhB;AAYgB,iBAhEA,8BAAA,CAiEP,KAAA,EAhEA,mCAgEoC,CAAA,EAhED,eAAA,CAAA,QAgEC;AAmG7B,UAhHC,oCAAA,CAgHY;EAAG;;;EAAmC,OAAA,EA5GxD,WA4GwD;EAuClD;AAsBjB;AAuKA;EAmBgB,SAAA,EAAA,MAAA;AAmEhB;AAciB,iBA5aD,+BAAA,CAgbM,KAAA,EA/ab,oCA+aa,CAAA,EA/auB,eAAA,CAAA,QA+avB;AAkBtB;AA8HA;AAsBA;iBAlfgB,aAAA;;;UAAoC;IAAa,eAAA,CAAE;UAuClD,6BAAA;;;;;;;;UASP;;;;;;;;;;;iBAaM,wBAAA,QAAgC,gCAA6B,eAAA,CAAA;UAuK5D,iCAAA;;;;;;;;;;;;;;;;iBAmBD,4BAAA,QACP,oCAAiC,eAAA,CAAA;iBAkE1B,2BAAA;WAA8C;IAAW,eAAA,CAAE;UAc1D,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA;UA8HhD,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA"}
+{"version":3,"file":"options-parser-logic.d.cts","names":[],"sources":["../../src/components/options-parser-logic.tsx"],"sourcesContent":[],"mappings":";;;;UA8CiB,+BAAA;;;AAAjB;EAYgB,OAAA,EARL,WAQK;EA6BC;AAiBjB;AA6KA;EAAgC,eAAA,EAAA,OAAA;;AAAiC,iBA3NjD,0BAAA,CA2NmD,KAAA,EA1N1D,+BA0N0D,CAAA,EA1N3B,eAAA,CAAA,QA0N2B;AAAA,UA9LlD,yBAAA,CA8LkD;EAuClD;AAsBjB;AAuKA;EAmBgB,OAAA,EAjbL,WAibK;EAmEA;AAchB;AAsBA;EA6HiB,SAAA,EAAA,MAAA;EAsBD;;;;;iBA9pBA,oBAAA,QAA4B,4BAAyB,eAAA,CAAA;;;;iBA6KrD,aAAA;;;UAAoC;IAAa,eAAA,CAAE;UAuClD,6BAAA;;;;;;;;UASP;;;;;;;;;;;iBAaM,wBAAA,QAAgC,gCAA6B,eAAA,CAAA;UAuK5D,iCAAA;;;;;;;;;;;;;;;;iBAmBD,4BAAA,QACP,oCAAiC,eAAA,CAAA;iBAkE1B,2BAAA;WAA8C;IAAW,eAAA,CAAE;UAc1D,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA;UA6HhD,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA"}

package/dist/components/options-parser-logic.d.mts

@@ -1,15 +1,19 @@
-import { CommandOption, CommandTree, CommandTreePath } from "../types/command.mjs";
+import { CommandOption, CommandTree } from "../types/command.mjs";
 import * as _alloy_js_core0 from "@alloy-js/core";
 
 //#region src/components/options-parser-logic.d.ts
-interface DynamicPathSegmentsParserLogicProps {
+interface DynamicSegmentsParserLogicProps {
   /**
-   * The command path to generate the dynamic path segments parser logic for.
+   * The command to generate the dynamic path segments parser logic for. This is used to access the command options and parameters when generating the parser logic for dynamic path segments.
    */
-  path: CommandTreePath;
+  command: CommandTree;
+  /**
+   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command-line arguments to option names and aliases.
+   */
+  isCaseSensitive: boolean;
 }
-declare function DynamicPathSegmentsParserLogic(props: DynamicPathSegmentsParserLogicProps): _alloy_js_core0.Children;
-interface PositionalParametersParserLogicProps {
+declare function DynamicSegmentsParserLogic(props: DynamicSegmentsParserLogicProps): _alloy_js_core0.Children;
+interface ArgumentsParserLogicProps {
   /**
    * The command to generate the positional parameters parser logic for.
    */
@@ -18,8 +22,12 @@ interface PositionalParametersParserLogicProps {
    * The environment variable prefix to use for options that have an associated environment variable. This prefix will be used in the generated code to access the environment variables (e.g., `env.${envPrefix}_OPTION_NAME`).
    */
   envPrefix: string;
+  /**
+   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command-line arguments to option names and aliases.
+   */
+  isCaseSensitive: boolean;
 }
-declare function PositionalParametersParserLogic(props: PositionalParametersParserLogicProps): _alloy_js_core0.Children;
+declare function ArgumentsParserLogic(props: ArgumentsParserLogicProps): _alloy_js_core0.Children;
 /**
  * The command option interface property.
  */
@@ -54,11 +62,11 @@ interface OptionsMemberParserConditionProps {
    */
   name: string;
   /**
-   * Aliases for the option, which will also be parsed in the generated code. This will affect how the generated code compares command-line arguments to option names and aliases.
+   * Aliases for the option, which will also be parsed in the generated code. This will affect how the generated code compares command line arguments to option names and aliases.
    */
   alias?: string[];
   /**
-   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command-line arguments to option names and aliases.
+   * Whether the command options should be parsed in a case-sensitive manner. This will affect how the generated code compares command line arguments to option names and aliases.
    *
    * @defaultValue false
    */
@@ -109,5 +117,5 @@ interface CommandParserLogicProps {
  */
 declare function CommandParserLogic(props: CommandParserLogicProps): _alloy_js_core0.Children;
 //#endregion
-export { CommandParserLogic, CommandParserLogicProps, DynamicPathSegmentsParserLogic, DynamicPathSegmentsParserLogicProps, OptionsInterfaceDeclaration, OptionsMember, OptionsMemberParserCondition, OptionsMemberParserConditionProps, OptionsMemberParserLogic, OptionsMemberParserLogicProps, OptionsParserLogic, OptionsParserLogicProps, PositionalParametersParserLogic, PositionalParametersParserLogicProps };
+export { ArgumentsParserLogic, ArgumentsParserLogicProps, CommandParserLogic, CommandParserLogicProps, DynamicSegmentsParserLogic, DynamicSegmentsParserLogicProps, OptionsInterfaceDeclaration, OptionsMember, OptionsMemberParserCondition, OptionsMemberParserConditionProps, OptionsMemberParserLogic, OptionsMemberParserLogicProps, OptionsParserLogic, OptionsParserLogicProps };
 //# sourceMappingURL=options-parser-logic.d.mts.map

package/dist/components/options-parser-logic.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"options-parser-logic.d.mts","names":[],"sources":["../../src/components/options-parser-logic.tsx"],"sourcesContent":[],"mappings":";;;;UA6CiB,mCAAA;;;AAAjB;EAOgB,IAAA,EAHR,eAGQ;AAoDhB;AAYgB,iBAhEA,8BAAA,CAiEP,KAAA,EAhEA,mCAgEoC,CAAA,EAhED,eAAA,CAAA,QAgEC;AAmG7B,UAhHC,oCAAA,CAgHY;EAAG;;;EAAmC,OAAA,EA5GxD,WA4GwD;EAuClD;AAsBjB;AAuKA;EAmBgB,SAAA,EAAA,MAAA;AAmEhB;AAciB,iBA5aD,+BAAA,CAgbM,KAAA,EA/ab,oCA+aa,CAAA,EA/auB,eAAA,CAAA,QA+avB;AAkBtB;AA8HA;AAsBA;iBAlfgB,aAAA;;;UAAoC;IAAa,eAAA,CAAE;UAuClD,6BAAA;;;;;;;;UASP;;;;;;;;;;;iBAaM,wBAAA,QAAgC,gCAA6B,eAAA,CAAA;UAuK5D,iCAAA;;;;;;;;;;;;;;;;iBAmBD,4BAAA,QACP,oCAAiC,eAAA,CAAA;iBAkE1B,2BAAA;WAA8C;IAAW,eAAA,CAAE;UAc1D,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA;UA8HhD,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA"}
+{"version":3,"file":"options-parser-logic.d.mts","names":[],"sources":["../../src/components/options-parser-logic.tsx"],"sourcesContent":[],"mappings":";;;;UA8CiB,+BAAA;;;AAAjB;EAYgB,OAAA,EARL,WAQK;EA6BC;AAiBjB;AA6KA;EAAgC,eAAA,EAAA,OAAA;;AAAiC,iBA3NjD,0BAAA,CA2NmD,KAAA,EA1N1D,+BA0N0D,CAAA,EA1N3B,eAAA,CAAA,QA0N2B;AAAA,UA9LlD,yBAAA,CA8LkD;EAuClD;AAsBjB;AAuKA;EAmBgB,OAAA,EAjbL,WAibK;EAmEA;AAchB;AAsBA;EA6HiB,SAAA,EAAA,MAAA;EAsBD;;;;;iBA9pBA,oBAAA,QAA4B,4BAAyB,eAAA,CAAA;;;;iBA6KrD,aAAA;;;UAAoC;IAAa,eAAA,CAAE;UAuClD,6BAAA;;;;;;;;UASP;;;;;;;;;;;iBAaM,wBAAA,QAAgC,gCAA6B,eAAA,CAAA;UAuK5D,iCAAA;;;;;;;;;;;;;;;;iBAmBD,4BAAA,QACP,oCAAiC,eAAA,CAAA;iBAkE1B,2BAAA;WAA8C;IAAW,eAAA,CAAE;UAc1D,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA;UA6HhD,uBAAA;;;;WAIN;;;;;;;;;;;;;;;iBAkBK,kBAAA,QAA0B,0BAAuB,eAAA,CAAA"}

package/dist/components/options-parser-logic.mjs

@@ -1,7 +1,9 @@
 import { getDynamicPathSegmentName, isDynamicPathSegment } from "../plugin-utils/context-helpers.mjs";
 import { computedOptions } from "../contexts/options.mjs";
+import { BooleanInputParserLogic } from "./helpers.mjs";
 import { createComponent, createIntrinsic, memo } from "@alloy-js/core/jsx-runtime";
 import { camelCase } from "@stryke/string-format/camel-case";
+import { constantCase } from "@stryke/string-format/constant-case";
 import { isSetString } from "@stryke/type-checks/is-set-string";
 import { For, Show, code, computed } from "@alloy-js/core";
 import { ReflectionKind } from "@powerlines/deepkit/vendor/type";
@@ -9,11 +11,11 @@ import { ElseClause, ElseIfClause, IfStatement, InterfaceDeclaration, InterfaceM
 import { pascalCase } from "@stryke/string-format/pascal-case";
 
 //#region src/components/options-parser-logic.tsx
-function DynamicPathSegmentsParserLogic(props) {
-	const { path } = props;
+function DynamicSegmentsParserLogic(props) {
+	const { command } = props;
 	return createComponent(For, {
 		get each() {
-			return path.segments ?? [];
+			return command.segments ?? [];
 		},
 		children: (segment, index) => createComponent(Show, {
 			get when() {
@@ -26,19 +28,7 @@ function DynamicPathSegmentsParserLogic(props) {
 						get name() {
 							return camelCase(getDynamicPathSegmentName(segment));
 						},
-						get type() {
-							return `${path.dynamics[getDynamicPathSegmentName(segment)]?.variadic ? "string[]" : "string"}${path.dynamics[getDynamicPathSegmentName(segment)]?.optional ? " | undefined" : ""}`;
-						},
-						get initializer() {
-							return memo(() => !!path.dynamics[getDynamicPathSegmentName(segment)]?.variadic)() ? code`[]` : [createComponent(Show, {
-								get when() {
-									return isSetString(path.dynamics[getDynamicPathSegmentName(segment)]?.default);
-								},
-								get children() {
-									return code`"${path.dynamics[getDynamicPathSegmentName(segment)]?.default}"`;
-								}
-							}), code`undefined;`];
-						}
+						type: "string"
 					}),
 					createIntrinsic("hbr", {}),
 					createComponent(IfStatement, {
@@ -54,60 +44,110 @@ function DynamicPathSegmentsParserLogic(props) {
 		})
 	});
 }
-function PositionalParametersParserLogic(props) {
-	const { command, envPrefix } = props;
-	return [createComponent(For, {
-		get each() {
-			return command.params ?? [];
+function ArgumentsParserLogic(props) {
+	const { command, envPrefix, isCaseSensitive } = props;
+	return createComponent(Show, {
+		get when() {
+			return command.arguments && command.arguments.length > 0;
 		},
-		hardline: true,
-		children: (param) => [
-			createComponent(VarDeclaration, {
-				"let": true,
-				get name() {
-					return param.name;
-				},
-				get type() {
-					return `${param.kind === ReflectionKind.boolean ? "boolean" : param.kind === ReflectionKind.number ? "number" : "string"}${(param.kind === ReflectionKind.string || param.kind === ReflectionKind.number) && param.variadic ? "[]" : ""}${param.optional ? " | undefined" : ""}`;
-				},
-				get initializer() {
-					return [memo(() => code`env.${envPrefix}_${param.env} ?? `), createComponent(Show, {
-						get when() {
-							return param.default !== void 0;
-						},
-						get fallback() {
-							return (param.kind === ReflectionKind.string || param.kind === ReflectionKind.number) && param.variadic ? code`[]` : code`undefined;`;
-						},
-						get children() {
-							return param.kind === ReflectionKind.string ? code`"${param.default}"` : code`${param.default}`;
-						}
-					})];
-				}
-			}),
-			createIntrinsic("hbr", {}),
-			createIntrinsic("hbr", {}),
-			createComponent(IfStatement, {
-				get condition() {
-					return code`args.length > ${command.path.segments.filter((segment) => isDynamicPathSegment(segment)).length + 1} && args[${command.path.segments.filter((segment) => isDynamicPathSegment(segment)).length + 1}]`;
-				},
-				get children() {
-					return createComponent(Show, {
-						get when() {
-							return param.kind === ReflectionKind.string || param.kind === ReflectionKind.number;
-						},
-						get fallback() {
-							return code`${param.name} = args[${command.path.segments.filter((segment) => isDynamicPathSegment(segment)).length + 1}];`;
-						},
-						get children() {
-							return code`${param.name} = ${(param.kind === ReflectionKind.string || param.kind === ReflectionKind.number) && param.variadic ? `args.slice(${command.path.segments.filter((segment) => isDynamicPathSegment(segment)).length + 1})` : `args[${command.path.segments.filter((segment) => isDynamicPathSegment(segment)).length + 1}]`}${param.kind === ReflectionKind.number ? ".map(Number).filter(value => !Number.isNaN(value))" : ""};`;
-						}
-					});
-				}
-			}),
-			createIntrinsic("hbr", {}),
-			createIntrinsic("hbr", {})
-		]
-	})];
+		get children() {
+			return [
+				createComponent(VarDeclaration, {
+					"let": true,
+					name: "optionsIndex",
+					type: "number",
+					get initializer() {
+						return code`Math.max(0, args.slice(${command.segments.length + 1}).findIndex(arg => arg.startsWith("-") && /^(${Object.values(command.options ?? {}).map((option) => `${isCaseSensitive || option.name.length === 1 ? option.name : option.name.toLowerCase().replaceAll("-", "").replaceAll("_", "")}${option.alias && option.alias.length > 0 ? "|" : ""}${option.alias?.map((a) => (isCaseSensitive || option.name.length === 1 ? a : a.toLowerCase().replaceAll("-", "").replaceAll("_", "")) === "?" ? "\\?" : isCaseSensitive || option.name.length === 1 ? a : a.toLowerCase().replaceAll("-", "").replaceAll("_", "")).join("|")}`).join("|")})=?.*$/.test(arg${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"}))) + ${command.segments.length + 1};`;
+					}
+				}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(VarDeclaration, {
+					"let": true,
+					name: "argsIndex",
+					type: "number",
+					get initializer() {
+						return code`optionsIndex > ${command.segments.length + 1} ? ${command.segments.length + 1} : (Math.max(0, args.slice(optionsIndex).findLastIndex(arg => arg.startsWith("-") && /^(${Object.values(command.options ?? {}).map((option) => `${isCaseSensitive || option.name.length === 1 ? option.name : option.name.toLowerCase().replaceAll("-", "").replaceAll("_", "")}${option.alias && option.alias.length > 0 ? "|" : ""}${option.alias?.map((a) => (isCaseSensitive || option.name.length === 1 ? a : a.toLowerCase().replaceAll("-", "").replaceAll("_", "")) === "?" ? "\\?" : isCaseSensitive || option.name.length === 1 ? a : a.toLowerCase().replaceAll("-", "").replaceAll("_", "")).join("|")}`).join("|")})=?.*$/.test(arg${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"}))) + ${command.segments.length + 1});`;
+					}
+				}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(For, {
+					get each() {
+						return command.arguments ?? [];
+					},
+					hardline: true,
+					children: (arg, index) => [
+						createComponent(VarDeclaration, {
+							"let": true,
+							get name() {
+								return camelCase(arg.name);
+							},
+							get type() {
+								return `${arg.kind === ReflectionKind.boolean ? "boolean" : arg.kind === ReflectionKind.number ? "number" : "string"}${(arg.kind === ReflectionKind.string || arg.kind === ReflectionKind.number) && arg.variadic ? "[]" : ""}${arg.optional ? " | undefined" : ""}`;
+							},
+							get initializer() {
+								return [createComponent(Show, {
+									get when() {
+										return isSetString(arg.env);
+									},
+									get children() {
+										return code`env.${envPrefix}_${constantCase(String(arg.env))} ?? `;
+									}
+								}), createComponent(Show, {
+									get when() {
+										return arg.default !== void 0;
+									},
+									get fallback() {
+										return (arg.kind === ReflectionKind.string || arg.kind === ReflectionKind.number) && arg.variadic ? code`[]` : code`undefined;`;
+									},
+									get children() {
+										return arg.kind === ReflectionKind.string ? code`"${arg.default}"` : code`${arg.default}`;
+									}
+								})];
+							}
+						}),
+						createIntrinsic("hbr", {}),
+						createIntrinsic("hbr", {}),
+						createComponent(IfStatement, {
+							condition: code`argsIndex + ${index} < args.length && argsIndex + ${index} !== optionsIndex`,
+							get children() {
+								return [memo(() => code`${camelCase(arg.name)} = `), createComponent(Show, {
+									get when() {
+										return arg.kind === ReflectionKind.string || arg.kind === ReflectionKind.number;
+									},
+									get fallback() {
+										return createComponent(BooleanInputParserLogic, { name: `args[argsIndex + ${index}] ` });
+									},
+									get children() {
+										return createComponent(Show, {
+											get when() {
+												return (arg.kind === ReflectionKind.string || arg.kind === ReflectionKind.number) && arg.variadic;
+											},
+											get fallback() {
+												return createComponent(Show, {
+													get when() {
+														return arg.kind === ReflectionKind.number;
+													},
+													fallback: code`args[argsIndex + ${index}]; `,
+													children: code`Number(args[argsIndex + ${index}]); `
+												});
+											},
+											get children() {
+												return code`args.slice(argsIndex + ${index}, (optionsIndex > argsIndex ? optionsIndex : args.length) - ${command.arguments.length - index}).join(" ").split(",").map(item => item.trim().replace(/^("|')/, "").replace(/("|')$/, "")).filter(Boolean)`;
+											}
+										});
+									}
+								})];
+							}
+						}),
+						createIntrinsic("hbr", {}),
+						createIntrinsic("hbr", {})
+					]
+				})
+			];
+		}
+	});
 }
 /**
 * The command option interface property.
@@ -381,10 +421,10 @@ function OptionsMemberParserLogic(props) {
 								get when() {
 									return name.includes("?") || name.includes("-");
 								},
-								fallback: code`options.${name}`,
-								children: code`options["${name}"]`
+								fallback: code`options.${name} = `,
+								children: code`options["${name}"] = `
 							}),
-							code` = value !== "false" && value !== "f" && value !== "no" && value !== "n" && value !== "0" && value !== "off" && value !== "disable" && value !== "disabled"; `
+							createComponent(BooleanInputParserLogic, { name: "value" })
 						];
 					}
 				}),
@@ -475,7 +515,7 @@ function OptionsParserLogic(props) {
 		}),
 		createIntrinsic("hbr", {}),
 		createIntrinsic("hbr", {}),
-		memo(() => code`for (let i = 0; i < args.slice(${command.path.segments.filter((segment) => isDynamicPathSegment(segment)).length}).length; i++) { `),
+		memo(() => code`for (let i = 0; i < args.slice(${command.segments.filter((segment) => isDynamicPathSegment(segment)).length}).length; i++) { `),
 		createIntrinsic("hbr", {}),
 		createComponent(VarDeclaration, {
 			"const": true,
@@ -548,27 +588,10 @@ function OptionsParserLogic(props) {
 function CommandParserLogic(props) {
 	const { command, envPrefix, isCaseSensitive = false } = props;
 	return [
-		createComponent(DynamicPathSegmentsParserLogic, { get path() {
-			return command.path;
-		} }),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
-		createComponent(VarDeclaration, {
-			"const": true,
-			name: "lastSegmentIndex",
-			type: "number",
-			get initializer() {
-				return memo(() => !!isDynamicPathSegment(command.path.segments[command.path.segments.length - 1]))() ? `args.some(arg => /^--?(${Object.keys(command.options).map((key) => key.toLowerCase().replaceAll("-", "").replaceAll("_", "")).join("|")})(=.*)?$/.test(arg${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"})) ? args.findIndex(arg => /^--?(${Object.keys(command.options).map((key) => key.toLowerCase().replaceAll("-", "").replaceAll("_", "")).join("|")})(=.*)?$/.test(arg${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"})) : args.length - ${command.params.length + 1}` : `args.reduce((ret, arg, index) => {
-        if (ret === -1 && (index < args.findIndex(a => /^--?(${Object.keys(command.options).map((key) => key.toLowerCase().replaceAll("-", "").replaceAll("_", "")).join("|")})(=.*)?$/.test(a${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"})) || !args.some(a => /^--?(${Object.keys(command.options).map((key) => key.toLowerCase().replaceAll("-", "").replaceAll("_", "")).join("|")})(=.*)?$/.test(a${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"}))) && arg${isCaseSensitive ? "" : ".toLowerCase().replaceAll(\"-\", \"\").replaceAll(\"_\", \"\")"} === "${command.path.segments[command.path.segments.length - 1]?.toLowerCase()}") {
-            return index;
-        }
-
-        return ret;
-      }, -1); `;
-			}
+		createComponent(DynamicSegmentsParserLogic, {
+			command,
+			isCaseSensitive
 		}),
-		code`
-      `,
 		createIntrinsic("hbr", {}),
 		createIntrinsic("hbr", {}),
 		createComponent(OptionsParserLogic, {
@@ -578,9 +601,10 @@ function CommandParserLogic(props) {
 		}),
 		createIntrinsic("hbr", {}),
 		createIntrinsic("hbr", {}),
-		createComponent(PositionalParametersParserLogic, {
+		createComponent(ArgumentsParserLogic, {
 			command,
-			envPrefix
+			envPrefix,
+			isCaseSensitive
 		}),
 		createIntrinsic("hbr", {}),
 		createIntrinsic("hbr", {})
@@ -588,5 +612,5 @@ function CommandParserLogic(props) {
 }
 
 //#endregion
-export { CommandParserLogic, DynamicPathSegmentsParserLogic, OptionsInterfaceDeclaration, OptionsMember, OptionsMemberParserCondition, OptionsMemberParserLogic, OptionsParserLogic, PositionalParametersParserLogic };
+export { ArgumentsParserLogic, CommandParserLogic, DynamicSegmentsParserLogic, OptionsInterfaceDeclaration, OptionsMember, OptionsMemberParserCondition, OptionsMemberParserLogic, OptionsParserLogic };
 //# sourceMappingURL=options-parser-logic.mjs.map