@duplojs/utils 1.1.13 → 1.1.15

package/dist/dataParser/base.mjs

@@ -1,9 +1,10 @@
 import { simpleClone } from '../common/simpleClone.mjs';
+import { keyWrappedValue } from '../common/wrapValue.mjs';
 import '../common/globalStore.mjs';
 import '../common/builder.mjs';
-import { createError, SymbolDataParserErrorIssue, addIssue, SymbolDataParserErrorPromiseIssue, addPromiseIssue } from './error.mjs';
 import { error } from '../either/left/error.mjs';
 import { success } from '../either/right/success.mjs';
+import { createError, addIssue, addPromiseIssue, SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from './error.mjs';
 import { createDataParserKind } from './kind.mjs';
 
 const SymbolDataParserErrorLabel = "SymbolDataParserError";
@@ -16,6 +17,14 @@ function dataParserCheckerInit(kind, params, exec) {
     }));
 }
 const dataParserKind = createDataParserKind("base");
+// This allows for better performance WTF ???
+const SDPEI = SymbolDataParserErrorIssue;
+const SDPEPI = SymbolDataParserErrorPromiseIssue;
+const SDPE = SymbolDataParserError;
+const DPE = createError();
+const EE = error(null);
+const ES = success(null);
+const KWV = keyWrappedValue;
 function dataParserInit(kind, params, exec) {
     const formattedExec = typeof exec === "object"
         ? exec
@@ -25,21 +34,21 @@ function dataParserInit(kind, params, exec) {
         };
     function middleExec(data, error) {
         let result = formattedExec.sync(data, error, dataParser);
-        if (result === SymbolDataParserErrorIssue) {
+        if (result === SDPEI) {
             addIssue(error, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result === SymbolDataParserErrorPromiseIssue) {
+        else if (result === SDPEPI) {
             addPromiseIssue(error, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result !== SymbolDataParserError
+        else if (result !== SDPE
             && dataParser.definition.checkers.length) {
             for (const checker of dataParser.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
-                if (checkerResult === SymbolDataParserErrorIssue) {
+                if (checkerResult === SDPEI) {
                     addIssue(error, checker, result);
-                    return SymbolDataParserError;
+                    return SDPE;
                 }
                 else {
                     result = checkerResult;
@@ -50,21 +59,21 @@ function dataParserInit(kind, params, exec) {
     }
     async function middleAsyncExec(data, error) {
         let result = await formattedExec.async(data, error, dataParser);
-        if (result === SymbolDataParserErrorIssue) {
+        if (result === SDPEI) {
             addIssue(error, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result === SymbolDataParserErrorPromiseIssue) {
+        else if (result === SDPEPI) {
             addPromiseIssue(error, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result !== SymbolDataParserError
+        else if (result !== SDPE
             && dataParser.definition.checkers.length) {
             for (const checker of dataParser.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
-                if (checkerResult === SymbolDataParserErrorIssue) {
+                if (checkerResult === SDPEI) {
                     addIssue(error, checker, result);
-                    return SymbolDataParserError;
+                    return SDPE;
                 }
                 else {
                     result = checkerResult;
@@ -78,20 +87,40 @@ function dataParserInit(kind, params, exec) {
         exec: middleExec,
         asyncExec: middleAsyncExec,
         parse(data) {
-            const error$1 = createError();
-            const result = middleExec(data, error$1);
-            if (result === SymbolDataParserError) {
-                return error(error$1);
+            const error = {
+                ...DPE,
+                issues: [],
+                currentPath: [],
+            };
+            const result = middleExec(data, error);
+            if (result === SDPE) {
+                return {
+                    ...EE,
+                    [KWV]: error,
+                };
             }
-            return success(result);
+            return {
+                ...ES,
+                [KWV]: result,
+            };
         },
         async asyncParse(data) {
-            const error$1 = createError();
-            const result = await middleAsyncExec(data, error$1);
-            if (result === SymbolDataParserError) {
-                return error(error$1);
+            const error = {
+                ...DPE,
+                issues: [],
+                currentPath: [],
+            };
+            const result = await middleAsyncExec(data, error);
+            if (result === SDPE) {
+                return {
+                    ...EE,
+                    [KWV]: error,
+                };
             }
-            return success(result);
+            return {
+                ...ES,
+                [KWV]: result,
+            };
         },
         addChecker: (...checkers) => dataParserInit(kind, simpleClone({
             ...params,
@@ -101,10 +130,7 @@ function dataParserInit(kind, params, exec) {
             },
         }), exec),
         clone: () => dataParserInit(kind, simpleClone(params), exec),
-    }, {
-        output: undefined,
-        input: undefined,
-    }));
+    }, null));
     return dataParser;
 }
 

package/dist/dataParser/baseExtended.cjs

@@ -7,14 +7,17 @@ var entry = require('../object/entry.cjs');
 var map = require('../array/map.cjs');
 require('../common/globalStore.cjs');
 require('../common/builder.cjs');
+require('./base.cjs');
 var kind = require('./kind.cjs');
 require('../pattern/result.cjs');
+var refine = require('./parsers/refine.cjs');
 var array = require('./extended/array.cjs');
 var transform = require('./extended/transform.cjs');
 var union = require('./extended/union.cjs');
 var nullable = require('./extended/nullable.cjs');
 var optional = require('./extended/optional.cjs');
 var pipe$1 = require('./extended/pipe.cjs');
+var recover = require('./extended/recover.cjs');
 
 const extendedKind = kind.createDataParserKind("extended");
 function dataParserExtendedInit(dataParser, rest) {
@@ -47,8 +50,18 @@ function dataParserExtendedInit(dataParser, rest) {
         or(option, definition) {
             return union.union([self, option], definition);
         },
-        addChecker: (...checkers) => dataParserExtendedInit(dataParser.addChecker(...checkers), rest),
-        clone: () => dataParserExtendedInit(dataParser.clone(), rest),
+        addChecker(...checkers) {
+            return dataParserExtendedInit(dataParser.addChecker(...checkers), rest);
+        },
+        clone() {
+            return dataParserExtendedInit(dataParser.clone(), rest);
+        },
+        refine(theFunction) {
+            return dataParserExtendedInit(dataParser.addChecker(refine.checkerRefine(theFunction)), rest);
+        },
+        recover(recoveredValue, definition) {
+            return recover.recover(self, recoveredValue, definition);
+        },
     });
     return self;
 }

package/dist/dataParser/baseExtended.d.ts

@@ -1,7 +1,7 @@
 import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue } from "../common";
 import { type MergeDefinition } from "./types";
 import { type Output, type DataParser } from "./base";
-import type * as dataParsers from "./parsers";
+import * as dataParsers from "./parsers";
 import * as dataParsersExtended from "./extended";
 import { type DataParserError } from "./error";
 export declare const extendedKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>>;
@@ -29,15 +29,20 @@ export interface DataParserExtended extends _DataParserExtended {
         input: GenericThis;
         output: GenericOutput;
     }>>;
-    nullable<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+    nullable<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericThis> | null>, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
         inner: GenericThis;
     }>>;
-    optional<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+    optional<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericThis> | undefined>, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
         inner: GenericThis;
     }>>;
     or<GenericThis extends this = this, GenericDataParser extends DataParser = DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(option: GenericDataParser, definition?: GenericDefinition): dataParsersExtended.DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
         options: [GenericThis, GenericDataParser];
     }>>;
+    refine(...args: never): DataParserExtended;
+    recover<GenericThis extends this = this, GenericRecoveredValue extends unknown = unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): dataParsersExtended.DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
+        inner: GenericThis;
+        recoveredValue: GenericRecoveredValue;
+    }>>;
 }
 export declare function dataParserExtendedInit<GenericDataParser extends DataParser, GenericDataParserExtended extends GenericDataParser & DataParserExtended>(dataParser: NoInfer<GenericDataParser>, rest: NoInfer<{
     [Prop in Exclude<keyof GenericDataParserExtended, keyof (GenericDataParser & DataParserExtended)>]: GenericDataParserExtended[Prop] extends AnyFunction ? (self: GenericDataParserExtended, ...args: Parameters<GenericDataParserExtended[Prop]>) => ReturnType<GenericDataParserExtended[Prop]> : GenericDataParserExtended[Prop];

package/dist/dataParser/baseExtended.mjs

@@ -5,14 +5,17 @@ import { entry } from '../object/entry.mjs';
 import { map } from '../array/map.mjs';
 import '../common/globalStore.mjs';
 import '../common/builder.mjs';
+import './base.mjs';
 import { createDataParserKind } from './kind.mjs';
 import '../pattern/result.mjs';
+import { checkerRefine } from './parsers/refine.mjs';
 import { array } from './extended/array.mjs';
 import { transform } from './extended/transform.mjs';
 import { union } from './extended/union.mjs';
 import { nullable } from './extended/nullable.mjs';
 import { optional } from './extended/optional.mjs';
 import { pipe as pipe$1 } from './extended/pipe.mjs';
+import { recover } from './extended/recover.mjs';
 
 const extendedKind = createDataParserKind("extended");
 function dataParserExtendedInit(dataParser, rest) {
@@ -45,8 +48,18 @@ function dataParserExtendedInit(dataParser, rest) {
         or(option, definition) {
             return union([self, option], definition);
         },
-        addChecker: (...checkers) => dataParserExtendedInit(dataParser.addChecker(...checkers), rest),
-        clone: () => dataParserExtendedInit(dataParser.clone(), rest),
+        addChecker(...checkers) {
+            return dataParserExtendedInit(dataParser.addChecker(...checkers), rest);
+        },
+        clone() {
+            return dataParserExtendedInit(dataParser.clone(), rest);
+        },
+        refine(theFunction) {
+            return dataParserExtendedInit(dataParser.addChecker(checkerRefine(theFunction)), rest);
+        },
+        recover(recoveredValue, definition) {
+            return recover(self, recoveredValue, definition);
+        },
     });
     return self;
 }

package/dist/dataParser/extended/array.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/array/index.cjs');

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

@@ -1,14 +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 DataParser } from "../base";
+import { type Output, type DataParser } from "../base";
 type _DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray> = (dataParsers.DataParserArray<GenericDefinition> & DataParserExtended);
 export interface DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray = dataParsers.DataParserDefinitionArray> extends _DataParserArrayExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
-        dataParsers.DataParserArrayCheckers,
-        ...dataParsers.DataParserArrayCheckers[]
-    ]>(...args: GenericChecker): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+        dataParsers.DataParserArrayCheckers<Output<this>>,
+        ...dataParsers.DataParserArrayCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserArrayCheckers<Output<this>>,
+        ...dataParsers.DataParserArrayCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMin, "min">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerArrayMin
     ]>>;

package/dist/dataParser/extended/array.mjs

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

package/dist/dataParser/extended/bigint.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/bigint/index.cjs');

package/dist/dataParser/extended/bigint.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 _DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt> = (dataParsers.DataParserBigInt<GenericDefinition> & DataParserExtended);
 export interface DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt = dataParsers.DataParserDefinitionBigInt> extends _DataParserBigIntExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserBigIntCheckers,
         ...dataParsers.DataParserBigIntCheckers[]
-    ]>(...args: GenericChecker): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserBigIntCheckers,
+        ...dataParsers.DataParserBigIntCheckers[]
+    ], GenericChecker>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
     min(min: bigint, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionBigIntMin, "min">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerBigIntMin
     ]>>;

package/dist/dataParser/extended/bigint.mjs

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

package/dist/dataParser/extended/boolean.cjs

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

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

package/dist/dataParser/extended/boolean.mjs

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

package/dist/dataParser/extended/coerce/bigint.cjs

@@ -2,6 +2,7 @@
 
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
+require('../../base.cjs');
 require('../../../pattern/result.cjs');
 var bigint$1 = require('../bigint.cjs');
 

package/dist/dataParser/extended/coerce/bigint.mjs

@@ -1,5 +1,6 @@
 import '../../../common/globalStore.mjs';
 import '../../../common/builder.mjs';
+import '../../base.mjs';
 import '../../../pattern/result.mjs';
 import { bigint as bigint$1 } from '../bigint.mjs';
 

package/dist/dataParser/extended/coerce/boolean.cjs

@@ -2,6 +2,7 @@
 
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
+require('../../base.cjs');
 require('../../../pattern/result.cjs');
 var boolean$1 = require('../boolean.cjs');
 

package/dist/dataParser/extended/coerce/boolean.mjs

@@ -1,5 +1,6 @@
 import '../../../common/globalStore.mjs';
 import '../../../common/builder.mjs';
+import '../../base.mjs';
 import '../../../pattern/result.mjs';
 import { boolean as boolean$1 } from '../boolean.mjs';
 

package/dist/dataParser/extended/coerce/empty.cjs

@@ -2,6 +2,7 @@
 
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
+require('../../base.cjs');
 require('../../../pattern/result.cjs');
 var empty$1 = require('../empty.cjs');
 

package/dist/dataParser/extended/coerce/empty.mjs

@@ -1,5 +1,6 @@
 import '../../../common/globalStore.mjs';
 import '../../../common/builder.mjs';
+import '../../base.mjs';
 import '../../../pattern/result.mjs';
 import { empty as empty$1 } from '../empty.mjs';
 

package/dist/dataParser/extended/coerce/nil.cjs

@@ -2,6 +2,7 @@
 
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
+require('../../base.cjs');
 require('../../../pattern/result.cjs');
 var nil$1 = require('../nil.cjs');
 

package/dist/dataParser/extended/coerce/nil.mjs

@@ -1,5 +1,6 @@
 import '../../../common/globalStore.mjs';
 import '../../../common/builder.mjs';
+import '../../base.mjs';
 import '../../../pattern/result.mjs';
 import { nil as nil$1 } from '../nil.mjs';
 

package/dist/dataParser/extended/coerce/number.cjs

@@ -2,6 +2,7 @@
 
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
+require('../../base.cjs');
 require('../../../pattern/result.cjs');
 var number$1 = require('../number.cjs');
 

package/dist/dataParser/extended/coerce/number.mjs

@@ -1,5 +1,6 @@
 import '../../../common/globalStore.mjs';
 import '../../../common/builder.mjs';
+import '../../base.mjs';
 import '../../../pattern/result.mjs';
 import { number as number$1 } from '../number.mjs';
 

package/dist/dataParser/extended/coerce/string.cjs

@@ -3,6 +3,7 @@
 var string$1 = require('../string.cjs');
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
+require('../../base.cjs');
 require('../../../pattern/result.cjs');
 
 function string(definition) {

package/dist/dataParser/extended/coerce/string.mjs

@@ -1,6 +1,7 @@
 import { string as string$1 } from '../string.mjs';
 import '../../../common/globalStore.mjs';
 import '../../../common/builder.mjs';
+import '../../base.mjs';
 import '../../../pattern/result.mjs';
 
 function string(definition) {

package/dist/dataParser/extended/empty.cjs

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

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

package/dist/dataParser/extended/empty.mjs

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

package/dist/dataParser/extended/index.cjs

@@ -20,6 +20,7 @@ var record = require('./record.cjs');
 var templateLiteral = require('./templateLiteral.cjs');
 var tuple = require('./tuple.cjs');
 var unknown = require('./unknown.cjs');
+var recover = require('./recover.cjs');
 
 
 
@@ -46,3 +47,4 @@ exports.record = record.record;
 exports.templateLiteral = templateLiteral.templateLiteral;
 exports.tuple = tuple.tuple;
 exports.unknown = unknown.unknown;
+exports.recover = recover.recover;

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

@@ -20,3 +20,4 @@ export * from "./transform";
 export * from "./tuple";
 export * from "./union";
 export * from "./unknown";
+export * from "./recover";

package/dist/dataParser/extended/index.mjs

@@ -19,3 +19,4 @@ export { record } from './record.mjs';
 export { templateLiteral } from './templateLiteral.mjs';
 export { tuple } from './tuple.mjs';
 export { unknown } from './unknown.mjs';
+export { recover } from './recover.mjs';

package/dist/dataParser/extended/lazy.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/lazy.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 _DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy> = (dataParsers.DataParserLazy<GenericDefinition> & DataParserExtended);
 export interface DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy = dataParsers.DataParserDefinitionLazy> extends _DataParserLazyExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserLazyCheckers<Output<this>>,
+        ...dataParsers.DataParserLazyCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserLazyCheckers<Output<this>>,
+        ...dataParsers.DataParserLazyCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
 }
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter(): GenericDataParser;

package/dist/dataParser/extended/lazy.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/literal.cjs

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