@duplojs/utils 1.1.13 → 1.1.14

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');

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
     ]>>;