@duplojs/utils 1.1.12 → 1.1.14

package/dist/dataParser/extended/literal.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 _DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral> = (dataParsers.DataParserLiteral<GenericDefinition> & DataParserExtended);
 export interface DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral = dataParsers.DataParserDefinitionLiteral> extends _DataParserLiteralExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserLiteralCheckers<Output<this>>,
+        ...dataParsers.DataParserLiteralCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserLiteralCheckers<Output<this>>,
+        ...dataParsers.DataParserLiteralCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function literal<const GenericValue extends dataParsers.LiteralValue, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
     value: GenericValue[];

package/dist/dataParser/extended/literal.mjs

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

package/dist/dataParser/extended/nil.cjs

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

package/dist/dataParser/extended/nil.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 _DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil> = (dataParsers.DataParserNil<GenericDefinition> & DataParserExtended);
 export interface DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil = dataParsers.DataParserDefinitionNil> extends _DataParserNilExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserNilCheckers,
+        ...dataParsers.DataParserNilCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserNilCheckers,
+        ...dataParsers.DataParserNilCheckers[]
+    ], GenericChecker>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function nil<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
 export {};

package/dist/dataParser/extended/nil.mjs

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

package/dist/dataParser/extended/nullable.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/nullable.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 _DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable> = (dataParsers.DataParserNullable<GenericDefinition> & DataParserExtended);
 export interface DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable = dataParsers.DataParserDefinitionNullable> extends _DataParserNullableExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserNullableCheckers<Output<this>>,
+        ...dataParsers.DataParserNullableCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserNullableCheckers<Output<this>>,
+        ...dataParsers.DataParserNullableCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
-export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/extended/nullable.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/number.cjs

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

package/dist/dataParser/extended/number.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 _DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber> = (dataParsers.DataParserNumber<GenericDefinition> & DataParserExtended);
 export interface DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber = dataParsers.DataParserDefinitionNumber> extends _DataParserNumberExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserNumberCheckers,
         ...dataParsers.DataParserNumberCheckers[]
-    ]>(...args: GenericChecker): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserNumberCheckers,
+        ...dataParsers.DataParserNumberCheckers[]
+    ], GenericChecker>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionNumberMin, "min">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerNumberMin
     ]>>;

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;