@duplojs/utils 1.0.6 → 1.1.7

package/dist/dataParser/extended/bigint.d.ts

@@ -0,0 +1,19 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt> = (dataParsers.DataParserBigInt<GenericDefinition> & DataParserExtended);
+export interface DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt = dataParsers.DataParserDefinitionBigInt> extends _DataParserBigIntExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserBigIntCheckers,
+        ...dataParsers.DataParserBigIntCheckers[]
+    ]>(...args: GenericChecker): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    min(min: bigint, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionBigIntMin, "min">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerBigIntMin
+    ]>>;
+    max(max: bigint, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionBigIntMax, "max">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerBigIntMax
+    ]>>;
+}
+export declare function bigint<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionBigInt> = never>(definition?: GenericDefinition): DataParserBigIntExtended<MergeDefinition<dataParsers.DataParserDefinitionBigInt, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/bigint.mjs

@@ -0,0 +1,18 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { bigint as bigint$1 } from '../parsers/bigint/index.mjs';
+import '../../pattern/result.mjs';
+import { checkerBigIntMax } from '../parsers/bigint/checkers/max.mjs';
+import { checkerBigIntMin } from '../parsers/bigint/checkers/min.mjs';
+
+function bigint(definition) {
+    return dataParserExtendedInit(bigint$1(definition), {
+        min(self, min, definition) {
+            return self.addChecker(checkerBigIntMin(min, definition));
+        },
+        max(self, max, definition) {
+            return self.addChecker(checkerBigIntMax(max, definition));
+        },
+    });
+}
+
+export { bigint };

package/dist/dataParser/extended/boolean.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var boolean$1 = require('../parsers/boolean.cjs');
+require('../../pattern/result.cjs');
+
+function boolean(definition) {
+    return baseExtended.dataParserExtendedInit(boolean$1.boolean(definition), {});
+}
+
+exports.boolean = boolean;

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

@@ -0,0 +1,9 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserBooleanExtended<GenericDefinition extends dataParsers.DataParserDefinitionBoolean> = (dataParsers.DataParserBoolean<GenericDefinition> & DataParserExtended);
+export interface DataParserBooleanExtended<GenericDefinition extends dataParsers.DataParserDefinitionBoolean = dataParsers.DataParserDefinitionBoolean> extends _DataParserBooleanExtended<GenericDefinition> {
+}
+export declare function boolean<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionBoolean> = never>(definition?: GenericDefinition): DataParserBooleanExtended<MergeDefinition<dataParsers.DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/boolean.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { boolean as boolean$1 } from '../parsers/boolean.mjs';
+import '../../pattern/result.mjs';
+
+function boolean(definition) {
+    return dataParserExtendedInit(boolean$1(definition), {});
+}
+
+export { boolean };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/dataParser/extended/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/extended/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/extended/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/extended/coerce/nil.cjs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/dataParser/extended/empty.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var empty$1 = require('../parsers/empty.cjs');
+require('../../pattern/result.cjs');
+
+function empty(definition) {
+    return baseExtended.dataParserExtendedInit(empty$1.empty(definition), {});
+}
+
+exports.empty = empty;

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

@@ -0,0 +1,9 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty> = (dataParsers.DataParserEmpty<GenericDefinition> & DataParserExtended);
+export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty = dataParsers.DataParserDefinitionEmpty> extends _DataParserEmptyExtended<GenericDefinition> {
+}
+export declare function empty<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmptyExtended<MergeDefinition<dataParsers.DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/empty.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { empty as empty$1 } from '../parsers/empty.mjs';
+import '../../pattern/result.mjs';
+
+function empty(definition) {
+    return dataParserExtendedInit(empty$1(definition), {});
+}
+
+export { empty };

package/dist/dataParser/extended/index.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var index = require('./coerce/index.cjs');
+var string = require('./string.cjs');
+var array = require('./array.cjs');
+var bigint = require('./bigint.cjs');
+var number = require('./number.cjs');
+var transform = require('./transform.cjs');
+var union = require('./union.cjs');
+var boolean = require('./boolean.cjs');
+var empty = require('./empty.cjs');
+var lazy = require('./lazy.cjs');
+var literal = require('./literal.cjs');
+var nil = require('./nil.cjs');
+var nullable = require('./nullable.cjs');
+var object = require('./object.cjs');
+var optional = require('./optional.cjs');
+var pipe = require('./pipe.cjs');
+var record = require('./record.cjs');
+var templateLiteral = require('./templateLiteral.cjs');
+var tuple = require('./tuple.cjs');
+var unknown = require('./unknown.cjs');
+
+
+
+exports.coerce = index;
+exports.email = string.email;
+exports.string = string.string;
+exports.url = string.url;
+exports.array = array.array;
+exports.bigint = bigint.bigint;
+exports.int = number.int;
+exports.number = number.number;
+exports.transform = transform.transform;
+exports.union = union.union;
+exports.boolean = boolean.boolean;
+exports.empty = empty.empty;
+exports.lazy = lazy.lazy;
+exports.literal = literal.literal;
+exports.nil = nil.nil;
+exports.nullable = nullable.nullable;
+exports.object = object.object;
+exports.optional = optional.optional;
+exports.pipe = pipe.pipe;
+exports.record = record.record;
+exports.templateLiteral = templateLiteral.templateLiteral;
+exports.tuple = tuple.tuple;
+exports.unknown = unknown.unknown;

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

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

package/dist/dataParser/extended/index.mjs

@@ -0,0 +1,21 @@
+import * as index from './coerce/index.mjs';
+export { index as coerce };
+export { email, string, url } from './string.mjs';
+export { array } from './array.mjs';
+export { bigint } from './bigint.mjs';
+export { int, number } from './number.mjs';
+export { transform } from './transform.mjs';
+export { union } from './union.mjs';
+export { boolean } from './boolean.mjs';
+export { empty } from './empty.mjs';
+export { lazy } from './lazy.mjs';
+export { literal } from './literal.mjs';
+export { nil } from './nil.mjs';
+export { nullable } from './nullable.mjs';
+export { object } from './object.mjs';
+export { optional } from './optional.mjs';
+export { pipe } from './pipe.mjs';
+export { record } from './record.mjs';
+export { templateLiteral } from './templateLiteral.mjs';
+export { tuple } from './tuple.mjs';
+export { unknown } from './unknown.mjs';

package/dist/dataParser/extended/lazy.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var lazy$1 = require('../parsers/lazy.cjs');
+
+function lazy(getter, definition) {
+    return baseExtended.dataParserExtendedInit(lazy$1.lazy(getter, definition), {});
+}
+
+exports.lazy = lazy;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy> = (dataParsers.DataParserLazy<GenericDefinition> & DataParserExtended);
+export interface DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy = dataParsers.DataParserDefinitionLazy> extends _DataParserLazyExtended<GenericDefinition> {
+}
+export declare function lazy<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
+    getter(): GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/extended/lazy.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../../pattern/result.mjs';
+import { lazy as lazy$1 } from '../parsers/lazy.mjs';
+
+function lazy(getter, definition) {
+    return dataParserExtendedInit(lazy$1(getter, definition), {});
+}
+
+export { lazy };

package/dist/dataParser/extended/literal.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var literal$1 = require('../parsers/literal.cjs');
+require('../../pattern/result.cjs');
+
+function literal(value, definition) {
+    return baseExtended.dataParserExtendedInit(literal$1.literal(value, definition), {});
+}
+
+exports.literal = literal;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral> = (dataParsers.DataParserLiteral<GenericDefinition> & DataParserExtended);
+export interface DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral = dataParsers.DataParserDefinitionLiteral> extends _DataParserLiteralExtended<GenericDefinition> {
+}
+export declare function literal<const GenericValue extends dataParsers.LiteralValue, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
+    value: GenericValue[];
+}>>;
+export {};

package/dist/dataParser/extended/literal.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { literal as literal$1 } from '../parsers/literal.mjs';
+import '../../pattern/result.mjs';
+
+function literal(value, definition) {
+    return dataParserExtendedInit(literal$1(value, definition), {});
+}
+
+export { literal };

package/dist/dataParser/extended/nil.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var nil$1 = require('../parsers/nil.cjs');
+require('../../pattern/result.cjs');
+
+function nil(definition) {
+    return baseExtended.dataParserExtendedInit(nil$1.nil(definition), {});
+}
+
+exports.nil = nil;

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

@@ -0,0 +1,9 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil> = (dataParsers.DataParserNil<GenericDefinition> & DataParserExtended);
+export interface DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil = dataParsers.DataParserDefinitionNil> extends _DataParserNilExtended<GenericDefinition> {
+}
+export declare function nil<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/nil.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { nil as nil$1 } from '../parsers/nil.mjs';
+import '../../pattern/result.mjs';
+
+function nil(definition) {
+    return dataParserExtendedInit(nil$1(definition), {});
+}
+
+export { nil };

package/dist/dataParser/extended/nullable.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var nullable$1 = require('../parsers/nullable.cjs');
+
+function nullable(inner, definition) {
+    return baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {});
+}
+
+exports.nullable = nullable;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable> = (dataParsers.DataParserNullable<GenericDefinition> & DataParserExtended);
+export interface DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable = dataParsers.DataParserDefinitionNullable> extends _DataParserNullableExtended<GenericDefinition> {
+}
+export declare function nullable<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/extended/nullable.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../../pattern/result.mjs';
+import { nullable as nullable$1 } from '../parsers/nullable.mjs';
+
+function nullable(inner, definition) {
+    return dataParserExtendedInit(nullable$1(inner, definition), {});
+}
+
+export { nullable };

package/dist/dataParser/extended/number.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var index = require('../parsers/number/index.cjs');
+require('../../pattern/result.cjs');
+var int$1 = require('../parsers/number/checkers/int.cjs');
+var max = require('../parsers/number/checkers/max.cjs');
+var min = require('../parsers/number/checkers/min.cjs');
+
+function number(definition) {
+    return baseExtended.dataParserExtendedInit(index.number(definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerNumberMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerNumberMax(max$1, definition));
+        },
+    });
+}
+function int(definition) {
+    return number({
+        checkers: [int$1.checkerInt(definition)],
+    });
+}
+
+exports.int = int;
+exports.number = number;