@duplojs/utils 1.1.13 → 1.1.14

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);
         },

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

@@ -1,14 +1,27 @@
-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 DataParserDefinitionNullable extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type IsEqual } 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 DataParserNullableCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserNullableCheckers<GenericInput extends unknown = unknown> = (DataParserNullableCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserNullableCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionNullable<GenericCoalescingValue extends unknown = unknown> extends DataParserDefinition<DataParserNullableCheckers> {
     readonly inner: DataParser;
+    readonly coalescingValue: GenericCoalescingValue;
 }
 export declare const nullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>>;
-type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | null, Input<GenericDefinition["inner"]> | null> & Kind<typeof nullableKind.definition>);
+type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | null : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | null> & Kind<typeof nullableKind.definition>);
 export interface DataParserNullable<GenericDefinition extends DataParserDefinitionNullable = DataParserDefinitionNullable> extends _DataParserNullable<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserNullableCheckers<Output<this>>,
+        ...DataParserNullableCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserNullableCheckers<Output<this>>,
+        ...DataParserNullableCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserNullable<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
-export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/parsers/nullable.mjs

@@ -8,17 +8,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);
         },

package/dist/dataParser/parsers/number/checkers/int.cjs

@@ -5,9 +5,9 @@ var error = require('../../../error.cjs');
 var index = require('../index.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerIntKind = kind.createDataParserKind("checker-number-int");
+const checkerIntKind = kind.createDataParserKind("checker-number-int");
 function checkerInt(definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerIntKind, {
+    return base.dataParserCheckerInit(checkerIntKind, {
         definition,
     }, (data) => {
         if (Number.isInteger(data)) {
@@ -23,5 +23,5 @@ function int(definition) {
 }
 
 exports.checkerInt = checkerInt;
-exports.dataParserCheckerIntKind = dataParserCheckerIntKind;
+exports.checkerIntKind = checkerIntKind;
 exports.int = int;

package/dist/dataParser/parsers/number/checkers/int.d.ts

@@ -2,8 +2,8 @@ import { type Kind } from "../../../../common";
 import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
 export interface DataParserCheckerDefinitionInt extends DataParserCheckerDefinition {
 }
-export declare const dataParserCheckerIntKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-int", unknown>>;
-type _DataParserCheckerInt = (Kind<typeof dataParserCheckerIntKind.definition> & DataParserChecker<DataParserCheckerDefinitionInt, number>);
+export declare const checkerIntKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-int", unknown>>;
+type _DataParserCheckerInt = (Kind<typeof checkerIntKind.definition> & DataParserChecker<DataParserCheckerDefinitionInt, number>);
 export interface DataParserCheckerInt extends _DataParserCheckerInt {
 }
 export declare function checkerInt(definition?: Partial<DataParserCheckerDefinitionInt>): DataParserCheckerInt;

package/dist/dataParser/parsers/number/checkers/int.mjs

@@ -3,9 +3,9 @@ import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { number } from '../index.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerIntKind = createDataParserKind("checker-number-int");
+const checkerIntKind = createDataParserKind("checker-number-int");
 function checkerInt(definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerIntKind, {
+    return dataParserCheckerInit(checkerIntKind, {
         definition,
     }, (data) => {
         if (Number.isInteger(data)) {
@@ -20,4 +20,4 @@ function int(definition) {
     });
 }
 
-export { checkerInt, dataParserCheckerIntKind, int };
+export { checkerInt, checkerIntKind, int };

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

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerNumberMaxKind = kind.createDataParserKind("checker-number-max");
+const checkerNumberMaxKind = kind.createDataParserKind("checker-number-max");
 function checkerNumberMax(max, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerNumberMaxKind, {
+    return base.dataParserCheckerInit(checkerNumberMaxKind, {
         definition: {
             ...definition,
             max,
@@ -15,4 +15,4 @@ function checkerNumberMax(max, definition = {}) {
 }
 
 exports.checkerNumberMax = checkerNumberMax;
-exports.dataParserCheckerNumberMaxKind = dataParserCheckerNumberMaxKind;
+exports.checkerNumberMaxKind = checkerNumberMaxKind;

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

@@ -3,8 +3,8 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionNumberMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerNumberMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-max", unknown>>;
-type _DataParserCheckerNumberMax = (Kind<typeof dataParserCheckerNumberMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMax, number>);
+export declare const checkerNumberMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-max", unknown>>;
+type _DataParserCheckerNumberMax = (Kind<typeof checkerNumberMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMax, number>);
 export interface DataParserCheckerNumberMax extends _DataParserCheckerNumberMax {
 }
 export declare function checkerNumberMax(max: number, definition?: Partial<Omit<DataParserCheckerDefinitionNumberMax, "max">>): DataParserCheckerNumberMax;

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

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerNumberMaxKind = createDataParserKind("checker-number-max");
+const checkerNumberMaxKind = createDataParserKind("checker-number-max");
 function checkerNumberMax(max, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerNumberMaxKind, {
+    return dataParserCheckerInit(checkerNumberMaxKind, {
         definition: {
             ...definition,
             max,
@@ -12,4 +12,4 @@ function checkerNumberMax(max, definition = {}) {
     }, (value, self) => value <= self.definition.max ? value : SymbolDataParserErrorIssue);
 }
 
-export { checkerNumberMax, dataParserCheckerNumberMaxKind };
+export { checkerNumberMax, checkerNumberMaxKind };