@duplojs/utils 1.3.19 → 1.3.20

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

@@ -19,6 +19,7 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
         DataParserLazyCheckers<Output<this>>,
         ...DataParserLazyCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLazy<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionLazy>(definition: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, GenericDefinition>>;
 }
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter: Memoized<GenericDataParser>;

package/dist/dataParser/parsers/lazy.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../common/override.mjs';
 const lazyKind = createDataParserKind("lazy");
 function lazy(getter, definition) {
     const self = dataParserInit(lazyKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            getter: memo(getter),
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        getter: memo(getter),
     }, {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),

package/dist/dataParser/parsers/literal.cjs

@@ -9,11 +9,9 @@ var override = require('../../common/override.cjs');
 const literalKind = kind.createDataParserKind("literal");
 function literal(value, definition) {
     const self = base.dataParserInit(literalKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            value: coalescing.coalescing(value),
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        value: coalescing.coalescing(value),
     }, (data, _error, self) => {
         if (self.definition.value.includes(data)) {
             return data;

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

@@ -20,6 +20,7 @@ export interface DataParserLiteral<GenericDefinition extends DataParserDefinitio
         DataParserLiteralCheckers<Output<this>>,
         ...DataParserLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, GenericDefinition>>;
 }
 export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
     value: GenericValue[];

package/dist/dataParser/parsers/literal.mjs

@@ -7,11 +7,9 @@ import { createOverride } from '../../common/override.mjs';
 const literalKind = createDataParserKind("literal");
 function literal(value, definition) {
     const self = dataParserInit(literalKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            value: coalescing(value),
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        value: coalescing(value),
     }, (data, _error, self) => {
         if (self.definition.value.includes(data)) {
             return data;

package/dist/dataParser/parsers/nil.cjs

@@ -8,11 +8,9 @@ var override = require('../../common/override.cjs');
 const nilKind = kind.createDataParserKind("nil");
 function nil(definition) {
     const self = base.dataParserInit(nilKind, {
-        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 === null) {
             return data;

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

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

package/dist/dataParser/parsers/nil.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../common/override.mjs';
 const nilKind = createDataParserKind("nil");
 function nil(definition) {
     const self = dataParserInit(nilKind, {
-        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 === null) {
             return data;

package/dist/dataParser/parsers/nullable.cjs

@@ -7,12 +7,10 @@ var override = require('../../common/override.cjs');
 const nullableKind = kind.createDataParserKind("nullable");
 function nullable(inner, definition) {
     const self = base.dataParserInit(nullableKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            coalescingValue: definition?.coalescingValue ?? null,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        coalescingValue: definition?.coalescingValue ?? null,
     }, {
         sync: (data, error, self) => {
             if (data === null) {

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

@@ -20,6 +20,7 @@ export interface DataParserNullable<GenericDefinition extends DataParserDefiniti
         DataParserNullableCheckers<Output<this>>,
         ...DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullable<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionNullable>(definition: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, GenericDefinition>>;
 }
 export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;

package/dist/dataParser/parsers/nullable.mjs

@@ -5,12 +5,10 @@ import { createOverride } from '../../common/override.mjs';
 const nullableKind = createDataParserKind("nullable");
 function nullable(inner, definition) {
     const self = dataParserInit(nullableKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            coalescingValue: definition?.coalescingValue ?? null,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        coalescingValue: definition?.coalescingValue ?? null,
     }, {
         sync: (data, error, self) => {
             if (data === null) {

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

@@ -8,11 +8,9 @@ var override = require('../../../common/override.cjs');
 const numberKind = kind.createDataParserKind("number");
 function number(definition) {
     const self = base.dataParserInit(numberKind, {
-        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/number/index.d.ts

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

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

@@ -6,11 +6,9 @@ import { createOverride } from '../../../common/override.mjs';
 const numberKind = createDataParserKind("number");
 function number(definition) {
     const self = dataParserInit(numberKind, {
-        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/object/index.cjs

@@ -14,15 +14,13 @@ var override = require('../../../common/override.cjs');
 const objectKind = kind.createDataParserKind("object");
 function object(shape, definition) {
     const self = base.dataParserInit(objectKind, {
-        definition: {
-            shape,
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            optimizedShape: memo.memo(() => pipe.pipe(forward.forward(shape), entries.entries, filter.filter((entry) => base.dataParserKind.has(entry[1])), map.map(([key, value]) => ({
-                key,
-                value,
-            })))),
-        },
+        shape,
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        optimizedShape: memo.memo(() => pipe.pipe(forward.forward(shape), entries.entries, filter.filter((entry) => base.dataParserKind.has(entry[1])), map.map(([key, value]) => ({
+            key,
+            value,
+        })))),
     }, {
         sync: (data, error$1, self) => {
             if (!data

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

@@ -35,6 +35,7 @@ export interface DataParserObject<GenericDefinition extends DataParserDefinition
         DataParserObjectCheckers<Output<this>>,
         ...DataParserObjectCheckers<Output<this>>[]
     ], GenericChecker>): DataParserObject<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionObject>(definition: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, GenericDefinition>>;
 }
 export declare function object<const GenericShape extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: GenericShape;

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

@@ -12,15 +12,13 @@ import { createOverride } from '../../../common/override.mjs';
 const objectKind = createDataParserKind("object");
 function object(shape, definition) {
     const self = dataParserInit(objectKind, {
-        definition: {
-            shape,
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            optimizedShape: memo(() => pipe(forward(shape), entries, filter((entry) => dataParserKind.has(entry[1])), map(([key, value]) => ({
-                key,
-                value,
-            })))),
-        },
+        shape,
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        optimizedShape: memo(() => pipe(forward(shape), entries, filter((entry) => dataParserKind.has(entry[1])), map(([key, value]) => ({
+            key,
+            value,
+        })))),
     }, {
         sync: (data, error, self) => {
             if (!data

package/dist/dataParser/parsers/optional.cjs

@@ -7,12 +7,10 @@ var override = require('../../common/override.cjs');
 const optionalKind = kind.createDataParserKind("optional");
 function optional(inner, definition) {
     const self = base.dataParserInit(optionalKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            coalescingValue: definition?.coalescingValue,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        coalescingValue: definition?.coalescingValue,
     }, {
         sync: (data, error, self) => {
             if (data === undefined) {

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

@@ -20,6 +20,7 @@ export interface DataParserOptional<GenericDefinition extends DataParserDefiniti
         DataParserOptionalCheckers<Output<this>>,
         ...DataParserOptionalCheckers<Output<this>>[]
     ], GenericChecker>): DataParserOptional<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionOptional>(definition: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, GenericDefinition>>;
 }
 export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;

package/dist/dataParser/parsers/optional.mjs

@@ -5,12 +5,10 @@ import { createOverride } from '../../common/override.mjs';
 const optionalKind = createDataParserKind("optional");
 function optional(inner, definition) {
     const self = dataParserInit(optionalKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            coalescingValue: definition?.coalescingValue,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        coalescingValue: definition?.coalescingValue,
     }, {
         sync: (data, error, self) => {
             if (data === undefined) {

package/dist/dataParser/parsers/pipe.cjs

@@ -7,12 +7,10 @@ var override = require('../../common/override.cjs');
 const pipeKind = kind.createDataParserKind("pipe");
 function pipe(input, output, definition) {
     const self = base.dataParserInit(pipeKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            input,
-            output,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        input,
+        output,
     }, {
         sync: (data, error, self) => {
             const result = self.definition.input.exec(data, error);

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

@@ -20,6 +20,7 @@ export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPi
         DataParserPipeCheckers<Output<this>>,
         ...DataParserPipeCheckers<Output<this>>[]
     ], GenericChecker>): DataParserPipe<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionPipe>(definition: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, GenericDefinition>>;
 }
 export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;

package/dist/dataParser/parsers/pipe.mjs

@@ -5,12 +5,10 @@ import { createOverride } from '../../common/override.mjs';
 const pipeKind = createDataParserKind("pipe");
 function pipe(input, output, definition) {
     const self = dataParserInit(pipeKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            input,
-            output,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        input,
+        output,
     }, {
         sync: (data, error, self) => {
             const result = self.definition.input.exec(data, error);

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

@@ -9,13 +9,11 @@ var override = require('../../../common/override.cjs');
 const recordKind = kind.createDataParserKind("record");
 function record(key, value, definition) {
     const self = base.dataParserInit(recordKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            key,
-            value,
-            requireKey: findRecordRequiredKey.findRecordRequiredKey(key),
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        key,
+        value,
+        requireKey: findRecordRequiredKey.findRecordRequiredKey(key),
     }, {
         sync: (data, error$1, self) => {
             if (!data

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

@@ -35,6 +35,7 @@ export interface DataParserRecord<GenericDefinition extends DataParserDefinition
         DataParserRecordCheckers<Output<this>>,
         ...DataParserRecordCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecord<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionRecord>(definition: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, GenericDefinition>>;
 }
 export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;

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

@@ -8,13 +8,11 @@ import { createOverride } from '../../../common/override.mjs';
 const recordKind = createDataParserKind("record");
 function record(key, value, definition) {
     const self = dataParserInit(recordKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            key,
-            value,
-            requireKey: findRecordRequiredKey(key),
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        key,
+        value,
+        requireKey: findRecordRequiredKey(key),
     }, {
         sync: (data, error, self) => {
             if (!data

package/dist/dataParser/parsers/recover.cjs

@@ -7,12 +7,10 @@ var override = require('../../common/override.cjs');
 const recoverKind = kind.createDataParserKind("recover");
 function recover(inner, recoveredValue, definition) {
     const self = base.dataParserInit(recoverKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            recoveredValue,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        recoveredValue,
     }, {
         sync: (data, error, self) => {
             const result = self.definition.inner.exec(data, error);

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

@@ -20,6 +20,7 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
         DataParserRecoverCheckers<Output<this>>,
         ...DataParserRecoverCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecover<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionRecover>(definition: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, GenericDefinition>>;
 }
 export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends Output<GenericDataParser>, const GenericDefinition extends Partial<Omit<DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;

package/dist/dataParser/parsers/recover.mjs

@@ -5,12 +5,10 @@ import { createOverride } from '../../common/override.mjs';
 const recoverKind = createDataParserKind("recover");
 function recover(inner, recoveredValue, definition) {
     const self = dataParserInit(recoverKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            recoveredValue,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        recoveredValue,
     }, {
         sync: (data, error, self) => {
             const result = self.definition.inner.exec(data, error);

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

@@ -8,11 +8,9 @@ var override = require('../../../common/override.cjs');
 const stringKind = kind.createDataParserKind("string");
 function string(definition) {
     const self = base.dataParserInit(stringKind, {
-        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/string/index.d.ts

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

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

@@ -6,11 +6,9 @@ import { createOverride } from '../../../common/override.mjs';
 const stringKind = createDataParserKind("string");
 function string(definition) {
     const self = dataParserInit(stringKind, {
-        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/templateLiteral/createTemplateLiteralPattern.cjs

@@ -11,13 +11,11 @@ var index$1 = require('../string/index.cjs');
 var union = require('../union.cjs');
 var innerPipe = require('../../../common/innerPipe.cjs');
 var regex = require('../string/checkers/regex.cjs');
-var when$1 = require('../../../common/when.cjs');
 var max = require('../string/checkers/max.cjs');
 var min = require('../string/checkers/min.cjs');
 var email = require('../string/checkers/email.cjs');
 var int = require('../number/checkers/int.cjs');
 var justReturn = require('../../../common/justReturn.cjs');
-var isType = require('../../../common/isType.cjs');
 var escapeRegExp = require('../../../common/escapeRegExp.cjs');
 var or = require('../../../common/or.cjs');
 var pipe = require('../../../common/pipe.cjs');
@@ -28,6 +26,8 @@ var replace = require('../../../string/replace.cjs');
 var exhaustive = require('../../../pattern/exhaustive.cjs');
 var to = require('../../../object/to.cjs');
 var find = require('../../../array/find.cjs');
+var when$1 = require('../../../common/when.cjs');
+var isType = require('../../../common/isType.cjs');
 
 function createTemplateLiteralPattern(templatePart) {
     return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when(or.or([

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.mjs

@@ -9,13 +9,11 @@ import { stringKind } from '../string/index.mjs';
 import { unionKind } from '../union.mjs';
 import { innerPipe } from '../../../common/innerPipe.mjs';
 import { checkerStringRegexKind } from '../string/checkers/regex.mjs';
-import { when as when$1 } from '../../../common/when.mjs';
 import { checkerStringMaxKind } from '../string/checkers/max.mjs';
 import { checkerStringMinKind } from '../string/checkers/min.mjs';
 import { checkerEmailKind } from '../string/checkers/email.mjs';
 import { checkerIntKind } from '../number/checkers/int.mjs';
 import { justReturn } from '../../../common/justReturn.mjs';
-import { isType } from '../../../common/isType.mjs';
 import { escapeRegExp } from '../../../common/escapeRegExp.mjs';
 import { or } from '../../../common/or.mjs';
 import { pipe } from '../../../common/pipe.mjs';
@@ -26,6 +24,8 @@ import { replace } from '../../../string/replace.mjs';
 import { exhaustive } from '../../../pattern/exhaustive.mjs';
 import { to } from '../../../object/to.mjs';
 import { find } from '../../../array/find.mjs';
+import { when as when$1 } from '../../../common/when.mjs';
+import { isType } from '../../../common/isType.mjs';
 
 function createTemplateLiteralPattern(templatePart) {
     return pipe(templatePart, map(innerPipe(when(or([

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

@@ -11,12 +11,10 @@ const templateLiteralKind = kind.createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
     const pattern = pipe.pipe(createTemplateLiteralPattern.createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
     const self = base.dataParserInit(templateLiteralKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            template,
-            pattern,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        template,
+        pattern,
     }, (data, _error, self) => {
         if (typeof data === "string" && self.definition.pattern.test(data)) {
             return data;

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

@@ -60,6 +60,7 @@ export interface DataParserTemplateLiteral<GenericDefinition extends DataParserD
         DataParserTemplateLiteralCheckers<Output<this>>,
         ...DataParserTemplateLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTemplateLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionTemplateLiteral>(definition: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, GenericDefinition>>;
 }
 export declare function templateLiteral<const GenericTemplate extends TemplateLiteralShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
     template: GenericTemplate;

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

@@ -9,12 +9,10 @@ const templateLiteralKind = createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
     const pattern = pipe(createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
     const self = dataParserInit(templateLiteralKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            template,
-            pattern,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        template,
+        pattern,
     }, (data, _error, self) => {
         if (typeof data === "string" && self.definition.pattern.test(data)) {
             return data;

package/dist/dataParser/parsers/transform.cjs

@@ -8,12 +8,10 @@ var override = require('../../common/override.cjs');
 const transformKind = kind.createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
     const self = base.dataParserInit(transformKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            theFunction,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        theFunction,
     }, {
         sync: (data, error$1, self) => {
             const innerResult = self.definition.inner.exec(data, error$1);

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

@@ -21,6 +21,7 @@ export interface DataParserTransform<GenericDefinition extends DataParserDefinit
         DataParserTransformCheckers<Output<this>>,
         ...DataParserTransformCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTransform<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionTransform>(definition: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, GenericDefinition>>;
 }
 export declare function transform<GenericDataParser extends DataParser, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;