@duplojs/utils 1.1.13 → 1.1.14

package/dist/dataParser/extended/number.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import { number as number$1 } from '../parsers/number/index.mjs';

package/dist/dataParser/extended/object.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 var object$1 = require('../parsers/object.cjs');

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

@@ -1,9 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type Output } from "../base";
 type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (dataParsers.DataParserObject<GenericDefinition> & DataParserExtended);
 export interface DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject = dataParsers.DataParserDefinitionObject> extends _DataParserObjectExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserObjectCheckers<Output<this>>,
+        ...dataParsers.DataParserObjectCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserObjectCheckers<Output<this>>,
+        ...dataParsers.DataParserObjectCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function object<const GenericShape extends dataParsers.DataParserObjectShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;

package/dist/dataParser/extended/object.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import { object as object$1 } from '../parsers/object.mjs';

package/dist/dataParser/extended/optional.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 require('../../pattern/result.cjs');

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

@@ -1,12 +1,22 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type DataParser } from "../base";
+import { type Output, type DataParser } from "../base";
 type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (dataParsers.DataParserOptional<GenericDefinition> & DataParserExtended);
 export interface DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional = dataParsers.DataParserDefinitionOptional> extends _DataParserOptionalExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserOptionalCheckers<Output<this>>,
+        ...dataParsers.DataParserOptionalCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserOptionalCheckers<Output<this>>,
+        ...dataParsers.DataParserOptionalCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserOptionalExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserOptionalExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/extended/optional.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import '../../pattern/result.mjs';

package/dist/dataParser/extended/pipe.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 require('../../pattern/result.cjs');

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

@@ -1,10 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type DataParser } from "../base";
+import { type Output, type DataParser } from "../base";
 type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (dataParsers.DataParserPipe<GenericDefinition> & DataParserExtended);
 export interface DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe = dataParsers.DataParserDefinitionPipe> extends _DataParserPipeExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserPipeCheckers<Output<this>>,
+        ...dataParsers.DataParserPipeCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserPipeCheckers<Output<this>>,
+        ...dataParsers.DataParserPipeCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserPipeExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserPipeExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;

package/dist/dataParser/extended/pipe.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import '../../pattern/result.mjs';

package/dist/dataParser/extended/record.cjs

@@ -1,13 +1,14 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 require('../../pattern/result.cjs');
-var record$1 = require('../parsers/record.cjs');
+var index = require('../parsers/record/index.cjs');
 
 function record(key, value, definition) {
-    return baseExtended.dataParserExtendedInit(record$1.record(key, value, definition), {});
+    return baseExtended.dataParserExtendedInit(index.record(key, value, definition), {});
 }
 
 exports.record = record;

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

@@ -1,10 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type DataParser } from "../base";
+import { type Output, type DataParser } from "../base";
 type _DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord> = (dataParsers.DataParserRecord<GenericDefinition> & DataParserExtended);
 export interface DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord = dataParsers.DataParserDefinitionRecord> extends _DataParserRecordExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserRecordCheckers<Output<this>>,
+        ...dataParsers.DataParserRecordCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserRecordCheckers<Output<this>>,
+        ...dataParsers.DataParserRecordCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserRecordExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserRecordExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function record<GenericDataParserKey extends dataParsers.DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecordExtended<MergeDefinition<dataParsers.DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;

package/dist/dataParser/extended/record.mjs

@@ -1,8 +1,9 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import '../../pattern/result.mjs';
-import { record as record$1 } from '../parsers/record.mjs';
+import { record as record$1 } from '../parsers/record/index.mjs';
 
 function record(key, value, definition) {
     return dataParserExtendedInit(record$1(key, value, definition), {});

package/dist/dataParser/extended/recover.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../pattern/result.cjs');
+var recover$1 = require('../parsers/recover.cjs');
+
+function recover(inner, recoveredValue, definition) {
+    return baseExtended.dataParserExtendedInit(recover$1.recover(inner, recoveredValue, definition), {});
+}
+
+exports.recover = recover;

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

@@ -0,0 +1,23 @@
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+import { type Output, type DataParser } from "../base";
+type _DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover> = (dataParsers.DataParserRecover<GenericDefinition> & DataParserExtended);
+export interface DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover = dataParsers.DataParserDefinitionRecover> extends _DataParserRecoverExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserRecoverCheckers<Output<this>>,
+        ...dataParsers.DataParserRecoverCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserRecoverCheckers<Output<this>>,
+        ...dataParsers.DataParserRecoverCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
+}
+export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+    recoveredValue: GenericRecoveredValue;
+}>>;
+export {};

package/dist/dataParser/extended/recover.mjs

@@ -0,0 +1,12 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../pattern/result.mjs';
+import { recover as recover$1 } from '../parsers/recover.mjs';
+
+function recover(inner, recoveredValue, definition) {
+    return dataParserExtendedInit(recover$1(inner, recoveredValue, definition), {});
+}
+
+export { recover };

package/dist/dataParser/extended/string.cjs

@@ -4,6 +4,7 @@ var baseExtended = require('../baseExtended.cjs');
 var index = require('../parsers/string/index.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
+require('../base.cjs');
 require('../../pattern/result.cjs');
 var email$1 = require('../parsers/string/checkers/email.cjs');
 var url$1 = require('../parsers/string/checkers/url.cjs');

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

@@ -1,13 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type Output } from "../base";
 type _DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString> = (dataParsers.DataParserString<GenericDefinition> & DataParserExtended);
 export interface DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString = dataParsers.DataParserDefinitionString> extends _DataParserStringExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserStringCheckers,
         ...dataParsers.DataParserStringCheckers[]
-    ]>(...args: GenericChecker): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserStringCheckers,
+        ...dataParsers.DataParserStringCheckers[]
+    ], GenericChecker>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMin, "min">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerStringMin
     ]>>;

package/dist/dataParser/extended/string.mjs

@@ -2,6 +2,7 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { string as string$1 } from '../parsers/string/index.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
+import '../base.mjs';
 import '../../pattern/result.mjs';
 import { checkerEmail } from '../parsers/string/checkers/email.mjs';
 import { checkerUrl } from '../parsers/string/checkers/url.mjs';

package/dist/dataParser/extended/templateLiteral.cjs

@@ -1,12 +1,14 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
-var templateLiteral$1 = require('../parsers/templateLiteral.cjs');
+var index = require('../parsers/templateLiteral/index.cjs');
+require('../../pattern/result.cjs');
 
 function templateLiteral(template, definition) {
-    return baseExtended.dataParserExtendedInit(templateLiteral$1.templateLiteral(template, definition), {});
+    return baseExtended.dataParserExtendedInit(index.templateLiteral(template, definition), {});
 }
 
 exports.templateLiteral = templateLiteral;

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

@@ -1,9 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type Output } from "../base";
 type _DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral> = (dataParsers.DataParserTemplateLiteral<GenericDefinition> & DataParserExtended);
 export interface DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral = dataParsers.DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteralExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserTemplateLiteralCheckers<Output<this>>,
+        ...dataParsers.DataParserTemplateLiteralCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserTemplateLiteralCheckers<Output<this>>,
+        ...dataParsers.DataParserTemplateLiteralCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function templateLiteral<const GenericTemplate extends dataParsers.TemplateLiteralShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
     template: GenericTemplate;

package/dist/dataParser/extended/templateLiteral.mjs

@@ -1,7 +1,9 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { templateLiteral as templateLiteral$1 } from '../parsers/templateLiteral.mjs';
+import { templateLiteral as templateLiteral$1 } from '../parsers/templateLiteral/index.mjs';
+import '../../pattern/result.mjs';
 
 function templateLiteral(template, definition) {
     return dataParserExtendedInit(templateLiteral$1(template, definition), {});

package/dist/dataParser/extended/transform.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 var transform$1 = require('../parsers/transform.cjs');

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

@@ -1,11 +1,21 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type DataParser, type Output } from "../base";
 import { type DataParserError } from "../error";
 type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (dataParsers.DataParserTransform<GenericDefinition> & DataParserExtended);
 export interface DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform = dataParsers.DataParserDefinitionTransform> extends _DataParserTransformExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserTransformCheckers<Output<this>>,
+        ...dataParsers.DataParserTransformCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserTransformCheckers<Output<this>>,
+        ...dataParsers.DataParserTransformCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function transform<GenericDataParser extends DataParser, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;

package/dist/dataParser/extended/transform.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import { transform as transform$1 } from '../parsers/transform.mjs';

package/dist/dataParser/extended/tuple.cjs

@@ -1,13 +1,23 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
+var min = require('../parsers/array/checkers/min.cjs');
+var max = require('../parsers/array/checkers/max.cjs');
 var tuple$1 = require('../parsers/tuple.cjs');
 require('../../pattern/result.cjs');
 
 function tuple(shape, definition) {
-    return baseExtended.dataParserExtendedInit(tuple$1.tuple(shape, definition), {});
+    return baseExtended.dataParserExtendedInit(tuple$1.tuple(shape, definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerArrayMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerArrayMax(max$1, definition));
+        },
+    });
 }
 
 exports.tuple = tuple;

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

@@ -1,9 +1,26 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type Output } from "../base";
 type _DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple> = (dataParsers.DataParserTuple<GenericDefinition> & DataParserExtended);
 export interface DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple = dataParsers.DataParserDefinitionTuple> extends _DataParserTupleExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserTupleCheckers<Output<this>>,
+        ...dataParsers.DataParserTupleCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserTupleCheckers<Output<this>>,
+        ...dataParsers.DataParserTupleCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
+    min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMin, "min">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerArrayMin
+    ]>>;
+    max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMax, "max">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerArrayMax
+    ]>>;
 }
 export declare function tuple<GenericShape extends dataParsers.TupleShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTupleExtended<MergeDefinition<dataParsers.DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;

package/dist/dataParser/extended/tuple.mjs

@@ -1,11 +1,21 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
+import { checkerArrayMin } from '../parsers/array/checkers/min.mjs';
+import { checkerArrayMax } from '../parsers/array/checkers/max.mjs';
 import { tuple as tuple$1 } from '../parsers/tuple.mjs';
 import '../../pattern/result.mjs';
 
 function tuple(shape, definition) {
-    return dataParserExtendedInit(tuple$1(shape, definition), {});
+    return dataParserExtendedInit(tuple$1(shape, definition), {
+        min(self, min, definition) {
+            return self.addChecker(checkerArrayMin(min, definition));
+        },
+        max(self, max, definition) {
+            return self.addChecker(checkerArrayMax(max, definition));
+        },
+    });
 }
 
 export { tuple };

package/dist/dataParser/extended/union.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 var union$1 = require('../parsers/union.cjs');

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

@@ -1,9 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type Output } from "../base";
 type _DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion> = (dataParsers.DataParserUnion<GenericDefinition> & DataParserExtended);
 export interface DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion = dataParsers.DataParserDefinitionUnion> extends _DataParserUnionExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserUnionCheckers<Output<this>>,
+        ...dataParsers.DataParserUnionCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserUnionCheckers<Output<this>>,
+        ...dataParsers.DataParserUnionCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserUnionExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserUnionExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function union<GenericOptions extends dataParsers.UnionOptions, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
     options: GenericOptions;

package/dist/dataParser/extended/union.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import { union as union$1 } from '../parsers/union.mjs';

package/dist/dataParser/extended/unknown.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
+require('../base.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 require('../../pattern/result.cjs');

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

@@ -1,9 +1,20 @@
-import { type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type Output } from "../base";
 type _DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown> = (dataParsers.DataParserUnknown<GenericDefinition> & DataParserExtended);
 export interface DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown = dataParsers.DataParserDefinitionUnknown> extends _DataParserUnknownExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserUnknownCheckers,
+        ...dataParsers.DataParserUnknownCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserUnknownCheckers,
+        ...dataParsers.DataParserUnknownCheckers[]
+    ], GenericChecker>): DataParserUnknownExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserUnknownExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function unknown<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknownExtended<MergeDefinition<dataParsers.DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
 export {};

package/dist/dataParser/extended/unknown.mjs

@@ -1,4 +1,5 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../base.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import '../../pattern/result.mjs';

package/dist/dataParser/identifier.cjs

@@ -1,10 +1,8 @@
 'use strict';
 
-var coalescing = require('../array/coalescing.cjs');
 require('../common/globalStore.cjs');
 require('../common/builder.cjs');
-var error = require('../either/left/error.cjs');
-var success = require('../either/right/success.cjs');
+var createKindIdentifier = require('../common/createKindIdentifier.cjs');
 
 /**
  * Due to the recursive typing of `DataParsers`, it can’t be used without
@@ -14,19 +12,6 @@ var success = require('../either/right/success.cjs');
  * starting from the parent type and the kinds associated with the data
  * parsers, the correct type can be retrieved.
  */
-function identifier(...args) {
-    if (args.length === 1) {
-        const [kind] = args;
-        return (input) => identifier(input, kind);
-    }
-    const [input, kind] = args;
-    const formattedKind = coalescing.coalescing(kind);
-    for (const kind of formattedKind) {
-        if (!kind.has(input)) {
-            return error.error(input);
-        }
-    }
-    return success.success(input);
-}
+const identifier = createKindIdentifier.createKindIdentifier();
 
 exports.identifier = identifier;