@duplojs/utils 1.0.7 → 1.1.7

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

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

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

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

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

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

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

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

package/dist/dataParser/parsers/empty.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserEmptyKind = kind.createKind("data-parser-empty");
+function empty(definition) {
+    return base.dataParserInit(dataParserEmptyKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (data === undefined) {
+            return data;
+        }
+        else if (self.definition.coerce && data === "undefined") {
+            return undefined;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserEmptyKind = dataParserEmptyKind;
+exports.empty = empty;

package/dist/dataParser/parsers/empty.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 DataParserDefinitionEmpty extends DataParserDefinition<never> {
+    readonly coerce: boolean;
+}
+export declare const dataParserEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-empty", unknown>>;
+type _DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty> = (DataParser<GenericDefinition, undefined, undefined> & Kind<typeof dataParserEmptyKind.definition>);
+export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty = DataParserDefinitionEmpty> extends _DataParserEmpty<GenericDefinition> {
+}
+export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/parsers/empty.mjs

@@ -0,0 +1,24 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+
+const dataParserEmptyKind = createKind("data-parser-empty");
+function empty(definition) {
+    return dataParserInit(dataParserEmptyKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (data === undefined) {
+            return data;
+        }
+        else if (self.definition.coerce && data === "undefined") {
+            return undefined;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserEmptyKind, empty };

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

@@ -0,0 +1,20 @@
+export * as coerce from "./coerce";
+export * from "./string";
+export * from "./object";
+export * from "./number";
+export * from "./literal";
+export * from "./union";
+export * from "./array";
+export * from "./bigint";
+export * from "./tuple";
+export * from "./transform";
+export * from "./nil";
+export * from "./boolean";
+export * from "./empty";
+export * from "./templateLiteral";
+export * from "./pipe";
+export * from "./optional";
+export * from "./nullable";
+export * from "./lazy";
+export * from "./unknown";
+export * from "./record";

package/dist/dataParser/parsers/lazy.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+
+const dataParserLazyKind = kind.createKind("data-parser-lazy");
+function lazy(getter, definition) {
+    return base.dataParserInit(dataParserLazyKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            getter,
+        },
+    }, {
+        sync: (data, _error, self) => self.definition.getter().exec(data, _error),
+        async: (data, _error, self) => self.definition.getter().asyncExec(data, _error),
+    });
+}
+
+exports.dataParserLazyKind = dataParserLazyKind;
+exports.lazy = lazy;

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

@@ -0,0 +1,14 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+export interface DataParserDefinitionLazy extends DataParserDefinition<never> {
+    getter(): DataParsers;
+}
+export declare const dataParserLazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-lazy", unknown>>;
+type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<ReturnType<GenericDefinition["getter"]>>, Input<ReturnType<GenericDefinition["getter"]>>> & Kind<typeof dataParserLazyKind.definition>);
+export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLazy = DataParserDefinitionLazy> extends _DataParserLazy<GenericDefinition> {
+}
+export declare function lazy<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
+    getter(): GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/parsers/lazy.mjs

@@ -0,0 +1,18 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+
+const dataParserLazyKind = createKind("data-parser-lazy");
+function lazy(getter, definition) {
+    return dataParserInit(dataParserLazyKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            getter,
+        },
+    }, {
+        sync: (data, _error, self) => self.definition.getter().exec(data, _error),
+        async: (data, _error, self) => self.definition.getter().asyncExec(data, _error),
+    });
+}
+
+export { dataParserLazyKind, lazy };

package/dist/dataParser/parsers/literal.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var coalescing = require('../../array/coalescing.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserLiteralKind = kind.createKind("data-parser-literal");
+function literal(value, definition) {
+    return base.dataParserInit(dataParserLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            value: coalescing.coalescing(value),
+        },
+    }, (data, _error, self) => {
+        if (self.definition.value.includes(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserLiteralKind = dataParserLiteralKind;
+exports.literal = literal;

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

@@ -0,0 +1,15 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserDefinition, type DataParser } from "../base";
+import { type MergeDefinition } from "../../dataParser/types";
+export type LiteralValue = string | number | bigint | undefined | null | boolean;
+export interface DataParserDefinitionLiteral extends DataParserDefinition<never> {
+    readonly value: LiteralValue[];
+}
+export declare const dataParserLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-literal", unknown>>;
+type _DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral> = (DataParser<GenericDefinition, GenericDefinition["value"][number], GenericDefinition["value"][number]> & Kind<typeof dataParserLiteralKind.definition>);
+export interface DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral = DataParserDefinitionLiteral> extends _DataParserLiteral<GenericDefinition> {
+}
+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[];
+}>>;
+export {};

package/dist/dataParser/parsers/literal.mjs

@@ -0,0 +1,22 @@
+import { createKind } from '../../common/kind.mjs';
+import { coalescing } from '../../array/coalescing.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+
+const dataParserLiteralKind = createKind("data-parser-literal");
+function literal(value, definition) {
+    return dataParserInit(dataParserLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            value: coalescing(value),
+        },
+    }, (data, _error, self) => {
+        if (self.definition.value.includes(data)) {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserLiteralKind, literal };

package/dist/dataParser/parsers/nil.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserNilKind = kind.createKind("data-parser-nil");
+function nil(definition) {
+    return base.dataParserInit(dataParserNilKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (data === null) {
+            return data;
+        }
+        else if (self.definition.coerce && data === "null") {
+            return null;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserNilKind = dataParserNilKind;
+exports.nil = nil;

package/dist/dataParser/parsers/nil.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 DataParserDefinitionNil extends DataParserDefinition<never> {
+    readonly coerce: boolean;
+}
+export declare const dataParserNilKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-nil", unknown>>;
+type _DataParserNil<GenericDefinition extends DataParserDefinitionNil> = (DataParser<GenericDefinition, null, null> & Kind<typeof dataParserNilKind.definition>);
+export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil = DataParserDefinitionNil> extends _DataParserNil<GenericDefinition> {
+}
+export declare function nil<const GenericDefinition extends Partial<DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/parsers/nil.mjs

@@ -0,0 +1,24 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+
+const dataParserNilKind = createKind("data-parser-nil");
+function nil(definition) {
+    return dataParserInit(dataParserNilKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (data === null) {
+            return data;
+        }
+        else if (self.definition.coerce && data === "null") {
+            return null;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserNilKind, nil };

package/dist/dataParser/parsers/nullable.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+
+const dataParserNullableKind = kind.createKind("data-parser-nullable");
+function nullable(inner, definition) {
+    return base.dataParserInit(dataParserNullableKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (data === null) {
+                return data;
+            }
+            return self.definition.inner.exec(data, error);
+        },
+        async: async (data, error, self) => {
+            if (data === null) {
+                return data;
+            }
+            return self.definition.inner.asyncExec(data, error);
+        },
+    });
+}
+
+exports.dataParserNullableKind = dataParserNullableKind;
+exports.nullable = nullable;

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

@@ -0,0 +1,14 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+export interface DataParserDefinitionNullable extends DataParserDefinition<never> {
+    readonly inner: DataParsers;
+}
+export declare const dataParserNullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-nullable", unknown>>;
+type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | null, Input<GenericDefinition["inner"]> | null> & Kind<typeof dataParserNullableKind.definition>);
+export interface DataParserNullable<GenericDefinition extends DataParserDefinitionNullable = DataParserDefinitionNullable> extends _DataParserNullable<GenericDefinition> {
+}
+export declare function nullable<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/parsers/nullable.mjs

@@ -0,0 +1,28 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+
+const dataParserNullableKind = createKind("data-parser-nullable");
+function nullable(inner, definition) {
+    return dataParserInit(dataParserNullableKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (data === null) {
+                return data;
+            }
+            return self.definition.inner.exec(data, error);
+        },
+        async: async (data, error, self) => {
+            if (data === null) {
+                return data;
+            }
+            return self.definition.inner.asyncExec(data, error);
+        },
+    });
+}
+
+export { dataParserNullableKind, nullable };

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

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

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var index = require('../index.cjs');
+
+const dataParserCheckerIntKind = kind.createKind("data-parser-checker-int");
+function checkerInt(definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerIntKind, {
+        definition,
+    }, (data) => {
+        if (Number.isInteger(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+function int(definition) {
+    return index.number({
+        checkers: [checkerInt(definition)],
+    });
+}
+
+exports.checkerInt = checkerInt;
+exports.dataParserCheckerIntKind = dataParserCheckerIntKind;
+exports.int = int;

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

@@ -0,0 +1,15 @@
+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<"data-parser-checker-int", unknown>>;
+type _DataParserCheckerInt = (Kind<typeof dataParserCheckerIntKind.definition> & DataParserChecker<DataParserCheckerDefinitionInt, number>);
+export interface DataParserCheckerInt extends _DataParserCheckerInt {
+}
+export declare function checkerInt(definition?: Partial<DataParserCheckerDefinitionInt>): DataParserCheckerInt;
+export declare function int(definition?: Partial<DataParserCheckerDefinitionInt>): import("..").DataParserNumber<{
+    readonly checkers: readonly [DataParserCheckerInt];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

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

@@ -0,0 +1,23 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { number } from '../index.mjs';
+
+const dataParserCheckerIntKind = createKind("data-parser-checker-int");
+function checkerInt(definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerIntKind, {
+        definition,
+    }, (data) => {
+        if (Number.isInteger(data)) {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+function int(definition) {
+    return number({
+        checkers: [checkerInt(definition)],
+    });
+}
+
+export { checkerInt, dataParserCheckerIntKind, int };

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerNumberMaxKind = kind.createKind("data-parser-checker-number-max");
+function checkerNumberMax(max, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerNumberMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => value <= self.definition.max ? value : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerNumberMax = checkerNumberMax;
+exports.dataParserCheckerNumberMaxKind = dataParserCheckerNumberMaxKind;

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

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

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

@@ -0,0 +1,15 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerNumberMaxKind = createKind("data-parser-checker-number-max");
+function checkerNumberMax(max, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerNumberMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => value <= self.definition.max ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerNumberMax, dataParserCheckerNumberMaxKind };

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerNumberMinKind = kind.createKind("data-parser-checker-number-min");
+function checkerNumberMin(min, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerNumberMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => value >= self.definition.min ? value : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerNumberMin = checkerNumberMin;
+exports.dataParserCheckerNumberMinKind = dataParserCheckerNumberMinKind;

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

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionNumberMin extends DataParserCheckerDefinition {
+    min: number;
+}
+export declare const dataParserCheckerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-number-min", unknown>>;
+type _DataParserCheckerNumberMin = (Kind<typeof dataParserCheckerNumberMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMin, number>);
+export interface DataParserCheckerNumberMin extends _DataParserCheckerNumberMin {
+}
+export declare function checkerNumberMin(min: number, definition?: Partial<Omit<DataParserCheckerDefinitionNumberMin, "min">>): DataParserCheckerNumberMin;
+export {};

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

@@ -0,0 +1,15 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerNumberMinKind = createKind("data-parser-checker-number-min");
+function checkerNumberMin(min, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerNumberMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => value >= self.definition.min ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerNumberMin, dataParserCheckerNumberMinKind };

package/dist/dataParser/parsers/number/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 dataParserNumberKind = kind.createKind("data-parser-number");
+function number(definition) {
+    return base.dataParserInit(dataParserNumberKind, {
+        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 = Number(data);
+            }
+            catch { }
+        }
+        if (typeof data === "number" && !Number.isNaN(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserNumberKind = dataParserNumberKind;
+exports.number = number;

package/dist/dataParser/parsers/number/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 DataParserCheckerInt, type DataParserCheckerNumberMin, type DataParserCheckerNumberMax } from "./checkers";
+export * from "./checkers";
+export type DataParserNumberCheckers = (DataParserCheckerInt | DataParserCheckerNumberMin | DataParserCheckerNumberMax);
+export interface DataParserDefinitionNumber extends DataParserDefinition<DataParserNumberCheckers> {
+    readonly coerce: boolean;
+}
+export declare const dataParserNumberKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"data-parser-number", unknown>>;
+type _DataParserNumber<GenericDefinition extends DataParserDefinitionNumber> = (DataParser<GenericDefinition, number, number> & Kind<typeof dataParserNumberKind.definition>);
+export interface DataParserNumber<GenericDefinition extends DataParserDefinitionNumber = DataParserDefinitionNumber> extends _DataParserNumber<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserNumberCheckers,
+        ...DataParserNumberCheckers[]
+    ]>(...args: GenericChecker): DataParserNumber<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function number<const GenericDefinition extends Partial<DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumber<MergeDefinition<DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;