@clerc/core 1.0.0-beta.15 → 1.0.0-beta.16

package/dist/chunk-BAz01cYq.js

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 import { ErrorHandler as ErrorHandler$1 } from "lite-emit";
 
-//#region rolldown:runtime
-//#endregion
 //#region ../parser/src/errors.d.ts
 declare class InvalidSchemaError extends Error {
   constructor(message: string);
@@ -12,7 +10,7 @@ declare class MissingRequiredFlagError extends Error {
 //#endregion
 //#region ../parser/src/flag-types.d.ts
 /**
-* Creates a Choices type function that validates the input against allowed values.
+* Creates a Enum type function that validates the input against allowed values.
 * The display name will be formatted as "value1 | value2 | ..." for help output.
 *
 * @param values - Array of allowed string values
@@ -21,11 +19,11 @@ declare class MissingRequiredFlagError extends Error {
 *
 * @example
 * ```typescript
-* const format = Choices(['json', 'yaml', 'xml']);
+* const format = Enum(['json', 'yaml', 'xml']);
 * // Help output will show: json | yaml | xml
 * ```
 */
-declare function Choices<T extends string>(...values: T[]): FlagTypeFunction<T>;
+declare function Enum<T extends string>(...values: T[]): FlagTypeFunction<T>;
 //#endregion
 //#region ../utils/src/types/type-fest.d.ts
 type LiteralUnion<LiteralType, BaseType> = LiteralType | (BaseType & Record<never, never>);
@@ -46,21 +44,24 @@ type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) ext
 type CamelCase<S extends string> = S extends `${infer Head} ${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S;
 //#endregion
 //#region ../parser/src/types.d.ts
-type FlagDefaultValue<T = unknown> = T | ((() => T) & {
+interface FlagDefaultValueFunction<T> {
+  (): T;
   display?: string;
-});
+}
+type FlagDefaultValue<T = unknown> = T | FlagDefaultValueFunction<T>;
 /**
 * Defines how a string input is converted to the target type T.
 *
 * @template T The target type.
 */
-type FlagTypeFunction<T = unknown> = ((value: string) => T) & {
+interface FlagTypeFunction<T = unknown> {
+  (value: string): T;
   /**
   * Optional display name for the type, useful in help output.
   * If provided, this will be shown instead of the function name.
   */
   display?: string;
-};
+}
 /**
 * A callback function to conditionally stop parsing.
 * When it returns true, parsing stops and remaining arguments are preserved in `ignored`.
@@ -184,7 +185,7 @@ declare function createParser<T extends FlagsDefinition>(options?: ParserOptions
 };
 declare const parse: <T extends FlagsDefinition>(args: string[], options?: ParserOptions<T>) => ParsedResult<InferFlags<T>>;
 declare namespace index_d_exports {
-  export { BaseFlagOptions, Choices, DOUBLE_DASH, FlagDefaultValue, FlagDefinitionValue, FlagOptions, FlagType, FlagTypeFunction, FlagsDefinition, IgnoreFunction, InferFlags, InvalidSchemaError, KNOWN_FLAG, MissingRequiredFlagError, ObjectInputType, PARAMETER, ParsedResult, ParserOptions, RawInputType, UNKNOWN_FLAG, createParser, parse };
+  export { BaseFlagOptions, DOUBLE_DASH, Enum, FlagDefaultValue, FlagDefaultValueFunction, FlagDefinitionValue, FlagOptions, FlagType, FlagTypeFunction, FlagsDefinition, IgnoreFunction, InferFlags, InvalidSchemaError, KNOWN_FLAG, MissingRequiredFlagError, ObjectInputType, PARAMETER, ParsedResult, ParserOptions, RawInputType, UNKNOWN_FLAG, createParser, parse };
 }
 //#endregion
 //#region src/types/clerc.d.ts
@@ -195,13 +196,31 @@ interface FlagCustomOptions {}
 type ClercFlagOptions = FlagOptions & FlagCustomOptions;
 type ClercGlobalFlagDefinitionValue = ClercFlagOptions | FlagType;
 type ClercFlagOptionsWithDescription = ClercFlagOptions & {
-  description: string;
+  description?: string;
 };
 type ClercFlagsDefinition = Record<string, ClercFlagOptionsWithDescription>;
 //#endregion
+//#region src/types/constraint.d.ts
+/**
+* Creates an enum constraint function that validates the input against a set of allowed values.
+*
+* @template T - The union type of allowed string values. Just a marker type to help with inference.
+*/
+interface ConstraintFunction<T = string> {
+  (value: string): void;
+  display?: string;
+}
+//#endregion
 //#region src/types/parameters.d.ts
-type InferParameter<T extends string> = T extends `<${infer Name extends string}...>` | `[${infer Name extends string}...]` ? Record<CamelCase<Name>, string[]> : T extends `<${infer Name extends string}>` ? Record<CamelCase<Name>, string> : T extends `[${infer Name extends string}]` ? Record<CamelCase<Name>, string | undefined> : never;
-type InferParameters<T extends readonly string[]> = T extends readonly (infer U extends string)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+type InferStringParameter<T extends string, Type$1 = string> = T extends `<${infer Name extends string}...>` | `[${infer Name extends string}...]` ? Record<CamelCase<Name>, Type$1[]> : T extends `<${infer Name extends string}>` ? Record<CamelCase<Name>, Type$1> : T extends `[${infer Name extends string}]` ? Record<CamelCase<Name>, Type$1 | undefined> : never;
+type InferParameter<T extends Parameter> = T extends string ? InferStringParameter<T> : T extends ParameterDefinition ? T["constraint"] extends ConstraintFunction<infer U> ? InferStringParameter<T["key"], U> : InferStringParameter<T["key"]> : never;
+type InferParameters<T extends readonly Parameter[]> = T extends readonly (infer U extends Parameter)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+interface ParameterDefinition {
+  key: string;
+  description?: string;
+  constraint?: ConstraintFunction;
+}
+type Parameter = string | ParameterDefinition;
 //#endregion
 //#region src/types/context.d.ts
 type AddStringIndex<T> = T & Record<string, any>;
@@ -221,7 +240,7 @@ interface BaseContext<C extends Command = Command, GF extends ClercFlagsDefiniti
 //#endregion
 //#region src/types/command.d.ts
 interface CommandCustomOptions {}
-interface CommandOptions<Parameters extends readonly string[] = readonly string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
+interface CommandOptions<Parameters extends readonly Parameter[] = readonly Parameter[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
   alias?: MaybeArray<string>;
   parameters?: Parameters;
   flags?: Flags;
@@ -230,11 +249,11 @@ interface CommandOptions<Parameters extends readonly string[] = readonly string[
   */
   ignore?: IgnoreFunction;
 }
-interface Command<Name$1 extends string = string, Parameters extends readonly string[] = readonly string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
+interface Command<Name$1 extends string = string, Parameters extends readonly Parameter[] = readonly Parameter[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
   name: Name$1;
-  description: string;
+  description?: string;
 }
-type CommandWithHandler<Name$1 extends string = string, Parameters extends readonly string[] = readonly string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
+type CommandWithHandler<Name$1 extends string = string, Parameters extends readonly Parameter[] = readonly Parameter[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
   handler?: CommandHandler<Command<Name$1, Parameters, Flags>>;
 };
 type CommandsRecord = Record<string, Command>;
@@ -292,9 +311,11 @@ declare class Clerc<Commands extends CommandsRecord = {}, GlobalFlags extends Cl
   version(version: string): this;
   use(plugin: Plugin): this;
   errorHandler(handler: ErrorHandler$1): this;
-  command<Name$1 extends string, const Parameters extends readonly string[] = readonly [], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, Parameters, Flags>): Clerc<Commands & Record<string, CommandWithHandler<Name$1, Parameters, Flags>>, GlobalFlags>;
-  command<Name$1 extends string, const Parameters extends readonly string[] = readonly [], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, description: string, options?: CommandOptions<Parameters, Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
+  command<Name$1 extends string, const Parameters extends readonly Parameter[] = readonly [], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, Parameters, Flags>): Clerc<Commands & Record<string, CommandWithHandler<Name$1, Parameters, Flags>>, GlobalFlags>;
+  command<Name$1 extends string, const Parameters extends readonly Parameter[] = readonly [], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, options?: CommandOptions<Parameters, Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
+  command<Name$1 extends string, const Parameters extends readonly Parameter[] = readonly [], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, description: string, options?: CommandOptions<Parameters, Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
   globalFlag<Name$1 extends string, Flag extends ClercGlobalFlagDefinitionValue>(name: Name$1, description: string, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
+  globalFlag<Name$1 extends string, Flag extends ClercGlobalFlagDefinitionValue>(name: Name$1, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
   interceptor(interceptor: Interceptor<Command, GlobalFlags>): this;
   on<Name$1 extends LiteralUnion<keyof Commands, string>>(name: Name$1, handler: CommandHandler<Commands[Name$1], GlobalFlags>): this;
   run(): Promise<void>;
@@ -303,6 +324,45 @@ declare class Clerc<Commands extends CommandsRecord = {}, GlobalFlags extends Cl
 //#endregion
 //#region src/commands.d.ts
 declare function resolveCommand(commandsMap: CommandsMap, parameters: string[]): [Command, string] | [undefined, undefined];
+declare namespace constraint_d_exports {
+  export { Custom, Enum$1 as Enum, Range, Regex };
+}
+/**
+* Creates an enum constraint function that validates the input against a set of allowed values.
+*
+* @param values - Array of allowed string values
+* @returns A ConstraintFunction that validates the input value
+* @throws {Error} If the value is not in the allowed values list
+*/
+declare function Enum$1<T extends string>(...values: T[]): ConstraintFunction<T>;
+/**
+* Creates a range constraint function that validates the input is a number within the specified range.
+*
+* @param min - The minimum acceptable value (inclusive)
+* @param max - The maximum acceptable value (inclusive)
+* @returns A ConstraintFunction that validates the input value
+* @throws {Error} If the value is not a number or is outside the specified range
+*/
+declare function Range(min: number, max: number): ConstraintFunction;
+/**
+* Creates a regex constraint function that validates the input against the provided pattern.
+*
+* @param pattern - The regular expression pattern to validate against
+* @param description - Optional description for display purposes
+* @returns A ConstraintFunction that validates the input value
+* @throws {Error} If the value does not match the regex pattern
+*/
+declare function Regex(pattern: RegExp, description?: string): ConstraintFunction;
+/**
+* Just an utility to create custom constraints, helps you set the display name.
+*
+* @param validator - A function that validates the input value. Should return true if valid, false or throw an error if invalid.
+* @param display - Optional display name for the constraint, useful in help output.
+* @param errorMessage - Optional function to generate a custom error message when validation fails.
+* @returns A ConstraintFunction that applies the custom validation logic.
+* @throws {Error} If the validator returns false or throws an error.
+*/
+declare function Custom(validator: (value: string) => boolean | void, display?: string, errorMessage?: (value: string) => string): ConstraintFunction;
 //#endregion
 //#region src/errors.d.ts
 declare class NoSuchCommandError extends Error {
@@ -321,9 +381,12 @@ declare class MissingRequiredMetadataError extends Error {
 declare class InvalidParametersError extends Error {
   constructor(message: string);
 }
+declare namespace flag_types_d_exports {
+  export { Enum };
+}
 //#endregion
 //#region src/helpers.d.ts
-declare const defineCommand: <Name$1 extends string, const Parameters extends readonly string[] = readonly [], Flags extends ClercFlagsDefinition = {}>(command: Command<Name$1, Parameters, Flags>, handler?: NoInfer<CommandHandler<Command<Name$1, Parameters, Flags>>>) => CommandWithHandler<Name$1, Parameters, Flags>;
+declare const defineCommand: <Name$1 extends string, const Parameters extends readonly Parameter[] = readonly [], Flags extends ClercFlagsDefinition = {}>(command: Command<Name$1, Parameters, Flags>, handler?: NoInfer<CommandHandler<Command<Name$1, Parameters, Flags>>>) => CommandWithHandler<Name$1, Parameters, Flags>;
 //#endregion
 //#region src/ignore.d.ts
 declare function createStopAtFirstParameter(): IgnoreFunction;
@@ -331,4 +394,4 @@ declare function createStopAtFirstParameter(): IgnoreFunction;
 //#region src/plugin.d.ts
 declare const definePlugin: (plugin: Plugin) => Plugin;
 //#endregion
-export { BaseContext, Choices, Clerc, ClercFlagOptions, ClercFlagOptionsWithDescription, ClercFlagsDefinition, ClercGlobalFlagDefinitionValue, Command, CommandCustomOptions, CommandHandler, CommandHandlerContext, CommandOptions, CommandWithHandler, CommandsMap, CommandsRecord, ContextStore, type CreateOptions, DOUBLE_DASH, ErrorHandler, FlagCustomOptions, InferParameters, Interceptor, InterceptorContext, InterceptorHandler, InterceptorNext, InterceptorObject, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MakeEmitterEvents, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, type ParseOptions, type index_d_exports as Parser, Plugin, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };
+export { BaseContext, Clerc, ClercFlagOptions, ClercFlagOptionsWithDescription, ClercFlagsDefinition, ClercGlobalFlagDefinitionValue, Command, CommandCustomOptions, CommandHandler, CommandHandlerContext, CommandOptions, CommandWithHandler, CommandsMap, CommandsRecord, ConstraintFunction, constraint_d_exports as Constraints, ContextStore, type CreateOptions, DOUBLE_DASH, ErrorHandler, FlagCustomOptions, InferParameters, Interceptor, InterceptorContext, InterceptorHandler, InterceptorNext, InterceptorObject, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MakeEmitterEvents, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, Parameter, ParameterDefinition, type ParseOptions, type index_d_exports as Parser, Plugin, flag_types_d_exports as Types, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };

package/dist/index.js

@@ -1,4 +1,5 @@
-import { Choices, DOUBLE_DASH, DOUBLE_DASH as DOUBLE_DASH$1, InvalidSchemaError, KNOWN_FLAG, PARAMETER, PARAMETER as PARAMETER$1, UNKNOWN_FLAG, parse } from "@clerc/parser";
+import { t as __export } from "./chunk-BAz01cYq.js";
+import { DOUBLE_DASH, DOUBLE_DASH as DOUBLE_DASH$1, Enum, InvalidSchemaError, KNOWN_FLAG, PARAMETER, PARAMETER as PARAMETER$1, UNKNOWN_FLAG, parse } from "@clerc/parser";
 import { LiteEmit } from "lite-emit";
 
 //#region ../utils/src/index.ts
@@ -111,11 +112,12 @@ function _parseParameters(definitions, parameters) {
 	const result = {};
 	let hasOptional = false;
 	for (const [i, definition] of definitions.entries()) {
-		const match = definition.match(PARAMETER_REGEX);
-		if (!match || !isParameterDefinitionBracketsValid(definition)) throw new InvalidParametersError(`Invalid parameter definition: ${definition}`);
+		const definitionKey = typeof definition === "string" ? definition : definition.key;
+		const match = definitionKey.match(PARAMETER_REGEX);
+		if (!match || !isParameterDefinitionBracketsValid(definitionKey)) throw new InvalidParametersError(`Invalid parameter definition: ${definitionKey}`);
 		const name = camelCase(match[2]);
 		const isVariadic = !!match[3];
-		const isRequired = definition.startsWith("<");
+		const isRequired = definitionKey.startsWith("<");
 		if (name in result) throw new InvalidParametersError(`Duplicate parameter name: ${name}`);
 		if (isVariadic && i !== definitions.length - 1) throw new InvalidParametersError("Variadic parameter must be the last parameter in the definition.");
 		if (isRequired) {
@@ -123,6 +125,10 @@ function _parseParameters(definitions, parameters) {
 		} else hasOptional = true;
 		const value = isVariadic ? parameters.slice(i) : parameters[i];
 		if (isRequired && (isVariadic ? value.length === 0 : value === void 0)) throw new InvalidParametersError(`Missing required ${isVariadic ? "variadic " : ""}parameter: ${name}`);
+		if (typeof definition !== "string" && definition.constraint) {
+			if (isVariadic) for (const v of value) definition.constraint(v);
+			else if (value !== void 0) definition.constraint(value);
+		}
 		result[name] = value;
 	}
 	return result;
@@ -238,11 +244,12 @@ var Clerc = class Clerc {
 		if (this.#commands.has(name)) throw new InvalidCommandError(`Command with name "${name}" already exists.`);
 		for (const alias of aliases) if (this.#commands.has(alias)) throw new InvalidCommandError(`Command with name "${alias}" already exists.`);
 	}
-	command(nameOrCommandObject, description, options) {
+	command(nameOrCommandObject, descriptionOrOptions, options) {
+		const isDescription = typeof descriptionOrOptions === "string";
 		const command = typeof nameOrCommandObject === "string" ? {
 			name: nameOrCommandObject,
-			description,
-			...options
+			description: isDescription ? descriptionOrOptions : void 0,
+			...isDescription ? options : descriptionOrOptions
 		} : nameOrCommandObject;
 		const aliases = toArray(command?.alias ?? []);
 		this.#callWithErrorHandler(() => this.#validateCommandNameAndAlias(command.name, aliases));
@@ -254,10 +261,11 @@ var Clerc = class Clerc {
 		if (command.handler) this.on(command.name, command.handler);
 		return this;
 	}
-	globalFlag(name, description, options) {
+	globalFlag(name, descriptionOrOptions, options) {
+		const isDescription = typeof descriptionOrOptions === "string";
 		this.#globalFlags[name] = {
-			description,
-			...options
+			description: isDescription ? descriptionOrOptions : void 0,
+			...isDescription ? options : descriptionOrOptions
 		};
 		return this;
 	}
@@ -271,7 +279,6 @@ var Clerc = class Clerc {
 	}
 	#validate() {
 		if (!this.#scriptName) throw new MissingRequiredMetadataError("script name");
-		if (!this.#description) throw new MissingRequiredMetadataError("description");
 		if (!this.#version) throw new MissingRequiredMetadataError("version");
 	}
 	#parseArgv(argv, command) {
@@ -328,6 +335,80 @@ var Clerc = class Clerc {
 	}
 };
 
+//#endregion
+//#region src/constraint.ts
+var constraint_exports = /* @__PURE__ */ __export({
+	Custom: () => Custom,
+	Enum: () => Enum$1,
+	Range: () => Range,
+	Regex: () => Regex
+});
+/**
+* Creates an enum constraint function that validates the input against a set of allowed values.
+*
+* @param values - Array of allowed string values
+* @returns A ConstraintFunction that validates the input value
+* @throws {Error} If the value is not in the allowed values list
+*/
+function Enum$1(...values) {
+	function fn(value) {
+		if (!values.includes(value)) throw new Error(`Invalid value: ${value}. Must be one of: ${values.join(", ")}`);
+	}
+	fn.display = values.join(" | ");
+	return fn;
+}
+/**
+* Creates a range constraint function that validates the input is a number within the specified range.
+*
+* @param min - The minimum acceptable value (inclusive)
+* @param max - The maximum acceptable value (inclusive)
+* @returns A ConstraintFunction that validates the input value
+* @throws {Error} If the value is not a number or is outside the specified range
+*/
+function Range(min, max) {
+	function fn(value) {
+		const num = Number(value);
+		if (Number.isNaN(num) || num < min || num > max) throw new Error(`Invalid value: ${value}. Must be a number between ${min} and ${max}`);
+	}
+	fn.display = `${min}-${max}`;
+	return fn;
+}
+/**
+* Creates a regex constraint function that validates the input against the provided pattern.
+*
+* @param pattern - The regular expression pattern to validate against
+* @param description - Optional description for display purposes
+* @returns A ConstraintFunction that validates the input value
+* @throws {Error} If the value does not match the regex pattern
+*/
+function Regex(pattern, description) {
+	function fn(value) {
+		if (!pattern.test(value)) throw new Error(`Invalid value: ${value}. Must match pattern: ${pattern}`);
+	}
+	fn.display = description ?? pattern.toString();
+	return fn;
+}
+/**
+* Just an utility to create custom constraints, helps you set the display name.
+*
+* @param validator - A function that validates the input value. Should return true if valid, false or throw an error if invalid.
+* @param display - Optional display name for the constraint, useful in help output.
+* @param errorMessage - Optional function to generate a custom error message when validation fails.
+* @returns A ConstraintFunction that applies the custom validation logic.
+* @throws {Error} If the validator returns false or throws an error.
+*/
+function Custom(validator, display, errorMessage) {
+	function fn(value) {
+		if (validator(value) === false) throw new Error(errorMessage ? errorMessage(value) : `Invalid value: ${value}`);
+	}
+	fn.display = display;
+	return fn;
+}
+
+//#endregion
+//#region src/flag-types.ts
+var flag_types_exports = /* @__PURE__ */ __export({ Enum: () => Enum });
+
 //#endregion
 //#region src/helpers.ts
 const defineCommand = (command, handler) => ({
@@ -353,4 +434,4 @@ function createStopAtFirstParameter() {
 const definePlugin = (plugin) => plugin;
 
 //#endregion
-export { Choices, Clerc, DOUBLE_DASH, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };
+export { Clerc, constraint_exports as Constraints, DOUBLE_DASH, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, flag_types_exports as Types, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/core",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.16",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve)",
   "type": "module",
   "description": "Clerc core",
@@ -45,10 +45,10 @@
   },
   "dependencies": {
     "lite-emit": "^3.1.0",
-    "@clerc/parser": "^1.0.0-beta.15"
+    "@clerc/parser": "^1.0.0-beta.16"
   },
   "devDependencies": {
     "is-platform": "^1.0.0",
-    "@clerc/utils": "1.0.0-beta.15"
+    "@clerc/utils": "1.0.0-beta.16"
   }
 }