@duplojs/utils 1.2.19 → 1.3.20

package/dist/array/group.d.ts

@@ -1,10 +1,10 @@
 import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
-export interface ArrayGroupFunctionOutput<GenericGroupeName extends string = string, GenericGroupeValue extends unknown = unknown> {
-    group: GenericGroupeName;
-    value: GenericGroupeValue;
+export interface ArrayGroupFunctionOutput<GenericGroupName extends string = string, GenericGroupValue extends unknown = unknown> {
+    group: GenericGroupName;
+    value: GenericGroupValue;
 }
-export declare function groupOutput<GenericGroupeValue extends unknown, GenericGroupeName extends string>(group: GenericGroupeName): (value: GenericGroupeValue) => ArrayGroupFunctionOutput<GenericGroupeName, GenericGroupeValue>;
-export declare function groupOutput<GenericGroupeValue extends unknown, GenericGroupeName extends string>(group: GenericGroupeName, value: GenericGroupeValue): ArrayGroupFunctionOutput<GenericGroupeName, GenericGroupeValue>;
+export declare function groupOutput<GenericGroupValue extends unknown, GenericGroupName extends string>(group: GenericGroupName): (value: GenericGroupValue) => ArrayGroupFunctionOutput<GenericGroupName, GenericGroupValue>;
+export declare function groupOutput<GenericGroupValue extends unknown, GenericGroupName extends string>(group: GenericGroupName, value: GenericGroupValue): ArrayGroupFunctionOutput<GenericGroupName, GenericGroupValue>;
 export interface ArrayGroupFunctionParams {
     index: number;
     output: typeof groupOutput;

package/dist/common/types/index.d.ts

@@ -41,3 +41,4 @@ export * from "./removeFromUnion";
 export * from "./unwrapArray";
 export * from "./onlyLiteral";
 export * from "./sortType";
+export * from "./maybeGetter";

package/dist/common/types/maybeGetter.d.ts

@@ -0,0 +1 @@
+export type MayBeGetter<GenericValue extends unknown> = (() => GenericValue) | GenericValue;

package/dist/dataParser/base.cjs

@@ -2,10 +2,10 @@
 
 var error = require('./error.cjs');
 var kind = require('./kind.cjs');
-var pipe = require('../common/pipe.cjs');
 var simpleClone = require('../common/simpleClone.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
 var override = require('../common/override.cjs');
+var pipe = require('../common/pipe.cjs');
 var error$1 = require('../either/left/error.cjs');
 var success = require('../either/right/success.cjs');
 
@@ -27,7 +27,7 @@ const DPE = error.createError();
 const EE = error$1.error(null);
 const ES = success.success(null);
 const KWV = wrapValue.keyWrappedValue;
-function dataParserInit(kind, params, exec) {
+function dataParserInit(kind, definition, exec) {
     const formattedExec = typeof exec === "object"
         ? exec
         : {
@@ -85,7 +85,7 @@ function dataParserInit(kind, params, exec) {
         return result;
     }
     const dataParser = pipe.pipe({
-        ...params,
+        definition,
         exec: middleExec,
         asyncExec: middleAsyncExec,
         parse(data) {
@@ -125,13 +125,11 @@ function dataParserInit(kind, params, exec) {
             };
         },
         addChecker: (...checkers) => dataParserInit(kind, simpleClone.simpleClone({
-            ...params,
-            definition: {
-                ...params.definition,
-                checkers: [...params.definition.checkers, ...checkers],
-            },
+            ...definition,
+            checkers: [...definition.checkers, ...checkers],
         }), exec),
-        clone: () => dataParserInit(kind, simpleClone.simpleClone(params), exec),
+        clone: () => dataParserInit(kind, simpleClone.simpleClone(definition), exec),
+        construct: (definition) => dataParserInit(kind, definition, exec),
     }, (value) => dataParserKind.setTo(value, null), kind.setTo, dataParserInit.overrideHandler.apply);
     return dataParser;
 }

package/dist/dataParser/base.d.ts

@@ -33,12 +33,13 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
     asyncParse(data: unknown): Promise<DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>>;
     addChecker(...args: never): DataParser;
     clone(): this;
+    construct(definition: never): DataParser;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {
     sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
     async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
 }
-export declare function dataParserInit<GenericDataParser extends DataParser>(kind: Exclude<GetKindHandler<GenericDataParser>, typeof dataParserKind>, params: NoInfer<Omit<RemoveKind<GenericDataParser>, "parse" | "exec" | "asyncParse" | "asyncExec" | "addChecker" | "clone">>, exec: (DataParserInitExecParams<GenericDataParser> | DataParserInitExecParams<GenericDataParser>["sync"])): GenericDataParser;
+export declare function dataParserInit<GenericDataParser extends DataParser>(kind: Exclude<GetKindHandler<GenericDataParser>, typeof dataParserKind>, definition: GenericDataParser["definition"], exec: (DataParserInitExecParams<GenericDataParser> | DataParserInitExecParams<GenericDataParser>["sync"])): GenericDataParser;
 export declare namespace dataParserInit {
     var overrideHandler: import("../common").OverrideHandler<DataParser<DataParserDefinition<DataParserChecker<DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }

package/dist/dataParser/base.mjs

@@ -1,9 +1,9 @@
 import { createError, addIssue, addPromiseIssue, SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from './error.mjs';
 import { createDataParserKind } from './kind.mjs';
-import { pipe } from '../common/pipe.mjs';
 import { simpleClone } from '../common/simpleClone.mjs';
 import { keyWrappedValue } from '../common/wrapValue.mjs';
 import { createOverride } from '../common/override.mjs';
+import { pipe } from '../common/pipe.mjs';
 import { error } from '../either/left/error.mjs';
 import { success } from '../either/right/success.mjs';
 
@@ -25,7 +25,7 @@ const DPE = createError();
 const EE = error(null);
 const ES = success(null);
 const KWV = keyWrappedValue;
-function dataParserInit(kind, params, exec) {
+function dataParserInit(kind, definition, exec) {
     const formattedExec = typeof exec === "object"
         ? exec
         : {
@@ -83,7 +83,7 @@ function dataParserInit(kind, params, exec) {
         return result;
     }
     const dataParser = pipe({
-        ...params,
+        definition,
         exec: middleExec,
         asyncExec: middleAsyncExec,
         parse(data) {
@@ -123,13 +123,11 @@ function dataParserInit(kind, params, exec) {
             };
         },
         addChecker: (...checkers) => dataParserInit(kind, simpleClone({
-            ...params,
-            definition: {
-                ...params.definition,
-                checkers: [...params.definition.checkers, ...checkers],
-            },
+            ...definition,
+            checkers: [...definition.checkers, ...checkers],
         }), exec),
-        clone: () => dataParserInit(kind, simpleClone(params), exec),
+        clone: () => dataParserInit(kind, simpleClone(definition), exec),
+        construct: (definition) => dataParserInit(kind, definition, exec),
     }, (value) => dataParserKind.setTo(value, null), kind.setTo, dataParserInit.overrideHandler.apply);
     return dataParser;
 }

package/dist/dataParser/baseExtended.cjs

@@ -59,6 +59,9 @@ function dataParserExtendedInit(dataParser, rest) {
         recover(recoveredValue, definition) {
             return recover.recover(self, recoveredValue, definition);
         },
+        construct(definition) {
+            return dataParserExtendedInit(dataParser.construct(definition), rest);
+        },
     }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply);
     return self;
 }

package/dist/dataParser/baseExtended.d.ts

@@ -43,6 +43,7 @@ export interface DataParserExtended<GenericDefinition extends DataParserDefiniti
         inner: GenericThis;
         recoveredValue: GenericRecoveredValue;
     }>>;
+    construct(definition: never): DataParserExtended;
 }
 export declare function dataParserExtendedInit<GenericDataParser extends DataParser, GenericDataParserExtended extends GenericDataParser & DataParserExtended>(dataParser: NoInfer<GenericDataParser>, rest: NoInfer<{
     [Prop in Exclude<keyof GenericDataParserExtended, keyof (GenericDataParser & DataParserExtended)>]: GenericDataParserExtended[Prop] extends AnyFunction ? (self: GenericDataParserExtended, ...args: Parameters<GenericDataParserExtended[Prop]>) => ReturnType<GenericDataParserExtended[Prop]> : GenericDataParserExtended[Prop];
@@ -50,4 +51,5 @@ export declare function dataParserExtendedInit<GenericDataParser extends DataPar
 export declare namespace dataParserExtendedInit {
     var overrideHandler: import("../common").OverrideHandler<DataParserExtended<DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }
+export type ContractExtended<GenericOutput extends unknown, GenericInput extends unknown = GenericOutput> = DataParserExtended<DataParserDefinition<never>, GenericOutput, GenericInput>;
 export {};

package/dist/dataParser/baseExtended.mjs

@@ -57,6 +57,9 @@ function dataParserExtendedInit(dataParser, rest) {
         recover(recoveredValue, definition) {
             return recover(self, recoveredValue, definition);
         },
+        construct(definition) {
+            return dataParserExtendedInit(dataParser.construct(definition), rest);
+        },
     }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply);
     return self;
 }

package/dist/dataParser/extended/array.d.ts

@@ -12,6 +12,7 @@ export interface DataParserArrayExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserArrayCheckers<Output<this>>,
         ...dataParsers.DataParserArrayCheckers<Output<this>>[]
     ], GenericChecker>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionArray>(definition: GenericDefinition): DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/bigint.d.ts

@@ -12,6 +12,7 @@ export interface DataParserBigIntExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserBigIntCheckers,
         ...dataParsers.DataParserBigIntCheckers[]
     ], GenericChecker>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionBigInt>(definition: GenericDefinition): DataParserBigIntExtended<MergeDefinition<dataParsers.DataParserDefinitionBigInt, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/boolean.d.ts

@@ -12,6 +12,7 @@ export interface DataParserBooleanExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserBooleanCheckers,
         ...dataParsers.DataParserBooleanCheckers[]
     ], GenericChecker>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionBoolean>(definition: GenericDefinition): DataParserBooleanExtended<MergeDefinition<dataParsers.DataParserDefinitionBoolean, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/date.d.ts

@@ -13,6 +13,7 @@ export interface DataParserDateExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserDateCheckers,
         ...dataParsers.DataParserDateCheckers[]
     ], GenericChecker>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionDate>(definition: GenericDefinition): DataParserDateExtended<MergeDefinition<dataParsers.DataParserDefinitionDate, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/empty.d.ts

@@ -12,6 +12,7 @@ export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserEmptyCheckers,
         ...dataParsers.DataParserEmptyCheckers[]
     ], GenericChecker>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionEmpty>(definition: GenericDefinition): DataParserEmptyExtended<MergeDefinition<dataParsers.DataParserDefinitionEmpty, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/index.d.ts

@@ -24,3 +24,4 @@ export * from "./unknown";
 export * from "./recover";
 export * from "../error";
 export { type Contract, type Output, type Input } from "../base";
+export { type ContractExtended } from "../baseExtended";

package/dist/dataParser/extended/lazy.d.ts

@@ -12,6 +12,7 @@ export interface DataParserLazyExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserLazyCheckers<Output<this>>,
         ...dataParsers.DataParserLazyCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionLazy>(definition: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/literal.d.ts

@@ -12,6 +12,7 @@ export interface DataParserLiteralExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserLiteralCheckers<Output<this>>,
         ...dataParsers.DataParserLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/nil.d.ts

@@ -12,6 +12,7 @@ export interface DataParserNilExtended<GenericDefinition extends dataParsers.Dat
         dataParsers.DataParserNilCheckers,
         ...dataParsers.DataParserNilCheckers[]
     ], GenericChecker>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionNil>(definition: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/nullable.d.ts

@@ -12,6 +12,7 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
         dataParsers.DataParserNullableCheckers<Output<this>>,
         ...dataParsers.DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionNullable>(definition: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/number.d.ts

@@ -12,6 +12,7 @@ export interface DataParserNumberExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserNumberCheckers,
         ...dataParsers.DataParserNumberCheckers[]
     ], GenericChecker>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionNumber>(definition: GenericDefinition): DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/object.d.ts

@@ -12,6 +12,7 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserObjectCheckers<Output<this>>,
         ...dataParsers.DataParserObjectCheckers<Output<this>>[]
     ], GenericChecker>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionObject>(definition: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/optional.d.ts

@@ -12,6 +12,7 @@ export interface DataParserOptionalExtended<GenericDefinition extends dataParser
         dataParsers.DataParserOptionalCheckers<Output<this>>,
         ...dataParsers.DataParserOptionalCheckers<Output<this>>[]
     ], GenericChecker>): DataParserOptionalExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionOptional>(definition: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserOptionalExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/pipe.d.ts

@@ -12,6 +12,7 @@ export interface DataParserPipeExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserPipeCheckers<Output<this>>,
         ...dataParsers.DataParserPipeCheckers<Output<this>>[]
     ], GenericChecker>): DataParserPipeExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionPipe>(definition: GenericDefinition): DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserPipeExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/record.d.ts

@@ -12,6 +12,7 @@ export interface DataParserRecordExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserRecordCheckers<Output<this>>,
         ...dataParsers.DataParserRecordCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecordExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionRecord>(definition: GenericDefinition): DataParserRecordExtended<MergeDefinition<dataParsers.DataParserDefinitionRecord, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserRecordExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/recover.d.ts

@@ -12,6 +12,7 @@ export interface DataParserRecoverExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserRecoverCheckers<Output<this>>,
         ...dataParsers.DataParserRecoverCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionRecover>(definition: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/string.d.ts

@@ -12,6 +12,7 @@ export interface DataParserStringExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserStringCheckers,
         ...dataParsers.DataParserStringCheckers[]
     ], GenericChecker>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionString>(definition: GenericDefinition): DataParserStringExtended<MergeDefinition<dataParsers.DataParserDefinitionString, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/templateLiteral.d.ts

@@ -12,6 +12,7 @@ export interface DataParserTemplateLiteralExtended<GenericDefinition extends dat
         dataParsers.DataParserTemplateLiteralCheckers<Output<this>>,
         ...dataParsers.DataParserTemplateLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral>(definition: GenericDefinition): DataParserTemplateLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionTemplateLiteral, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/transform.d.ts

@@ -13,6 +13,7 @@ export interface DataParserTransformExtended<GenericDefinition extends dataParse
         dataParsers.DataParserTransformCheckers<Output<this>>,
         ...dataParsers.DataParserTransformCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTransform>(definition: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/tuple.d.ts

@@ -12,6 +12,7 @@ export interface DataParserTupleExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserTupleCheckers<Output<this>>,
         ...dataParsers.DataParserTupleCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTuple>(definition: GenericDefinition): DataParserTupleExtended<MergeDefinition<dataParsers.DataParserDefinitionTuple, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/union.d.ts

@@ -12,6 +12,7 @@ export interface DataParserUnionExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserUnionCheckers<Output<this>>,
         ...dataParsers.DataParserUnionCheckers<Output<this>>[]
     ], GenericChecker>): DataParserUnionExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionUnion>(definition: GenericDefinition): DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserUnionExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/extended/unknown.d.ts

@@ -12,6 +12,7 @@ export interface DataParserUnknownExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserUnknownCheckers,
         ...dataParsers.DataParserUnknownCheckers[]
     ], GenericChecker>): DataParserUnknownExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionUnknown>(definition: GenericDefinition): DataParserUnknownExtended<MergeDefinition<dataParsers.DataParserDefinitionUnknown, GenericDefinition>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserUnknownExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;

package/dist/dataParser/parsers/array/index.cjs

@@ -8,11 +8,9 @@ var override = require('../../../common/override.cjs');
 const arrayKind = kind.createDataParserKind("array");
 function array(element, definition) {
     const self = base.dataParserInit(arrayKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            element,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        element,
     }, {
         sync: (data, error$1, self) => {
             if (!(data instanceof Array)) {

package/dist/dataParser/parsers/array/index.d.ts

@@ -21,6 +21,7 @@ export interface DataParserArray<GenericDefinition extends DataParserDefinitionA
         DataParserArrayCheckers<Output<this>>,
         ...DataParserArrayCheckers<Output<this>>[]
     ], GenericChecker>): DataParserArray<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionArray>(definition: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, GenericDefinition>>;
 }
 export declare function array<GenericElement extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
     element: GenericElement;

package/dist/dataParser/parsers/array/index.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../../common/override.mjs';
 const arrayKind = createDataParserKind("array");
 function array(element, definition) {
     const self = dataParserInit(arrayKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            element,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        element,
     }, {
         sync: (data, error, self) => {
             if (!(data instanceof Array)) {

package/dist/dataParser/parsers/bigint/index.cjs

@@ -8,11 +8,9 @@ var override = require('../../../common/override.cjs');
 const bigIntKind = kind.createDataParserKind("bigint");
 function bigint(definition) {
     const self = base.dataParserInit(bigIntKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
             try {

package/dist/dataParser/parsers/bigint/index.d.ts

@@ -21,6 +21,7 @@ export interface DataParserBigInt<GenericDefinition extends DataParserDefinition
         DataParserBigIntCheckers,
         ...DataParserBigIntCheckers[]
     ], GenericChecker>): DataParserBigInt<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionBigInt>(definition: GenericDefinition): DataParserBigInt<MergeDefinition<DataParserDefinitionBigInt, GenericDefinition>>;
 }
 export declare function bigint<const GenericDefinition extends Partial<DataParserDefinitionBigInt> = never>(definition?: GenericDefinition): DataParserBigInt<MergeDefinition<DataParserDefinitionBigInt, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace bigint {

package/dist/dataParser/parsers/bigint/index.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../../common/override.mjs';
 const bigIntKind = createDataParserKind("bigint");
 function bigint(definition) {
     const self = dataParserInit(bigIntKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
             try {

package/dist/dataParser/parsers/boolean.cjs

@@ -8,11 +8,9 @@ var override = require('../../common/override.cjs');
 const booleanKind = kind.createDataParserKind("boolean");
 function boolean(definition) {
     const self = base.dataParserInit(booleanKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (typeof data === "boolean") {
             return data;

package/dist/dataParser/parsers/boolean.d.ts

@@ -19,6 +19,7 @@ export interface DataParserBoolean<GenericDefinition extends DataParserDefinitio
         DataParserBooleanCheckers,
         ...DataParserBooleanCheckers[]
     ], GenericChecker>): DataParserBoolean<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionBoolean>(definition: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, GenericDefinition>>;
 }
 export declare function boolean<const GenericDefinition extends Partial<DataParserDefinitionBoolean> = never>(definition?: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace boolean {

package/dist/dataParser/parsers/boolean.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../common/override.mjs';
 const booleanKind = createDataParserKind("boolean");
 function boolean(definition) {
     const self = dataParserInit(booleanKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (typeof data === "boolean") {
             return data;

package/dist/dataParser/parsers/date.cjs

@@ -10,11 +10,9 @@ var override = require('../../common/override.cjs');
 const dateKind = kind.createDataParserKind("date");
 function date(definition) {
     const self = base.dataParserInit(dateKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
             if (data instanceof Date) {

package/dist/dataParser/parsers/date.d.ts

@@ -20,6 +20,7 @@ export interface DataParserDate<GenericDefinition extends DataParserDefinitionDa
         DataParserDateCheckers,
         ...DataParserDateCheckers[]
     ], GenericChecker>): DataParserDate<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionDate>(definition: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, GenericDefinition>>;
 }
 export declare function date<const GenericDefinition extends Partial<DataParserDefinitionDate> = never>(definition?: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace date {

package/dist/dataParser/parsers/date.mjs

@@ -8,11 +8,9 @@ import { createOverride } from '../../common/override.mjs';
 const dateKind = createDataParserKind("date");
 function date(definition) {
     const self = dataParserInit(dateKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
             if (data instanceof Date) {

package/dist/dataParser/parsers/empty.cjs

@@ -8,11 +8,9 @@ var override = require('../../common/override.cjs');
 const emptyKind = kind.createDataParserKind("empty");
 function empty(definition) {
     const self = base.dataParserInit(emptyKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (data === undefined) {
             return data;

package/dist/dataParser/parsers/empty.d.ts

@@ -19,6 +19,7 @@ export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionE
         DataParserEmptyCheckers,
         ...DataParserEmptyCheckers[]
     ], GenericChecker>): DataParserEmpty<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionEmpty>(definition: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, GenericDefinition>>;
 }
 export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace empty {

package/dist/dataParser/parsers/empty.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../common/override.mjs';
 const emptyKind = createDataParserKind("empty");
 function empty(definition) {
     const self = dataParserInit(emptyKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            coerce: definition?.coerce ?? false,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (data === undefined) {
             return data;