@duplojs/utils 1.0.7 → 1.1.7

package/dist/dataParser/parsers/array/index.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+var kind = require('../../../common/kind.cjs');
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+
+const dataParserArrayKind = kind.createKind("data-parser-array");
+function array(element, definition) {
+    return base.dataParserInit(dataParserArrayKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            element,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            if (!(data instanceof Array)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error$1.currentPath.length;
+            for (let index = 0; index < data.length; index++) {
+                error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                const result = self
+                    .definition
+                    .element
+                    .exec(data[index], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+        async: async (data, error$1, self) => {
+            if (!(data instanceof Array)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error$1.currentPath.length;
+            for (let index = 0; index < data.length; index++) {
+                error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                const result = await self
+                    .definition
+                    .element
+                    .asyncExec(data[index], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+    });
+}
+
+exports.array = array;
+exports.dataParserArrayKind = dataParserArrayKind;

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

@@ -0,0 +1,20 @@
+import { type NeverCoalescing, type Kind } from "../../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../../base";
+import { type AddCheckersToDefinition, type DataParsers, type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserCheckerArrayMin, type DataParserCheckerArrayMax } from "./checkers";
+export * from "./checkers";
+export type DataParserArrayCheckers = (DataParserCheckerArrayMin | DataParserCheckerArrayMax);
+export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers> {
+    readonly element: DataParsers;
+}
+export declare const dataParserArrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"data-parser-array", unknown>>;
+type _DataParserArray<GenericDefinition extends DataParserDefinitionArray> = (DataParser<GenericDefinition, Output<GenericDefinition["element"]>[], Input<GenericDefinition["element"]>[]> & Kind<typeof dataParserArrayKind.definition>);
+export interface DataParserArray<GenericDefinition extends DataParserDefinitionArray = DataParserDefinitionArray> extends _DataParserArray<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserArrayCheckers,
+        ...DataParserArrayCheckers[]
+    ]>(...args: GenericChecker): DataParserArray<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function array<GenericElement extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
+    element: GenericElement;
+}>>;

package/dist/dataParser/parsers/array/index.mjs

@@ -0,0 +1,61 @@
+import { createKind } from '../../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../error.mjs';
+
+const dataParserArrayKind = createKind("data-parser-array");
+function array(element, definition) {
+    return dataParserInit(dataParserArrayKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            element,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (!(data instanceof Array)) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error.currentPath.length;
+            for (let index = 0; index < data.length; index++) {
+                setErrorPath(error, `[${index}]`, currentIndexPath);
+                const result = self
+                    .definition
+                    .element
+                    .exec(data[index], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+        async: async (data, error, self) => {
+            if (!(data instanceof Array)) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error.currentPath.length;
+            for (let index = 0; index < data.length; index++) {
+                setErrorPath(error, `[${index}]`, currentIndexPath);
+                const result = await self
+                    .definition
+                    .element
+                    .asyncExec(data[index], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+    });
+}
+
+export { array, dataParserArrayKind };

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

@@ -0,0 +1,2 @@
+export * from "./min";
+export * from "./max";

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerBigIntMaxKind = kind.createKind("data-parser-checker-bigint-max");
+function checkerBigIntMax(max, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerBigIntMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => {
+        if (value > self.definition.max) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return value;
+    });
+}
+
+exports.checkerBigIntMax = checkerBigIntMax;
+exports.dataParserCheckerBigIntMaxKind = dataParserCheckerBigIntMaxKind;

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

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

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

@@ -0,0 +1,20 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerBigIntMaxKind = createKind("data-parser-checker-bigint-max");
+function checkerBigIntMax(max, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerBigIntMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => {
+        if (value > self.definition.max) {
+            return SymbolDataParserErrorIssue;
+        }
+        return value;
+    });
+}
+
+export { checkerBigIntMax, dataParserCheckerBigIntMaxKind };

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerBigIntMinKind = kind.createKind("data-parser-checker-bigint-min");
+function checkerBigIntMin(min, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerBigIntMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => {
+        if (value < self.definition.min) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return value;
+    });
+}
+
+exports.checkerBigIntMin = checkerBigIntMin;
+exports.dataParserCheckerBigIntMinKind = dataParserCheckerBigIntMinKind;

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

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

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

@@ -0,0 +1,20 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerBigIntMinKind = createKind("data-parser-checker-bigint-min");
+function checkerBigIntMin(min, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerBigIntMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => {
+        if (value < self.definition.min) {
+            return SymbolDataParserErrorIssue;
+        }
+        return value;
+    });
+}
+
+export { checkerBigIntMin, dataParserCheckerBigIntMinKind };

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var kind = require('../../../common/kind.cjs');
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+
+const dataParserBigIntKind = kind.createKind("data-parser-bigint");
+function bigint(definition) {
+    return base.dataParserInit(dataParserBigIntKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            try {
+                // eslint-disable-next-line no-param-reassign
+                data = BigInt(data);
+            }
+            catch { }
+        }
+        if (typeof data === "bigint") {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.bigint = bigint;
+exports.dataParserBigIntKind = dataParserBigIntKind;

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

@@ -0,0 +1,18 @@
+import { type NeverCoalescing, type Kind } from "../../../common";
+import { type DataParserDefinition, type DataParser } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserCheckerBigIntMin, type DataParserCheckerBigIntMax } from "./checkers";
+export * from "./checkers";
+export type DataParserBigIntCheckers = (DataParserCheckerBigIntMin | DataParserCheckerBigIntMax);
+export interface DataParserDefinitionBigInt extends DataParserDefinition<DataParserBigIntCheckers> {
+    readonly coerce: boolean;
+}
+export declare const dataParserBigIntKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"data-parser-bigint", unknown>>;
+type _DataParserBigInt<GenericDefinition extends DataParserDefinitionBigInt> = (DataParser<GenericDefinition, bigint, bigint> & Kind<typeof dataParserBigIntKind.definition>);
+export interface DataParserBigInt<GenericDefinition extends DataParserDefinitionBigInt = DataParserDefinitionBigInt> extends _DataParserBigInt<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserBigIntCheckers,
+        ...DataParserBigIntCheckers[]
+    ]>(...args: 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/bigint/index.mjs

@@ -0,0 +1,28 @@
+import { createKind } from '../../../common/kind.mjs';
+import { dataParserInit } from '../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../error.mjs';
+
+const dataParserBigIntKind = createKind("data-parser-bigint");
+function bigint(definition) {
+    return dataParserInit(dataParserBigIntKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            try {
+                // eslint-disable-next-line no-param-reassign
+                data = BigInt(data);
+            }
+            catch { }
+        }
+        if (typeof data === "bigint") {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { bigint, dataParserBigIntKind };

package/dist/dataParser/parsers/boolean.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserBooleanKind = kind.createKind("data-parser-boolean");
+function boolean(definition) {
+    return base.dataParserInit(dataParserBooleanKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "boolean") {
+            return data;
+        }
+        else if (self.definition.coerce) {
+            if (typeof data === "string") {
+                const lower = data.trim().toLowerCase();
+                if (lower === "true" || lower === "false") {
+                    return lower === "true";
+                }
+                else {
+                    return error.SymbolDataParserErrorIssue;
+                }
+            }
+            else if (typeof data === "number"
+                && (data === 0
+                    || data === 1)) {
+                return data === 1;
+            }
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.boolean = boolean;
+exports.dataParserBooleanKind = dataParserBooleanKind;

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

@@ -0,0 +1,12 @@
+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> {
+    readonly coerce: boolean;
+}
+export declare const dataParserBooleanKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-boolean", unknown>>;
+type _DataParserBoolean<GenericDefinition extends DataParserDefinitionBoolean> = (DataParser<GenericDefinition, boolean, boolean> & Kind<typeof dataParserBooleanKind.definition>);
+export interface DataParserBoolean<GenericDefinition extends DataParserDefinitionBoolean = DataParserDefinitionBoolean> extends _DataParserBoolean<GenericDefinition> {
+}
+export declare function boolean<const GenericDefinition extends Partial<DataParserDefinitionBoolean> = never>(definition?: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/parsers/boolean.mjs

@@ -0,0 +1,37 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+
+const dataParserBooleanKind = createKind("data-parser-boolean");
+function boolean(definition) {
+    return dataParserInit(dataParserBooleanKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "boolean") {
+            return data;
+        }
+        else if (self.definition.coerce) {
+            if (typeof data === "string") {
+                const lower = data.trim().toLowerCase();
+                if (lower === "true" || lower === "false") {
+                    return lower === "true";
+                }
+                else {
+                    return SymbolDataParserErrorIssue;
+                }
+            }
+            else if (typeof data === "number"
+                && (data === 0
+                    || data === 1)) {
+                return data === 1;
+            }
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { boolean, dataParserBooleanKind };

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('../bigint/index.cjs');
+require('../../../pattern/result.cjs');
+
+function bigint(definition) {
+    return index.bigint({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.bigint = bigint;

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

@@ -0,0 +1,6 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import * as dataParsers from "..";
+export declare function bigint<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionBigInt, "coerce">> = never>(definition?: GenericDefinition): dataParsers.DataParserBigInt<MergeDefinition<dataParsers.DataParserDefinitionBigInt, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import { bigint as bigint$1 } from '../bigint/index.mjs';
+import '../../../pattern/result.mjs';
+
+function bigint(definition) {
+    return bigint$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { bigint };

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var boolean$1 = require('../boolean.cjs');
+require('../../../pattern/result.cjs');
+
+function boolean(definition) {
+    return boolean$1.boolean({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.boolean = boolean;

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

@@ -0,0 +1,6 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import * as dataParsers from "..";
+export declare function boolean<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionBoolean, "coerce">> = never>(definition?: GenericDefinition): dataParsers.DataParserBoolean<MergeDefinition<dataParsers.DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import { boolean as boolean$1 } from '../boolean.mjs';
+import '../../../pattern/result.mjs';
+
+function boolean(definition) {
+    return boolean$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { boolean };

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var empty$1 = require('../empty.cjs');
+require('../../../pattern/result.cjs');
+
+function empty(definition) {
+    return empty$1.empty({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.empty = empty;

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

@@ -0,0 +1,6 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import * as dataParsers from "..";
+export declare function empty<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionEmpty, "coerce">> = never>(definition?: GenericDefinition): dataParsers.DataParserEmpty<MergeDefinition<dataParsers.DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import { empty as empty$1 } from '../empty.mjs';
+import '../../../pattern/result.mjs';
+
+function empty(definition) {
+    return empty$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { empty };

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

@@ -0,0 +1,17 @@
+'use strict';
+
+var bigint = require('./bigint.cjs');
+var boolean = require('./boolean.cjs');
+var empty = require('./empty.cjs');
+var nil = require('./nil.cjs');
+var number = require('./number.cjs');
+var string = require('./string.cjs');
+
+
+
+exports.bigint = bigint.bigint;
+exports.boolean = boolean.boolean;
+exports.empty = empty.empty;
+exports.nil = nil.nil;
+exports.number = number.number;
+exports.string = string.string;

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

@@ -0,0 +1,6 @@
+export * from "./bigint";
+export * from "./boolean";
+export * from "./empty";
+export * from "./nil";
+export * from "./number";
+export * from "./string";

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

@@ -0,0 +1,6 @@
+export { bigint } from './bigint.mjs';
+export { boolean } from './boolean.mjs';
+export { empty } from './empty.mjs';
+export { nil } from './nil.mjs';
+export { number } from './number.mjs';
+export { string } from './string.mjs';

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var nil$1 = require('../nil.cjs');
+require('../../../pattern/result.cjs');
+
+function nil(definition) {
+    return nil$1.nil({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.nil = nil;

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

@@ -0,0 +1,6 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import * as dataParsers from "..";
+export declare function nil<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNil, "coerce">> = never>(definition?: GenericDefinition): dataParsers.DataParserNil<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import { nil as nil$1 } from '../nil.mjs';
+import '../../../pattern/result.mjs';
+
+function nil(definition) {
+    return nil$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { nil };

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('../number/index.cjs');
+require('../../../pattern/result.cjs');
+
+function number(definition) {
+    return index.number({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.number = number;

package/dist/dataParser/parsers/coerce/number.d.ts

@@ -0,0 +1,6 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import * as dataParsers from "..";
+export declare function number<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNumber, "coerce">> = never>(definition?: GenericDefinition): dataParsers.DataParserNumber<MergeDefinition<dataParsers.DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;