@duplojs/utils 1.1.12 → 1.1.14

package/dist/dataParser/index.mjs

@@ -15,25 +15,29 @@ export { transform, transformKind } from './parsers/transform.mjs';
 export { nil, nilKind } from './parsers/nil.mjs';
 export { boolean, booleanKind } from './parsers/boolean.mjs';
 export { empty, emptyKind } from './parsers/empty.mjs';
-export { templateLiteral, templateLiteralKind } from './parsers/templateLiteral.mjs';
+export { templateLiteral, templateLiteralKind } from './parsers/templateLiteral/index.mjs';
 export { pipe, pipeKind } from './parsers/pipe.mjs';
 export { optional, optionalKind } from './parsers/optional.mjs';
 export { nullable, nullableKind } from './parsers/nullable.mjs';
 export { lazy, lazyKind } from './parsers/lazy.mjs';
 export { unknown, unknownKind } from './parsers/unknown.mjs';
-export { record, recordKind } from './parsers/record.mjs';
+export { record, recordKind } from './parsers/record/index.mjs';
+export { checkerRefine, dataParserCheckerRefineKind } from './parsers/refine.mjs';
+export { recover, recoverKind } from './parsers/recover.mjs';
 import * as index from './extended/index.mjs';
 export { index as extended };
 export { identifier } from './identifier.mjs';
-export { checkerUrl, dataParserCheckerUrlKind, url } from './parsers/string/checkers/url.mjs';
-export { checkerEmail, dataParserCheckerEmailKind, email } from './parsers/string/checkers/email.mjs';
-export { checkerStringMax, dataParserCheckerStringMaxKind } from './parsers/string/checkers/max.mjs';
-export { checkerStringMin, dataParserCheckerStringMinKind } from './parsers/string/checkers/min.mjs';
-export { checkerStringRegex, dataParserCheckerStringRegexKind } from './parsers/string/checkers/regex.mjs';
-export { checkerInt, dataParserCheckerIntKind, int } from './parsers/number/checkers/int.mjs';
-export { checkerNumberMin, dataParserCheckerNumberMinKind } from './parsers/number/checkers/min.mjs';
-export { checkerNumberMax, dataParserCheckerNumberMaxKind } from './parsers/number/checkers/max.mjs';
-export { checkerArrayMin, dataParserCheckerArrayMinKind } from './parsers/array/checkers/min.mjs';
-export { checkerArrayMax, dataParserCheckerArrayMaxKind } from './parsers/array/checkers/max.mjs';
-export { checkerBigIntMin, dataParserCheckerBigIntMinKind } from './parsers/bigint/checkers/min.mjs';
-export { checkerBigIntMax, dataParserCheckerBigIntMaxKind } from './parsers/bigint/checkers/max.mjs';
+export { checkerUrl, checkerUrlKind, url } from './parsers/string/checkers/url.mjs';
+export { checkerEmail, checkerEmailKind, email } from './parsers/string/checkers/email.mjs';
+export { checkerStringMax, checkerStringMaxKind } from './parsers/string/checkers/max.mjs';
+export { checkerStringMin, checkerStringMinKind } from './parsers/string/checkers/min.mjs';
+export { checkerStringRegex, checkerStringRegexKind } from './parsers/string/checkers/regex.mjs';
+export { checkerInt, checkerIntKind, int } from './parsers/number/checkers/int.mjs';
+export { checkerNumberMin, checkerNumberMinKind } from './parsers/number/checkers/min.mjs';
+export { checkerNumberMax, checkerNumberMaxKind } from './parsers/number/checkers/max.mjs';
+export { checkerArrayMin, checkerArrayMinKind } from './parsers/array/checkers/min.mjs';
+export { checkerArrayMax, checkerArrayMaxKind } from './parsers/array/checkers/max.mjs';
+export { checkerBigIntMin, checkerBigIntMinKind } from './parsers/bigint/checkers/min.mjs';
+export { checkerBigIntMax, checkerBigIntMaxKind } from './parsers/bigint/checkers/max.mjs';
+export { createTemplateLiteralPattern } from './parsers/templateLiteral/createTemplateLiteralPattern.mjs';
+export { findRecordRequiredKey, findRecordRequiredKeyOnTemplateLiteralPart } from './parsers/record/findRecordRequiredKey.mjs';

package/dist/dataParser/parsers/array/checkers/max.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerArrayMaxKind = kind.createDataParserKind("checker-array-max");
+const checkerArrayMaxKind = kind.createDataParserKind("checker-array-max");
 function checkerArrayMax(max, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerArrayMaxKind, {
+    return base.dataParserCheckerInit(checkerArrayMaxKind, {
         definition: {
             ...definition,
             max,
@@ -20,4 +20,4 @@ function checkerArrayMax(max, definition = {}) {
 }
 
 exports.checkerArrayMax = checkerArrayMax;
-exports.dataParserCheckerArrayMaxKind = dataParserCheckerArrayMaxKind;
+exports.checkerArrayMaxKind = checkerArrayMaxKind;

package/dist/dataParser/parsers/array/checkers/max.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionArrayMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerArrayMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-array-max", unknown>>;
-type _DataParserCheckerArrayMax = (Kind<typeof dataParserCheckerArrayMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMax, unknown[]>);
+export declare const checkerArrayMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-array-max", unknown>>;
+type _DataParserCheckerArrayMax = (Kind<typeof checkerArrayMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMax, unknown[]>);
 export interface DataParserCheckerArrayMax extends _DataParserCheckerArrayMax {
 }
 export declare function checkerArrayMax(max: number, definition?: Partial<Omit<DataParserCheckerDefinitionArrayMax, "max">>): DataParserCheckerArrayMax;

package/dist/dataParser/parsers/array/checkers/max.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerArrayMaxKind = createDataParserKind("checker-array-max");
+const checkerArrayMaxKind = createDataParserKind("checker-array-max");
 function checkerArrayMax(max, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerArrayMaxKind, {
+    return dataParserCheckerInit(checkerArrayMaxKind, {
         definition: {
             ...definition,
             max,
@@ -17,4 +17,4 @@ function checkerArrayMax(max, definition = {}) {
     });
 }
 
-export { checkerArrayMax, dataParserCheckerArrayMaxKind };
+export { checkerArrayMax, checkerArrayMaxKind };

package/dist/dataParser/parsers/array/checkers/min.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerArrayMinKind = kind.createDataParserKind("checker-array-min");
+const checkerArrayMinKind = kind.createDataParserKind("checker-array-min");
 function checkerArrayMin(min, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerArrayMinKind, {
+    return base.dataParserCheckerInit(checkerArrayMinKind, {
         definition: {
             ...definition,
             min,
@@ -20,4 +20,4 @@ function checkerArrayMin(min, definition = {}) {
 }
 
 exports.checkerArrayMin = checkerArrayMin;
-exports.dataParserCheckerArrayMinKind = dataParserCheckerArrayMinKind;
+exports.checkerArrayMinKind = checkerArrayMinKind;

package/dist/dataParser/parsers/array/checkers/min.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionArrayMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerArrayMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-array-min", unknown>>;
-type _DataParserCheckerArrayMin = (Kind<typeof dataParserCheckerArrayMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMin, unknown[]>);
+export declare const checkerArrayMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-array-min", unknown>>;
+type _DataParserCheckerArrayMin = (Kind<typeof checkerArrayMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMin, unknown[]>);
 export interface DataParserCheckerArrayMin extends _DataParserCheckerArrayMin {
 }
 export declare function checkerArrayMin(min: number, definition?: Partial<Omit<DataParserCheckerDefinitionArrayMin, "min">>): DataParserCheckerArrayMin;

package/dist/dataParser/parsers/array/checkers/min.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerArrayMinKind = createDataParserKind("checker-array-min");
+const checkerArrayMinKind = createDataParserKind("checker-array-min");
 function checkerArrayMin(min, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerArrayMinKind, {
+    return dataParserCheckerInit(checkerArrayMinKind, {
         definition: {
             ...definition,
             min,
@@ -17,4 +17,4 @@ function checkerArrayMin(min, definition = {}) {
     });
 }
 
-export { checkerArrayMin, dataParserCheckerArrayMinKind };
+export { checkerArrayMin, checkerArrayMinKind };

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

@@ -1,19 +1,26 @@
-import { type NeverCoalescing, type Kind } from "../../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../../base";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserCheckerArrayMin, type DataParserCheckerArrayMax } from "./checkers";
+import { type CheckerRefineImplementation } from "../refine";
+import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./checkers";
-export type DataParserArrayCheckers = (DataParserCheckerArrayMin | DataParserCheckerArrayMax);
-export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers> {
+export interface DataParserArrayCheckerCustom<GenericInput extends unknown[] = unknown[]> {
+}
+export type DataParserArrayCheckers<GenericInput extends unknown[] = unknown[]> = (DataParserArrayCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserArrayCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionArray extends DataParserDefinition {
     readonly element: DataParser;
 }
 export declare const arrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>>;
 type _DataParserArray<GenericDefinition extends DataParserDefinitionArray> = (DataParser<GenericDefinition, Output<GenericDefinition["element"]>[], Input<GenericDefinition["element"]>[]> & Kind<typeof arrayKind.definition>);
 export interface DataParserArray<GenericDefinition extends DataParserDefinitionArray = DataParserDefinitionArray> extends _DataParserArray<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
-        DataParserArrayCheckers,
-        ...DataParserArrayCheckers[]
-    ]>(...args: GenericChecker): DataParserArray<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+        DataParserArrayCheckers<Output<this>>,
+        ...DataParserArrayCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserArrayCheckers<Output<this>>,
+        ...DataParserArrayCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserArray<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function array<GenericElement extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
     element: GenericElement;

package/dist/dataParser/parsers/bigint/checkers/max.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerBigIntMaxKind = kind.createDataParserKind("checker-bigint-max");
+const checkerBigIntMaxKind = kind.createDataParserKind("checker-bigint-max");
 function checkerBigIntMax(max, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerBigIntMaxKind, {
+    return base.dataParserCheckerInit(checkerBigIntMaxKind, {
         definition: {
             ...definition,
             max,
@@ -20,4 +20,4 @@ function checkerBigIntMax(max, definition = {}) {
 }
 
 exports.checkerBigIntMax = checkerBigIntMax;
-exports.dataParserCheckerBigIntMaxKind = dataParserCheckerBigIntMaxKind;
+exports.checkerBigIntMaxKind = checkerBigIntMaxKind;

package/dist/dataParser/parsers/bigint/checkers/max.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionBigIntMax extends DataParserCheckerDefinition {
     max: bigint;
 }
-export declare const dataParserCheckerBigIntMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-bigint-max", unknown>>;
-type _DataParserCheckerBigIntMax = (Kind<typeof dataParserCheckerBigIntMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionBigIntMax, bigint>);
+export declare const checkerBigIntMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-bigint-max", unknown>>;
+type _DataParserCheckerBigIntMax = (Kind<typeof checkerBigIntMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionBigIntMax, bigint>);
 export interface DataParserCheckerBigIntMax extends _DataParserCheckerBigIntMax {
 }
 export declare function checkerBigIntMax(max: bigint, definition?: Partial<Omit<DataParserCheckerDefinitionBigIntMax, "max">>): DataParserCheckerBigIntMax;

package/dist/dataParser/parsers/bigint/checkers/max.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerBigIntMaxKind = createDataParserKind("checker-bigint-max");
+const checkerBigIntMaxKind = createDataParserKind("checker-bigint-max");
 function checkerBigIntMax(max, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerBigIntMaxKind, {
+    return dataParserCheckerInit(checkerBigIntMaxKind, {
         definition: {
             ...definition,
             max,
@@ -17,4 +17,4 @@ function checkerBigIntMax(max, definition = {}) {
     });
 }
 
-export { checkerBigIntMax, dataParserCheckerBigIntMaxKind };
+export { checkerBigIntMax, checkerBigIntMaxKind };

package/dist/dataParser/parsers/bigint/checkers/min.cjs

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerBigIntMinKind = kind.createDataParserKind("checker-bigint-min");
+const checkerBigIntMinKind = kind.createDataParserKind("checker-bigint-min");
 function checkerBigIntMin(min, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerBigIntMinKind, {
+    return base.dataParserCheckerInit(checkerBigIntMinKind, {
         definition: {
             ...definition,
             min,
@@ -20,4 +20,4 @@ function checkerBigIntMin(min, definition = {}) {
 }
 
 exports.checkerBigIntMin = checkerBigIntMin;
-exports.dataParserCheckerBigIntMinKind = dataParserCheckerBigIntMinKind;
+exports.checkerBigIntMinKind = checkerBigIntMinKind;

package/dist/dataParser/parsers/bigint/checkers/min.d.ts

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionBigIntMin extends DataParserCheckerDefinition {
     min: bigint;
 }
-export declare const dataParserCheckerBigIntMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-bigint-min", unknown>>;
-type _DataParserCheckerBigIntMin = (Kind<typeof dataParserCheckerBigIntMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionBigIntMin, bigint>);
+export declare const checkerBigIntMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-bigint-min", unknown>>;
+type _DataParserCheckerBigIntMin = (Kind<typeof checkerBigIntMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionBigIntMin, bigint>);
 export interface DataParserCheckerBigIntMin extends _DataParserCheckerBigIntMin {
 }
 export declare function checkerBigIntMin(min: bigint, definition?: Partial<Omit<DataParserCheckerDefinitionBigIntMin, "min">>): DataParserCheckerBigIntMin;

package/dist/dataParser/parsers/bigint/checkers/min.mjs

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerBigIntMinKind = createDataParserKind("checker-bigint-min");
+const checkerBigIntMinKind = createDataParserKind("checker-bigint-min");
 function checkerBigIntMin(min, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerBigIntMinKind, {
+    return dataParserCheckerInit(checkerBigIntMinKind, {
         definition: {
             ...definition,
             min,
@@ -17,4 +17,4 @@ function checkerBigIntMin(min, definition = {}) {
     });
 }
 
-export { checkerBigIntMin, dataParserCheckerBigIntMinKind };
+export { checkerBigIntMin, checkerBigIntMinKind };

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

@@ -1,9 +1,13 @@
-import { type NeverCoalescing, type Kind } from "../../../common";
-import { type DataParserDefinition, type DataParser } from "../../base";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserCheckerBigIntMin, type DataParserCheckerBigIntMax } from "./checkers";
+import { type CheckerRefineImplementation } from "../refine";
+import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./checkers";
-export type DataParserBigIntCheckers = (DataParserCheckerBigIntMin | DataParserCheckerBigIntMax);
+export interface DataParserBigIntCheckerCustom {
+}
+export type DataParserBigIntCheckers = (DataParserBigIntCheckerCustom[GetPropsWithValueExtends<DataParserBigIntCheckerCustom, DataParserChecker>] | DataParserCheckerBigIntMin | DataParserCheckerBigIntMax | CheckerRefineImplementation<bigint>);
 export interface DataParserDefinitionBigInt extends DataParserDefinition<DataParserBigIntCheckers> {
     readonly coerce: boolean;
 }
@@ -13,6 +17,9 @@ export interface DataParserBigInt<GenericDefinition extends DataParserDefinition
     addChecker<GenericChecker extends readonly [
         DataParserBigIntCheckers,
         ...DataParserBigIntCheckers[]
-    ]>(...args: GenericChecker): DataParserBigInt<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserBigIntCheckers,
+        ...DataParserBigIntCheckers[]
+    ], GenericChecker>): DataParserBigInt<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function bigint<const GenericDefinition extends Partial<DataParserDefinitionBigInt> = never>(definition?: GenericDefinition): DataParserBigInt<MergeDefinition<DataParserDefinitionBigInt, NeverCoalescing<GenericDefinition, {}>>>;

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

@@ -1,12 +1,24 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionBoolean extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserBooleanCheckerCustom {
+}
+export type DataParserBooleanCheckers = (DataParserBooleanCheckerCustom[GetPropsWithValueExtends<DataParserBooleanCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<boolean>);
+export interface DataParserDefinitionBoolean extends DataParserDefinition<DataParserBooleanCheckers> {
     readonly coerce: boolean;
 }
 export declare const booleanKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>>;
 type _DataParserBoolean<GenericDefinition extends DataParserDefinitionBoolean> = (DataParser<GenericDefinition, boolean, boolean> & Kind<typeof booleanKind.definition>);
 export interface DataParserBoolean<GenericDefinition extends DataParserDefinitionBoolean = DataParserDefinitionBoolean> extends _DataParserBoolean<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserBooleanCheckers,
+        ...DataParserBooleanCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserBooleanCheckers,
+        ...DataParserBooleanCheckers[]
+    ], GenericChecker>): DataParserBoolean<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function boolean<const GenericDefinition extends Partial<DataParserDefinitionBoolean> = never>(definition?: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}>>>;
 export {};

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

@@ -1,5 +1,6 @@
 'use strict';
 
+require('../../base.cjs');
 require('../../../common/globalStore.cjs');
 require('../../../common/builder.cjs');
 var index = require('../bigint/index.cjs');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,12 +1,24 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionEmpty extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserEmptyCheckerCustom {
+}
+export type DataParserEmptyCheckers = (DataParserEmptyCheckerCustom[GetPropsWithValueExtends<DataParserEmptyCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<undefined>);
+export interface DataParserDefinitionEmpty extends DataParserDefinition<DataParserEmptyCheckers> {
     readonly coerce: boolean;
 }
 export declare const emptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>>;
 type _DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty> = (DataParser<GenericDefinition, undefined, undefined> & Kind<typeof emptyKind.definition>);
 export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty = DataParserDefinitionEmpty> extends _DataParserEmpty<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserEmptyCheckers,
+        ...DataParserEmptyCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserEmptyCheckers,
+        ...DataParserEmptyCheckers[]
+    ], GenericChecker>): DataParserEmpty<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
 export {};

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

@@ -18,3 +18,5 @@ export * from "./nullable";
 export * from "./lazy";
 export * from "./unknown";
 export * from "./record";
+export * from "./refine";
+export * from "./recover";

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

@@ -1,12 +1,24 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionLazy extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserLazyCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserLazyCheckers<GenericInput extends unknown = unknown> = (DataParserLazyCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLazyCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers> {
     getter(): DataParser;
 }
 export declare const lazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;
 type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<ReturnType<GenericDefinition["getter"]>>, Input<ReturnType<GenericDefinition["getter"]>>> & Kind<typeof lazyKind.definition>);
 export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLazy = DataParserDefinitionLazy> extends _DataParserLazy<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserLazyCheckers<Output<this>>,
+        ...DataParserLazyCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserLazyCheckers<Output<this>>,
+        ...DataParserLazyCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserLazy<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter(): GenericDataParser;

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

@@ -1,13 +1,25 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
 export type LiteralValue = string | number | bigint | undefined | null | boolean;
-export interface DataParserDefinitionLiteral extends DataParserDefinition<never> {
+export interface DataParserLiteralCheckerCustom<GenericInput extends LiteralValue = LiteralValue> {
+}
+export type DataParserLiteralCheckers<GenericInput extends LiteralValue = LiteralValue> = (DataParserLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionLiteral extends DataParserDefinition<DataParserLiteralCheckers> {
     readonly value: LiteralValue[];
 }
 export declare const literalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>>;
 type _DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral> = (DataParser<GenericDefinition, GenericDefinition["value"][number], GenericDefinition["value"][number]> & Kind<typeof literalKind.definition>);
 export interface DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral = DataParserDefinitionLiteral> extends _DataParserLiteral<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserLiteralCheckers<Output<this>>,
+        ...DataParserLiteralCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserLiteralCheckers<Output<this>>,
+        ...DataParserLiteralCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
     value: GenericValue[];

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

@@ -1,12 +1,24 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionNil extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserNilCheckerCustom {
+}
+export type DataParserNilCheckers = (DataParserNilCheckerCustom[GetPropsWithValueExtends<DataParserNilCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<null>);
+export interface DataParserDefinitionNil extends DataParserDefinition<DataParserNilCheckers> {
     readonly coerce: boolean;
 }
 export declare const nilKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>>;
 type _DataParserNil<GenericDefinition extends DataParserDefinitionNil> = (DataParser<GenericDefinition, null, null> & Kind<typeof nilKind.definition>);
 export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil = DataParserDefinitionNil> extends _DataParserNil<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserNilCheckers,
+        ...DataParserNilCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserNilCheckers,
+        ...DataParserNilCheckers[]
+    ], GenericChecker>): DataParserNil<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function nil<const GenericDefinition extends Partial<DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
 export {};

package/dist/dataParser/parsers/nullable.cjs

@@ -10,17 +10,18 @@ function nullable(inner, definition) {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
             inner,
+            coalescingValue: definition?.coalescingValue ?? null,
         },
     }, {
         sync: (data, error, self) => {
             if (data === null) {
-                return data;
+                return self.definition.coalescingValue;
             }
             return self.definition.inner.exec(data, error);
         },
         async: async (data, error, self) => {
             if (data === null) {
-                return data;
+                return self.definition.coalescingValue;
             }
             return self.definition.inner.asyncExec(data, error);
         },