@duplojs/server 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/_virtual/_rolldown/runtime.mjs

@@ -9,5 +9,9 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
 //#endregion
-export { __exportAll };
+export { __exportAll, __require };

package/dist/command/argument.d.ts

@@ -1,5 +1,5 @@
 import { Error, SymbolCommandError } from './error';
-import { EligibleType } from './types';
+import { EligibleType, ForbiddenInvalidIdentifier } from './types';
 import type * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 import type * as DDataStructure from "@duplojs/lang/dataStructure";
@@ -15,4 +15,4 @@ export interface CreateArgumentParams {
     readonly description?: string;
     readonly optional?: boolean;
 }
-export declare function createArgument<GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateArgumentParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams): Argument<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["optional"], true> extends true ? undefined : never))>;
+export declare function createArgument<GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateArgumentParams = {}>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, dataStructure: GenericStructure, params?: GenericParams): Argument<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["optional"], true> extends true ? undefined : never))>;

package/dist/command/create.cjs

@@ -1,6 +1,7 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("./kind.cjs");
 const require_error = require("./error.cjs");
+const require_base = require("./options/base.cjs");
 const require_help = require("./help.cjs");
 let _duplojs_lang_common = require("@duplojs/lang/common");
 _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
@@ -51,19 +52,23 @@ function create(...args) {
 			}
 			const commandOptions = await _duplojs_lang_generator.asyncReduce(self.options, _duplojs_lang_generator.reduceFrom({
 				options: {},
-				restArgs: args
-			}), async ({ item: option, lastValue, next, exit }) => {
+				restArgs: args,
+				hasError: false
+			}), async ({ item: option, lastValue, next }) => {
 				const optionResult = await option.execute(lastValue.restArgs, error);
-				if (optionResult === require_error.SymbolCommandError) return exit(require_error.SymbolCommandError);
+				if (optionResult === require_error.SymbolCommandError) return next(_duplojs_lang_object.override(lastValue, { hasError: true }));
 				return next({
 					options: _duplojs_lang_object.override(lastValue.options, { [option.name]: optionResult.result }),
-					restArgs: optionResult.argumentRest
+					restArgs: optionResult.argumentRest,
+					hasError: lastValue.hasError
 				});
 			});
-			if (commandOptions === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+			if (commandOptions.hasError === true) return require_error.SymbolCommandError;
+			const unknownOptions = _duplojs_lang_array.filter(commandOptions.restArgs, require_base.isOptionToken);
+			if (unknownOptions.length > 0) return error.addUnknownOptionIssue(unknownOptions);
 			if (self.subject?.type === "argument") {
-				if (self.subject.args.length !== commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
-				const commandArguments = await _duplojs_lang_generator.asyncReduce(self.subject.args, _duplojs_lang_generator.reduceFrom({
+				if (self.subject.args.length < commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
+				const commandArgs = await _duplojs_lang_generator.asyncReduce(self.subject.args, _duplojs_lang_generator.reduceFrom({
 					args: {},
 					restArgs: commandOptions.restArgs
 				}), async ({ item: argument, lastValue, next, exit }) => {
@@ -75,13 +80,16 @@ function create(...args) {
 						restArgs: _duplojs_lang_array.shift(lastValue.restArgs)
 					});
 				});
-				if (commandArguments === require_error.SymbolCommandError) return require_error.SymbolCommandError;
+				if (commandArgs === require_error.SymbolCommandError) return require_error.SymbolCommandError;
 				await execute({
 					options: commandOptions.options,
-					args: commandArguments.args
+					args: commandArgs.args
 				});
 			} else {
-				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				if (commandOptions.restArgs.length > 0) {
+					if (self.subject?.type === "subCommand") return error.addUnknownSubCommandIssue(commandOptions.restArgs[0]);
+					return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				}
 				await execute({ options: commandOptions.options });
 			}
 		},

package/dist/command/create.d.ts

@@ -1,7 +1,7 @@
 import { Option } from './options';
 import { SymbolCommandError, Error } from './error';
 import { Argument } from './argument';
-import { ForbiddenDuplicateName } from './types';
+import { ForbiddenDuplicateName, ForbiddenInvalidIdentifier } from './types';
 import * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 declare const commandKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command", unknown>>;
@@ -42,6 +42,6 @@ export type CreateCommandExecuteParams<GenericOptions extends DCommon.AnyTuple<O
         readonly [GenericArgument in GenericArguments[number] as GenericArgument["name"]]: Exclude<Awaited<ReturnType<GenericArgument["execute"]>>, SymbolCommandError>;
     };
 }));
-export declare function create<GenericName extends string>(name: GenericName, execute: () => void): Command<GenericName>;
-export declare function create<GenericName extends string, const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(name: GenericName, params: CreateCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Command<GenericName>;
+export declare function create<GenericName extends string>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, execute: () => void): Command<GenericName>;
+export declare function create<GenericName extends string, const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, params: CreateCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Command<GenericName>;
 export {};

package/dist/command/create.mjs

@@ -1,5 +1,6 @@
 import { createKind } from "./kind.mjs";
 import { SymbolCommandError } from "./error.mjs";
+import { isOptionToken } from "./options/base.mjs";
 import { helpOption, logCommandHelp } from "./help.mjs";
 import * as DCommon from "@duplojs/lang/common";
 import * as DObject from "@duplojs/lang/object";
@@ -46,19 +47,23 @@ function create(...args) {
 			}
 			const commandOptions = await DGenerator.asyncReduce(self.options, DGenerator.reduceFrom({
 				options: {},
-				restArgs: args
-			}), async ({ item: option, lastValue, next, exit }) => {
+				restArgs: args,
+				hasError: false
+			}), async ({ item: option, lastValue, next }) => {
 				const optionResult = await option.execute(lastValue.restArgs, error);
-				if (optionResult === SymbolCommandError) return exit(SymbolCommandError);
+				if (optionResult === SymbolCommandError) return next(DObject.override(lastValue, { hasError: true }));
 				return next({
 					options: DObject.override(lastValue.options, { [option.name]: optionResult.result }),
-					restArgs: optionResult.argumentRest
+					restArgs: optionResult.argumentRest,
+					hasError: lastValue.hasError
 				});
 			});
-			if (commandOptions === SymbolCommandError) return SymbolCommandError;
+			if (commandOptions.hasError === true) return SymbolCommandError;
+			const unknownOptions = DArray.filter(commandOptions.restArgs, isOptionToken);
+			if (unknownOptions.length > 0) return error.addUnknownOptionIssue(unknownOptions);
 			if (self.subject?.type === "argument") {
-				if (self.subject.args.length !== commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
-				const commandArguments = await DGenerator.asyncReduce(self.subject.args, DGenerator.reduceFrom({
+				if (self.subject.args.length < commandOptions.restArgs.length) return error.addTooMuchCommandArgumentIssue(self.subject.args.length, commandOptions.restArgs.length);
+				const commandArgs = await DGenerator.asyncReduce(self.subject.args, DGenerator.reduceFrom({
 					args: {},
 					restArgs: commandOptions.restArgs
 				}), async ({ item: argument, lastValue, next, exit }) => {
@@ -70,13 +75,16 @@ function create(...args) {
 						restArgs: DArray.shift(lastValue.restArgs)
 					});
 				});
-				if (commandArguments === SymbolCommandError) return SymbolCommandError;
+				if (commandArgs === SymbolCommandError) return SymbolCommandError;
 				await execute({
 					options: commandOptions.options,
-					args: commandArguments.args
+					args: commandArgs.args
 				});
 			} else {
-				if (commandOptions.restArgs.length > 0) return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				if (commandOptions.restArgs.length > 0) {
+					if (self.subject?.type === "subCommand") return error.addUnknownSubCommandIssue(commandOptions.restArgs[0]);
+					return error.addTooMuchCommandArgumentIssue(0, commandOptions.restArgs.length);
+				}
 				await execute({ options: commandOptions.options });
 			}
 		},

package/dist/command/error.cjs

@@ -2,12 +2,12 @@ const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_defaultInterpreter = require("../dataStructure/common/error/defaultInterpreter.cjs");
 let _duplojs_lang_common = require("@duplojs/lang/common");
 _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
 _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
 let _duplojs_lang_array = require("@duplojs/lang/array");
 _duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
-let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
-_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_string = require("@duplojs/lang/string");
 _duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
 let _duplojs_lang_printer = require("@duplojs/lang/printer");
@@ -23,6 +23,20 @@ function createError(commandName) {
 		issues,
 		currentPath,
 		pushPath: (path) => void currentPath.push(path),
+		addUnknownOptionIssue: (optionTokens) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnknownOptionIssue", {
+				optionTokens,
+				path: _duplojs_lang_string.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnknownSubCommandIssue: (subCommandName) => {
+			issues.push(_duplojs_lang_modeling.taggedObject("UnknownSubCommandIssue", {
+				subCommandName,
+				path: _duplojs_lang_string.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
 		addRequiredOptionIssue: (optionName) => {
 			issues.push(_duplojs_lang_modeling.taggedObject("RequiredOptionIssue", {
 				optionName,
@@ -94,6 +108,16 @@ function interpretDataStructureError(error, dataStructureErrorInterpreter) {
 }
 function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
 	return _duplojs_lang_printer.renderParagraph([_duplojs_lang_array.map(issues, _duplojs_lang_pattern.matchWithTaggedObject({
+		UnknownOptionIssue: ({ optionTokens }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("OPTION: ", "blue"),
+			_duplojs_lang_string.join(optionTokens, ", ")
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Unknown Option`],
+		UnknownSubCommandIssue: ({ subCommandName }) => [_duplojs_lang_printer.render([
+			_duplojs_lang_printer.indent(1),
+			_duplojs_lang_printer.colorizedBold("SUB-COMMAND: ", "cyan"),
+			subCommandName
+		], ""), `${_duplojs_lang_printer.indent(1)}↳ Unknown Sub-command`],
 		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [_duplojs_lang_printer.render([
 			_duplojs_lang_printer.indent(1),
 			_duplojs_lang_printer.colorizedBold("ARGUMENT: ", "magenta"),

package/dist/command/error.d.ts

@@ -27,17 +27,25 @@ export interface DataStructureArgumentIssue extends ArgumentIssueBase, DModeling
 export interface CommandArgumentIssueBase {
     readonly path: string;
 }
+export interface UnknownOptionIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"UnknownOptionIssue"> {
+    readonly optionTokens: readonly string[];
+}
+export interface UnknownSubCommandIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"UnknownSubCommandIssue"> {
+    readonly subCommandName: string;
+}
 export interface TooMuchCommandArgumentIssue extends CommandArgumentIssueBase, DModeling.ObjectTag<"TooMuchCommandArgumentIssue"> {
     readonly expect: number;
     readonly receive: number;
 }
-export type Issues = (RequiredOptionIssue | RequiredOptionValueIssue | UnexpectedOptionValueIssue | DataStructureOptionIssue | RequiredArgumentIssue | DataStructureArgumentIssue | TooMuchCommandArgumentIssue);
+export type Issues = (RequiredOptionIssue | RequiredOptionValueIssue | UnexpectedOptionValueIssue | DataStructureOptionIssue | RequiredArgumentIssue | DataStructureArgumentIssue | TooMuchCommandArgumentIssue | UnknownOptionIssue | UnknownSubCommandIssue);
 export declare const SymbolCommandError: unique symbol;
 export type SymbolCommandError = typeof SymbolCommandError;
 export interface Error {
     readonly issues: readonly Issues[];
     readonly currentPath: readonly string[];
     pushPath(path: string): void;
+    addUnknownOptionIssue(optionTokens: readonly string[]): SymbolCommandError;
+    addUnknownSubCommandIssue(subCommandName: string): SymbolCommandError;
     addRequiredOptionIssue(optionName: string): SymbolCommandError;
     addRequiredOptionValueIssue(optionName: string): SymbolCommandError;
     addUnexpectedOptionValueIssue(optionName: string, data: unknown): SymbolCommandError;

package/dist/command/error.mjs

@@ -1,8 +1,8 @@
 import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "../dataStructure/common/error/defaultInterpreter.mjs";
 import * as DCommon from "@duplojs/lang/common";
+import * as DPattern from "@duplojs/lang/pattern";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as DArray from "@duplojs/lang/array";
-import * as DPattern from "@duplojs/lang/pattern";
 import * as DString from "@duplojs/lang/string";
 import * as DPrinter from "@duplojs/lang/printer";
 import * as DModeling from "@duplojs/lang/modeling";
@@ -15,6 +15,20 @@ function createError(commandName) {
 		issues,
 		currentPath,
 		pushPath: (path) => void currentPath.push(path),
+		addUnknownOptionIssue: (optionTokens) => {
+			issues.push(DModeling.taggedObject("UnknownOptionIssue", {
+				optionTokens,
+				path: DString.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
+		addUnknownSubCommandIssue: (subCommandName) => {
+			issues.push(DModeling.taggedObject("UnknownSubCommandIssue", {
+				subCommandName,
+				path: DString.join(currentPath, ".")
+			}));
+			return SymbolCommandError;
+		},
 		addRequiredOptionIssue: (optionName) => {
 			issues.push(DModeling.taggedObject("RequiredOptionIssue", {
 				optionName,
@@ -86,6 +100,16 @@ function interpretDataStructureError(error, dataStructureErrorInterpreter) {
 }
 function interpretErrorIssues(issues, dataStructureErrorInterpreter) {
 	return DPrinter.renderParagraph([DArray.map(issues, DPattern.matchWithTaggedObject({
+		UnknownOptionIssue: ({ optionTokens }) => [DPrinter.render([
+			DPrinter.indent(1),
+			DPrinter.colorizedBold("OPTION: ", "blue"),
+			DString.join(optionTokens, ", ")
+		], ""), `${DPrinter.indent(1)}↳ Unknown Option`],
+		UnknownSubCommandIssue: ({ subCommandName }) => [DPrinter.render([
+			DPrinter.indent(1),
+			DPrinter.colorizedBold("SUB-COMMAND: ", "cyan"),
+			subCommandName
+		], ""), `${DPrinter.indent(1)}↳ Unknown Sub-command`],
 		DataStructureArgumentIssue: ({ argumentName, dataStructureError }) => [DPrinter.render([
 			DPrinter.indent(1),
 			DPrinter.colorizedBold("ARGUMENT: ", "magenta"),

package/dist/command/exec.d.ts

@@ -2,12 +2,13 @@ import { CreateCommandExecuteParams, CreateCommandParams, Subjects } from './cre
 import { Error } from './error';
 import { Option } from './options';
 import { Argument } from './argument';
+import { ForbiddenInvalidIdentifier } from './types';
 import type * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DDataStructure from "@duplojs/lang/dataStructure";
-export interface ExecCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubjects extends Subjects = Subjects> extends CreateCommandParams<GenericOptions, GenericSubjects> {
-    displayName?: string;
+export interface ExecCommandParams<GenericOptions extends DCommon.AnyTuple<Option> = DCommon.AnyTuple<Option>, GenericSubjects extends Subjects = Subjects, GenericDisplayName extends string = string> extends CreateCommandParams<GenericOptions, GenericSubjects> {
+    displayName?: GenericDisplayName & ForbiddenInvalidIdentifier<GenericDisplayName>;
     dataStructureErrorInterpreter?: DDataStructure.ErrorInterpreter;
 }
 export declare function exec(execute: () => void): Promise<DEither.Ok | DEither.Error<Error>>;
-export declare function exec<const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never>(params: ExecCommandParams<GenericOptions, GenericSubjects>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Promise<DEither.Ok | DEither.Error<Error>>;
+export declare function exec<const GenericOptions extends DCommon.AnyTuple<Option> = never, GenericSubjects extends Subjects = never, const GenericDisplayName extends string = string>(params: ExecCommandParams<GenericOptions, GenericSubjects, GenericDisplayName>, execute: (params: CreateCommandExecuteParams<GenericOptions, Extract<GenericSubjects, DCommon.AnyTuple<Argument>>>) => DCommon.MaybePromise<void>): Promise<DEither.Ok | DEither.Error<Error>>;

package/dist/command/help.cjs

@@ -1,19 +1,21 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
-const require_exist = require("../dataStructure/constraint/exist.cjs");
+const require_fileExist = require("../dataStructure/constraint/fileExist.cjs");
+const require_folderExist = require("../dataStructure/constraint/folderExist.cjs");
 const require_mimeType = require("../dataStructure/constraint/mimeType.cjs");
 const require_size = require("../dataStructure/constraint/size.cjs");
 const require_file = require("../dataStructure/type/file.cjs");
+const require_folder = require("../dataStructure/type/folder.cjs");
 const require_array = require("./options/defaults/array.cjs");
 const require_boolean = require("./options/defaults/boolean.cjs");
 const require_simple = require("./options/defaults/simple.cjs");
 let _duplojs_lang_common = require("@duplojs/lang/common");
 _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
 _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
 let _duplojs_lang_array = require("@duplojs/lang/array");
 _duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
-let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
-_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_string = require("@duplojs/lang/string");
 _duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
 let _duplojs_lang_printer = require("@duplojs/lang/printer");
@@ -53,7 +55,7 @@ function formatBytes(value) {
 	return `${Number.isInteger(size) ? size : size.toFixed(1)} ${units[index]}`;
 }
 function renderType(type) {
-	return _duplojs_lang_pattern.match(type).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.stringLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.numberLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.bigintLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.booleanLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.nullTypeKind), _duplojs_lang_common.justReturn([literal("null")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.undefinedTypeKind), _duplojs_lang_common.justReturn([literal("undefined")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.stringTypeKind), _duplojs_lang_common.justReturn([typeLabel("string")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.numberTypeKind), _duplojs_lang_common.justReturn([typeLabel("number")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.bigintTypeKind), _duplojs_lang_common.justReturn([typeLabel("bigint")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.booleanTypeKind), _duplojs_lang_common.justReturn([typeLabel("boolean")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.dateTypeKind), _duplojs_lang_common.justReturn([typeLabel("date")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.timeTypeKind), _duplojs_lang_common.justReturn([typeLabel("time")])).when(_duplojs_lang_dataStructure.typeIdentifier(require_file.fileTypeKind), _duplojs_lang_common.justReturn([typeLabel("file")])).otherwise(_duplojs_lang_common.justReturn([typeLabel("unknown")]));
+	return _duplojs_lang_pattern.match(type).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.stringLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.numberLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.bigintLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.booleanLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.nullTypeKind), _duplojs_lang_common.justReturn([literal("null")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.undefinedTypeKind), _duplojs_lang_common.justReturn([literal("undefined")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.stringTypeKind), _duplojs_lang_common.justReturn([typeLabel("string")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.numberTypeKind), _duplojs_lang_common.justReturn([typeLabel("number")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.bigintTypeKind), _duplojs_lang_common.justReturn([typeLabel("bigint")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.booleanTypeKind), _duplojs_lang_common.justReturn([typeLabel("boolean")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.dateTypeKind), _duplojs_lang_common.justReturn([typeLabel("date")])).when(_duplojs_lang_dataStructure.typeIdentifier(_duplojs_lang_dataStructure.timeTypeKind), _duplojs_lang_common.justReturn([typeLabel("time")])).when(_duplojs_lang_dataStructure.typeIdentifier(require_file.fileTypeKind), _duplojs_lang_common.justReturn([typeLabel("file")])).when(_duplojs_lang_dataStructure.typeIdentifier(require_folder.folderTypeKind), _duplojs_lang_common.justReturn([typeLabel("folder")])).otherwise(_duplojs_lang_common.justReturn([typeLabel("unknown")]));
 }
 function renderStringLength(constraints) {
 	const equal = _duplojs_lang_array.find(constraints, _duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.stringLengthEqualConstraintKind));
@@ -83,7 +85,7 @@ function renderNumberBounds(constraints) {
 	return _duplojs_lang_array.filter([greaterThan ? [constraintLabel("> "), literal(String(greaterThan.definition.threshold))] : greaterThanOrEqual ? [constraintLabel("min "), literal(String(greaterThanOrEqual.definition.threshold))] : null, lessThan ? [constraintLabel("< "), literal(String(lessThan.definition.threshold))] : lessThanOrEqual ? [constraintLabel("max "), literal(String(lessThanOrEqual.definition.threshold))] : null], _duplojs_lang_common.truthy);
 }
 function renderSimpleConstraint(constraint) {
-	return _duplojs_lang_pattern.match(constraint).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.emailConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("email")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.urlConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("url")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.uuidConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("uuid")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.integerConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("integer")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.trimmedConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("trimmed")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.notEmptyConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("not empty")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.numberInStringConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("number in string")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.evenConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("even")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.oddConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("odd")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.positiveConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("positive")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.negativeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("negative")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.notZeroConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("not zero")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.safeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("safe number")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.pathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("path")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.absolutePathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("absolute path")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.segmentPathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("path segment")])).when(_duplojs_lang_dataStructure.constraintIdentifier(require_exist.existConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("exists")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.strictPositiveConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("> "), literal("0")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.strictNegativeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("< "), literal("0")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.betweenThanConstraintKind), ({ definition }) => [
+	return _duplojs_lang_pattern.match(constraint).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.emailConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("email")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.urlConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("url")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.uuidConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("uuid")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.integerConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("integer")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.trimmedConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("trimmed")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.notEmptyConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("not empty")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.numberInStringConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("number in string")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.evenConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("even")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.oddConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("odd")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.positiveConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("positive")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.negativeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("negative")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.notZeroConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("not zero")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.safeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("safe number")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.pathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("path")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.absolutePathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("absolute path")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.segmentPathConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("path segment")])).when(_duplojs_lang_dataStructure.constraintIdentifier(require_fileExist.fileExistConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("exists")])).when(_duplojs_lang_dataStructure.constraintIdentifier(require_folderExist.folderExistConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("exists")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.strictPositiveConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("> "), literal("0")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.strictNegativeConstraintKind), _duplojs_lang_common.justReturn([constraintLabel("< "), literal("0")])).when(_duplojs_lang_dataStructure.constraintIdentifier(_duplojs_lang_dataStructure.betweenThanConstraintKind), ({ definition }) => [
 		constraintLabel("> "),
 		literal(String(definition.greater)),
 		secondary(" and "),
@@ -192,8 +194,8 @@ function renderOptionDetails(option, depth) {
 		const help = renderDataStructure(option.dataStructure);
 		return _duplojs_lang_array.filter([
 			renderInline([_duplojs_lang_printer.indent(depth), renderMetadata(help, option.required ? "required" : "optional")]),
-			renderDescriptionLine(option.description, depth),
-			...renderConstraintLines(help.constraints, depth)
+			...renderConstraintLines(help.constraints, depth),
+			renderDescriptionLine(option.description, depth)
 		], _duplojs_lang_common.truthy);
 	}
 	if (require_boolean.booleanOptionKind.has(option)) return _duplojs_lang_array.filter([renderInline([_duplojs_lang_printer.indent(depth), typeLabel("boolean")]), renderDescriptionLine(option.description, depth)], _duplojs_lang_common.truthy);
@@ -211,8 +213,8 @@ function renderArgumentsHelp(args, depth) {
 				name(argument.name.padEnd(12)),
 				renderMetadata(help, argument.optional ? "optional" : "required")
 			]),
-			renderDescriptionLine(argument.description, depth + 2),
-			renderConstraintLines(help.constraints, depth + 2)
+			renderConstraintLines(help.constraints, depth + 2),
+			renderDescriptionLine(argument.description, depth + 2)
 		]);
 	})]);
 }

package/dist/command/help.d.ts

@@ -1,7 +1,7 @@
 import { Command } from './create';
 import { Argument } from './argument';
 import { Options } from './options';
-export declare const helpOption: NoInfer<import('./options').BooleanOption<"help">>;
+export declare const helpOption: import('./options').BooleanOption<"help">;
 export declare function renderOptionsHelp(options: readonly Options[], depth: number): string;
 export declare function renderArgumentsHelp(args: readonly Argument[], depth: number): string;
 export declare function renderCommandHelp(command: Command, depth: number): string[];

package/dist/command/help.mjs

@@ -1,14 +1,16 @@
-import { existConstraintKind } from "../dataStructure/constraint/exist.mjs";
+import { fileExistConstraintKind } from "../dataStructure/constraint/fileExist.mjs";
+import { folderExistConstraintKind } from "../dataStructure/constraint/folderExist.mjs";
 import { mimeTypeConstraintKind } from "../dataStructure/constraint/mimeType.mjs";
 import { sizeConstraintKind } from "../dataStructure/constraint/size.mjs";
 import { fileTypeKind } from "../dataStructure/type/file.mjs";
+import { folderTypeKind } from "../dataStructure/type/folder.mjs";
 import { arrayOptionKind } from "./options/defaults/array.mjs";
 import { booleanOptionKind, createBooleanOption } from "./options/defaults/boolean.mjs";
 import { simpleOptionKind } from "./options/defaults/simple.mjs";
 import * as DCommon from "@duplojs/lang/common";
+import * as DPattern from "@duplojs/lang/pattern";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as DArray from "@duplojs/lang/array";
-import * as DPattern from "@duplojs/lang/pattern";
 import * as DString from "@duplojs/lang/string";
 import * as DPrinter from "@duplojs/lang/printer";
 //#region scripts/command/help.ts
@@ -46,7 +48,7 @@ function formatBytes(value) {
 	return `${Number.isInteger(size) ? size : size.toFixed(1)} ${units[index]}`;
 }
 function renderType(type) {
-	return DPattern.match(type).when(DDataStructure.typeIdentifier(DDataStructure.stringLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.numberLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.bigintLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.booleanLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.nullTypeKind), DCommon.justReturn([literal("null")])).when(DDataStructure.typeIdentifier(DDataStructure.undefinedTypeKind), DCommon.justReturn([literal("undefined")])).when(DDataStructure.typeIdentifier(DDataStructure.stringTypeKind), DCommon.justReturn([typeLabel("string")])).when(DDataStructure.typeIdentifier(DDataStructure.numberTypeKind), DCommon.justReturn([typeLabel("number")])).when(DDataStructure.typeIdentifier(DDataStructure.bigintTypeKind), DCommon.justReturn([typeLabel("bigint")])).when(DDataStructure.typeIdentifier(DDataStructure.booleanTypeKind), DCommon.justReturn([typeLabel("boolean")])).when(DDataStructure.typeIdentifier(DDataStructure.dateTypeKind), DCommon.justReturn([typeLabel("date")])).when(DDataStructure.typeIdentifier(DDataStructure.timeTypeKind), DCommon.justReturn([typeLabel("time")])).when(DDataStructure.typeIdentifier(fileTypeKind), DCommon.justReturn([typeLabel("file")])).otherwise(DCommon.justReturn([typeLabel("unknown")]));
+	return DPattern.match(type).when(DDataStructure.typeIdentifier(DDataStructure.stringLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.numberLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.bigintLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.booleanLiteralTypeKind), ({ definition }) => [literal(formatLiteral(definition.value))]).when(DDataStructure.typeIdentifier(DDataStructure.nullTypeKind), DCommon.justReturn([literal("null")])).when(DDataStructure.typeIdentifier(DDataStructure.undefinedTypeKind), DCommon.justReturn([literal("undefined")])).when(DDataStructure.typeIdentifier(DDataStructure.stringTypeKind), DCommon.justReturn([typeLabel("string")])).when(DDataStructure.typeIdentifier(DDataStructure.numberTypeKind), DCommon.justReturn([typeLabel("number")])).when(DDataStructure.typeIdentifier(DDataStructure.bigintTypeKind), DCommon.justReturn([typeLabel("bigint")])).when(DDataStructure.typeIdentifier(DDataStructure.booleanTypeKind), DCommon.justReturn([typeLabel("boolean")])).when(DDataStructure.typeIdentifier(DDataStructure.dateTypeKind), DCommon.justReturn([typeLabel("date")])).when(DDataStructure.typeIdentifier(DDataStructure.timeTypeKind), DCommon.justReturn([typeLabel("time")])).when(DDataStructure.typeIdentifier(fileTypeKind), DCommon.justReturn([typeLabel("file")])).when(DDataStructure.typeIdentifier(folderTypeKind), DCommon.justReturn([typeLabel("folder")])).otherwise(DCommon.justReturn([typeLabel("unknown")]));
 }
 function renderStringLength(constraints) {
 	const equal = DArray.find(constraints, DDataStructure.constraintIdentifier(DDataStructure.stringLengthEqualConstraintKind));
@@ -76,7 +78,7 @@ function renderNumberBounds(constraints) {
 	return DArray.filter([greaterThan ? [constraintLabel("> "), literal(String(greaterThan.definition.threshold))] : greaterThanOrEqual ? [constraintLabel("min "), literal(String(greaterThanOrEqual.definition.threshold))] : null, lessThan ? [constraintLabel("< "), literal(String(lessThan.definition.threshold))] : lessThanOrEqual ? [constraintLabel("max "), literal(String(lessThanOrEqual.definition.threshold))] : null], DCommon.truthy);
 }
 function renderSimpleConstraint(constraint) {
-	return DPattern.match(constraint).when(DDataStructure.constraintIdentifier(DDataStructure.emailConstraintKind), DCommon.justReturn([constraintLabel("email")])).when(DDataStructure.constraintIdentifier(DDataStructure.urlConstraintKind), DCommon.justReturn([constraintLabel("url")])).when(DDataStructure.constraintIdentifier(DDataStructure.uuidConstraintKind), DCommon.justReturn([constraintLabel("uuid")])).when(DDataStructure.constraintIdentifier(DDataStructure.integerConstraintKind), DCommon.justReturn([constraintLabel("integer")])).when(DDataStructure.constraintIdentifier(DDataStructure.trimmedConstraintKind), DCommon.justReturn([constraintLabel("trimmed")])).when(DDataStructure.constraintIdentifier(DDataStructure.notEmptyConstraintKind), DCommon.justReturn([constraintLabel("not empty")])).when(DDataStructure.constraintIdentifier(DDataStructure.numberInStringConstraintKind), DCommon.justReturn([constraintLabel("number in string")])).when(DDataStructure.constraintIdentifier(DDataStructure.evenConstraintKind), DCommon.justReturn([constraintLabel("even")])).when(DDataStructure.constraintIdentifier(DDataStructure.oddConstraintKind), DCommon.justReturn([constraintLabel("odd")])).when(DDataStructure.constraintIdentifier(DDataStructure.positiveConstraintKind), DCommon.justReturn([constraintLabel("positive")])).when(DDataStructure.constraintIdentifier(DDataStructure.negativeConstraintKind), DCommon.justReturn([constraintLabel("negative")])).when(DDataStructure.constraintIdentifier(DDataStructure.notZeroConstraintKind), DCommon.justReturn([constraintLabel("not zero")])).when(DDataStructure.constraintIdentifier(DDataStructure.safeConstraintKind), DCommon.justReturn([constraintLabel("safe number")])).when(DDataStructure.constraintIdentifier(DDataStructure.pathConstraintKind), DCommon.justReturn([constraintLabel("path")])).when(DDataStructure.constraintIdentifier(DDataStructure.absolutePathConstraintKind), DCommon.justReturn([constraintLabel("absolute path")])).when(DDataStructure.constraintIdentifier(DDataStructure.segmentPathConstraintKind), DCommon.justReturn([constraintLabel("path segment")])).when(DDataStructure.constraintIdentifier(existConstraintKind), DCommon.justReturn([constraintLabel("exists")])).when(DDataStructure.constraintIdentifier(DDataStructure.strictPositiveConstraintKind), DCommon.justReturn([constraintLabel("> "), literal("0")])).when(DDataStructure.constraintIdentifier(DDataStructure.strictNegativeConstraintKind), DCommon.justReturn([constraintLabel("< "), literal("0")])).when(DDataStructure.constraintIdentifier(DDataStructure.betweenThanConstraintKind), ({ definition }) => [
+	return DPattern.match(constraint).when(DDataStructure.constraintIdentifier(DDataStructure.emailConstraintKind), DCommon.justReturn([constraintLabel("email")])).when(DDataStructure.constraintIdentifier(DDataStructure.urlConstraintKind), DCommon.justReturn([constraintLabel("url")])).when(DDataStructure.constraintIdentifier(DDataStructure.uuidConstraintKind), DCommon.justReturn([constraintLabel("uuid")])).when(DDataStructure.constraintIdentifier(DDataStructure.integerConstraintKind), DCommon.justReturn([constraintLabel("integer")])).when(DDataStructure.constraintIdentifier(DDataStructure.trimmedConstraintKind), DCommon.justReturn([constraintLabel("trimmed")])).when(DDataStructure.constraintIdentifier(DDataStructure.notEmptyConstraintKind), DCommon.justReturn([constraintLabel("not empty")])).when(DDataStructure.constraintIdentifier(DDataStructure.numberInStringConstraintKind), DCommon.justReturn([constraintLabel("number in string")])).when(DDataStructure.constraintIdentifier(DDataStructure.evenConstraintKind), DCommon.justReturn([constraintLabel("even")])).when(DDataStructure.constraintIdentifier(DDataStructure.oddConstraintKind), DCommon.justReturn([constraintLabel("odd")])).when(DDataStructure.constraintIdentifier(DDataStructure.positiveConstraintKind), DCommon.justReturn([constraintLabel("positive")])).when(DDataStructure.constraintIdentifier(DDataStructure.negativeConstraintKind), DCommon.justReturn([constraintLabel("negative")])).when(DDataStructure.constraintIdentifier(DDataStructure.notZeroConstraintKind), DCommon.justReturn([constraintLabel("not zero")])).when(DDataStructure.constraintIdentifier(DDataStructure.safeConstraintKind), DCommon.justReturn([constraintLabel("safe number")])).when(DDataStructure.constraintIdentifier(DDataStructure.pathConstraintKind), DCommon.justReturn([constraintLabel("path")])).when(DDataStructure.constraintIdentifier(DDataStructure.absolutePathConstraintKind), DCommon.justReturn([constraintLabel("absolute path")])).when(DDataStructure.constraintIdentifier(DDataStructure.segmentPathConstraintKind), DCommon.justReturn([constraintLabel("path segment")])).when(DDataStructure.constraintIdentifier(fileExistConstraintKind), DCommon.justReturn([constraintLabel("exists")])).when(DDataStructure.constraintIdentifier(folderExistConstraintKind), DCommon.justReturn([constraintLabel("exists")])).when(DDataStructure.constraintIdentifier(DDataStructure.strictPositiveConstraintKind), DCommon.justReturn([constraintLabel("> "), literal("0")])).when(DDataStructure.constraintIdentifier(DDataStructure.strictNegativeConstraintKind), DCommon.justReturn([constraintLabel("< "), literal("0")])).when(DDataStructure.constraintIdentifier(DDataStructure.betweenThanConstraintKind), ({ definition }) => [
 		constraintLabel("> "),
 		literal(String(definition.greater)),
 		secondary(" and "),
@@ -185,8 +187,8 @@ function renderOptionDetails(option, depth) {
 		const help = renderDataStructure(option.dataStructure);
 		return DArray.filter([
 			renderInline([DPrinter.indent(depth), renderMetadata(help, option.required ? "required" : "optional")]),
-			renderDescriptionLine(option.description, depth),
-			...renderConstraintLines(help.constraints, depth)
+			...renderConstraintLines(help.constraints, depth),
+			renderDescriptionLine(option.description, depth)
 		], DCommon.truthy);
 	}
 	if (booleanOptionKind.has(option)) return DArray.filter([renderInline([DPrinter.indent(depth), typeLabel("boolean")]), renderDescriptionLine(option.description, depth)], DCommon.truthy);
@@ -204,8 +206,8 @@ function renderArgumentsHelp(args, depth) {
 				name(argument.name.padEnd(12)),
 				renderMetadata(help, argument.optional ? "optional" : "required")
 			]),
-			renderDescriptionLine(argument.description, depth + 2),
-			renderConstraintLines(help.constraints, depth + 2)
+			renderConstraintLines(help.constraints, depth + 2),
+			renderDescriptionLine(argument.description, depth + 2)
 		]);
 	})]);
 }

package/dist/command/index.cjs

@@ -25,12 +25,14 @@ var command_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createOption: () => require_simple.createOption,
 	exec: () => require_exec.exec,
 	execOptions: () => require_execOptions.execOptions,
+	findOptionToken: () => require_base.findOptionToken,
 	helpOption: () => require_help.helpOption,
 	interpretDataStructureError: () => require_error.interpretDataStructureError,
 	interpretErrorIssues: () => require_error.interpretErrorIssues,
 	interpretExecCommandError: () => require_error.interpretExecCommandError,
 	interpretExecOptionsError: () => require_error.interpretExecOptionsError,
 	isCommands: () => require_create.isCommands,
+	isOptionToken: () => require_base.isOptionToken,
 	logCommandHelp: () => require_help.logCommandHelp,
 	logExecOptionHelp: () => require_help.logExecOptionHelp,
 	optionIdentifier: () => require_identifier.optionIdentifier,
@@ -61,12 +63,14 @@ exports.createError = require_error.createError;
 exports.createOption = require_simple.createOption;
 exports.exec = require_exec.exec;
 exports.execOptions = require_execOptions.execOptions;
+exports.findOptionToken = require_base.findOptionToken;
 exports.helpOption = require_help.helpOption;
 exports.interpretDataStructureError = require_error.interpretDataStructureError;
 exports.interpretErrorIssues = require_error.interpretErrorIssues;
 exports.interpretExecCommandError = require_error.interpretExecCommandError;
 exports.interpretExecOptionsError = require_error.interpretExecOptionsError;
 exports.isCommands = require_create.isCommands;
+exports.isOptionToken = require_base.isOptionToken;
 exports.logCommandHelp = require_help.logCommandHelp;
 exports.logExecOptionHelp = require_help.logExecOptionHelp;
 exports.optionIdentifier = require_identifier.optionIdentifier;

package/dist/command/index.mjs

@@ -1,7 +1,7 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { argumentKind, createArgument } from "./argument.mjs";
 import { SymbolCommandError, createError, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError } from "./error.mjs";
-import { constructOption, optionKind } from "./options/base.mjs";
+import { constructOption, findOptionToken, isOptionToken, optionKind } from "./options/base.mjs";
 import { arrayOptionKind, createArrayOption } from "./options/defaults/array.mjs";
 import { booleanOptionKind, createBooleanOption } from "./options/defaults/boolean.mjs";
 import { createOption, simpleOptionKind } from "./options/defaults/simple.mjs";
@@ -25,12 +25,14 @@ var command_exports = /* @__PURE__ */ __exportAll({
 	createOption: () => createOption,
 	exec: () => exec,
 	execOptions: () => execOptions,
+	findOptionToken: () => findOptionToken,
 	helpOption: () => helpOption,
 	interpretDataStructureError: () => interpretDataStructureError,
 	interpretErrorIssues: () => interpretErrorIssues,
 	interpretExecCommandError: () => interpretExecCommandError,
 	interpretExecOptionsError: () => interpretExecOptionsError,
 	isCommands: () => isCommands,
+	isOptionToken: () => isOptionToken,
 	logCommandHelp: () => logCommandHelp,
 	logExecOptionHelp: () => logExecOptionHelp,
 	optionIdentifier: () => optionIdentifier,
@@ -42,4 +44,4 @@ var command_exports = /* @__PURE__ */ __exportAll({
 	simpleOptionKind: () => simpleOptionKind
 });
 //#endregion
-export { SymbolCommandError, argumentKind, arrayOptionKind, booleanOptionKind, command_exports, constructOption, create, createArgument, createArrayOption, createBooleanOption, createError, createOption, exec, execOptions, helpOption, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError, isCommands, logCommandHelp, logExecOptionHelp, optionIdentifier, optionKind, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp, simpleOptionKind };
+export { SymbolCommandError, argumentKind, arrayOptionKind, booleanOptionKind, command_exports, constructOption, create, createArgument, createArrayOption, createBooleanOption, createError, createOption, exec, execOptions, findOptionToken, helpOption, interpretDataStructureError, interpretErrorIssues, interpretExecCommandError, interpretExecOptionsError, isCommands, isOptionToken, logCommandHelp, logExecOptionHelp, optionIdentifier, optionKind, renderArgumentsHelp, renderCommandHelp, renderExecOptionHelp, renderOptionsHelp, simpleOptionKind };

package/dist/command/options/base.cjs

@@ -9,24 +9,30 @@ let _duplojs_lang_string = require("@duplojs/lang/string");
 _duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
 //#region scripts/command/options/base.ts
 const optionKind = require_kind.createKind("command-option");
-const regexOption = /^(?<dashes>-{1,2})(?<key>[A-Za-z0-9][A-Za-z0-9_-]*)(?:=(?<value>.*))?$/;
+const regexOption = /^(?<dashes>-{1,2})(?<key>(?![0-9]+(?:=|$))[A-Za-z0-9][A-Za-z0-9_-]*)(?:=(?<value>.*))?$/;
+function isOptionToken(input) {
+	return _duplojs_lang_string.test(input, regexOption);
+}
+function findOptionToken(args, option) {
+	return _duplojs_lang_array.reduce(args, _duplojs_lang_array.reduceFrom(null), ({ element, next, exit, index }) => {
+		const extractResult = _duplojs_lang_string.extract(element, regexOption);
+		if (!extractResult) return next(null);
+		const key = extractResult.namedGroups.key;
+		if (option.name !== key && (!_duplojs_lang_array.includes(option.aliases, key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
+		return exit({
+			key,
+			value: extractResult.namedGroups?.value,
+			index
+		});
+	});
+}
 function constructOption(kindHandler, createConstructor) {
 	return createConstructor({ init: (name, execute, params, ...rest) => {
 		const self = {
 			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
 			name,
 			execute: async (args, error) => {
-				const result = _duplojs_lang_array.reduce(args, _duplojs_lang_array.reduceFrom(null), ({ element, next, exit, index }) => {
-					const extractResult = _duplojs_lang_string.extract(element, regexOption);
-					if (!extractResult) return next(null);
-					const result = {
-						key: extractResult.namedGroups.key,
-						value: extractResult.namedGroups?.value,
-						index
-					};
-					if (self.name !== result.key && (!_duplojs_lang_array.includes(self.aliases, result.key) || extractResult.namedGroups?.dashes !== "-")) return next(null);
-					return exit(result);
-				});
+				const result = findOptionToken(args, self);
 				const { value, argumentRest } = _duplojs_lang_common.justExec(() => {
 					if (!result) return {
 						value: null,
@@ -34,7 +40,7 @@ function constructOption(kindHandler, createConstructor) {
 					};
 					if (result.value === void 0) {
 						const nextArg = args[result.index + 1];
-						if (nextArg === void 0 || _duplojs_lang_string.test(nextArg, regexOption)) return {
+						if (nextArg === void 0 || isOptionToken(nextArg)) return {
 							value: void 0,
 							argumentRest: _duplojs_lang_array.spliceDelete(args, result.index, 1)
 						};
@@ -65,4 +71,6 @@ function constructOption(kindHandler, createConstructor) {
 }
 //#endregion
 exports.constructOption = constructOption;
+exports.findOptionToken = findOptionToken;
+exports.isOptionToken = isOptionToken;
 exports.optionKind = optionKind;

package/dist/command/options/base.d.ts

@@ -2,6 +2,12 @@ import { Error, SymbolCommandError } from '../error';
 import * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 export declare const optionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-option", unknown>>;
+export declare function isOptionToken(input: string): boolean;
+export declare function findOptionToken(args: readonly string[], option: Pick<Option, "name" | "aliases">): {
+    key: string;
+    value: string | undefined;
+    index: number;
+} | null;
 export interface Option<GenericName extends string = string, GenericValue extends unknown = unknown> extends DKind.Kind<typeof optionKind> {
     readonly name: GenericName;
     readonly description: string | null;