@duplojs/utils 1.0.7 → 1.1.7

package/dist/dataParser/base.mjs

@@ -0,0 +1,109 @@
+import { createKind } from '../common/kind.mjs';
+import { simpleClone } from '../common/simpleClone.mjs';
+import { createError, SymbolDataParserErrorIssue, addIssue, SymbolDataParserErrorPromiseIssue, addPromiseIssue } from './error.mjs';
+import { error } from '../either/left/error.mjs';
+import { success } from '../either/right/success.mjs';
+
+const SymbolDataParserErrorLabel = "SymbolDataParserError";
+const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
+const dataParserCheckerKind = createKind("data-parser-checker");
+function dataParserCheckerInit(kind, params, exec) {
+    return kind.setTo(dataParserCheckerKind.setTo({
+        ...params,
+        exec,
+    }));
+}
+const dataParserKind = createKind("data-parser");
+function dataParserInit(kind, params, exec) {
+    const formattedExec = typeof exec === "object"
+        ? exec
+        : {
+            sync: exec,
+            async: exec,
+        };
+    function middleExec(data, error) {
+        let result = formattedExec.sync(data, error, dataParser);
+        if (result === SymbolDataParserErrorIssue) {
+            addIssue(error, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result === SymbolDataParserErrorPromiseIssue) {
+            addPromiseIssue(error, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result !== SymbolDataParserError
+            && dataParser.definition.checkers.length) {
+            for (const checker of dataParser.definition.checkers) {
+                const checkerResult = checker.exec(result, checker);
+                if (checkerResult === SymbolDataParserErrorIssue) {
+                    addIssue(error, checker, result);
+                    return SymbolDataParserError;
+                }
+                else {
+                    result = checkerResult;
+                }
+            }
+        }
+        return result;
+    }
+    async function middleAsyncExec(data, error) {
+        let result = await formattedExec.async(data, error, dataParser);
+        if (result === SymbolDataParserErrorIssue) {
+            addIssue(error, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result === SymbolDataParserErrorPromiseIssue) {
+            addPromiseIssue(error, dataParser, data);
+            return SymbolDataParserError;
+        }
+        else if (result !== SymbolDataParserError
+            && dataParser.definition.checkers.length) {
+            for (const checker of dataParser.definition.checkers) {
+                const checkerResult = checker.exec(result, checker);
+                if (checkerResult === SymbolDataParserErrorIssue) {
+                    addIssue(error, checker, result);
+                    return SymbolDataParserError;
+                }
+                else {
+                    result = checkerResult;
+                }
+            }
+        }
+        return result;
+    }
+    const dataParser = kind.setTo(dataParserKind.setTo({
+        ...params,
+        exec: middleExec,
+        asyncExec: middleAsyncExec,
+        parse(data) {
+            const error$1 = createError();
+            const result = middleExec(data, error$1);
+            if (result === SymbolDataParserError) {
+                return error(error$1);
+            }
+            return success(result);
+        },
+        async asyncParse(data) {
+            const error$1 = createError();
+            const result = await middleAsyncExec(data, error$1);
+            if (result === SymbolDataParserError) {
+                return error(error$1);
+            }
+            return success(result);
+        },
+        addChecker: (...checkers) => dataParserInit(kind, simpleClone({
+            ...params,
+            definition: {
+                ...params.definition,
+                checkers: [...params.definition.checkers, ...checkers],
+            },
+        }), exec),
+        clone: () => dataParserInit(kind, simpleClone(params), exec),
+    }, {
+        output: undefined,
+        input: undefined,
+    }));
+    return dataParser;
+}
+
+export { SymbolDataParserError, SymbolDataParserErrorLabel, dataParserCheckerInit, dataParserCheckerKind, dataParserInit, dataParserKind };

package/dist/dataParser/baseExtended.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var entries = require('../object/entries.cjs');
+var kind = require('../common/kind.cjs');
+var pipe = require('../common/pipe.cjs');
+var fromEntries = require('../object/fromEntries.cjs');
+var entry = require('../object/entry.cjs');
+var map = require('../array/map.cjs');
+require('../pattern/result.cjs');
+var array = require('./extended/array.cjs');
+var transform = require('./extended/transform.cjs');
+var union = require('./extended/union.cjs');
+var nullable = require('./extended/nullable.cjs');
+var optional = require('./extended/optional.cjs');
+var pipe$1 = require('./extended/pipe.cjs');
+
+const dataParserExtendedKind = kind.createKind("data-parser-extended");
+function dataParserExtendedInit(dataParser, rest) {
+    const self = dataParserExtendedKind.setTo({
+        ...dataParser,
+        ...pipe.pipe(rest, entries.entries, map.map(([key, value]) => entry.entry(key, typeof value === "function"
+            ? (...args) => value(self, ...args)
+            : value)), fromEntries.fromEntries),
+        array(definition) {
+            return array.array(self, definition);
+        },
+        transform(theFunction, definition) {
+            return transform.transform(self, theFunction, definition);
+        },
+        arrayCoalescing() {
+            return union.union([
+                self.array(),
+                self.transform((data) => [data]),
+            ]);
+        },
+        pipe(output, definition) {
+            return pipe$1.pipe(self, output, definition);
+        },
+        nullable(definition) {
+            return nullable.nullable(self, definition);
+        },
+        optional(definition) {
+            return optional.optional(self, definition);
+        },
+        or(option, definition) {
+            return union.union([self, option], definition);
+        },
+        addChecker: (...checkers) => dataParserExtendedInit(dataParser.addChecker(...checkers), rest),
+        clone: () => dataParserExtendedInit(dataParser.clone(), rest),
+    });
+    return self;
+}
+
+exports.dataParserExtendedInit = dataParserExtendedInit;
+exports.dataParserExtendedKind = dataParserExtendedKind;

package/dist/dataParser/baseExtended.d.ts

@@ -0,0 +1,45 @@
+import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue } from "../common";
+import { type DataParsers, type MergeDefinition } from "./types";
+import { type Output, type DataParser } from "./base";
+import type * as dataParsers from "./parsers";
+import * as dataParsersExtended from "./extended";
+import { type DataParserError } from "./error";
+export declare const dataParserExtendedKind: import("../common").KindHandler<import("../common").KindDefinition<"data-parser-extended", unknown>>;
+type _DataParserExtended = (DataParser & Kind<typeof dataParserExtendedKind.definition>);
+export interface DataParserExtended extends _DataParserExtended {
+    array<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionArray, "element">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
+        element: GenericThis;
+    }>>;
+    transform<GenericThis extends this = this, GenericOutput extends AnyValue = AnyValue, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction">> = never>(theFunction: (input: Output<GenericThis>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): dataParsersExtended.DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
+        inner: GenericThis;
+        theFunction(input: Output<GenericThis>): GenericOutput;
+    }>>;
+    arrayCoalescing<GenericThis extends this = this>(): dataParsersExtended.DataParserUnionExtended<SimplifyTopLevel<Omit<dataParsers.DataParserDefinitionUnion, "options"> & {
+        readonly options: [
+            dataParsersExtended.DataParserArrayExtended<SimplifyTopLevel<Omit<dataParsers.DataParserDefinitionArray, "element"> & {
+                readonly element: GenericThis;
+            }>>,
+            dataParsersExtended.DataParserTransformExtended<SimplifyTopLevel<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction"> & {
+                readonly inner: GenericThis;
+                theFunction(input: Output<GenericThis>, error: DataParserError): Output<GenericThis>[];
+            }>>
+        ];
+    }>>;
+    pipe<GenericThis extends this = this, GenericOutput extends DataParsers = DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(output: GenericOutput, definition?: GenericDefinition): dataParsersExtended.DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
+        input: GenericThis;
+        output: GenericOutput;
+    }>>;
+    nullable<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+        inner: GenericThis;
+    }>>;
+    optional<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+        inner: GenericThis;
+    }>>;
+    or<GenericThis extends this = this, GenericDataParser extends DataParsers = DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(option: GenericDataParser, definition?: GenericDefinition): dataParsersExtended.DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
+        options: [GenericThis, GenericDataParser];
+    }>>;
+}
+export declare function dataParserExtendedInit<GenericDataParser extends DataParser, GenericDataParserExtended extends GenericDataParser & DataParserExtended>(dataParser: NoInfer<GenericDataParser>, rest: NoInfer<{
+    [Prop in Exclude<keyof GenericDataParserExtended, keyof (GenericDataParser & DataParserExtended)>]: GenericDataParserExtended[Prop] extends AnyFunction ? (self: GenericDataParserExtended, ...args: Parameters<GenericDataParserExtended[Prop]>) => ReturnType<GenericDataParserExtended[Prop]> : GenericDataParserExtended[Prop];
+}>): GenericDataParserExtended;
+export {};

package/dist/dataParser/baseExtended.mjs

@@ -0,0 +1,52 @@
+import { entries } from '../object/entries.mjs';
+import { createKind } from '../common/kind.mjs';
+import { pipe } from '../common/pipe.mjs';
+import { fromEntries } from '../object/fromEntries.mjs';
+import { entry } from '../object/entry.mjs';
+import { map } from '../array/map.mjs';
+import '../pattern/result.mjs';
+import { array } from './extended/array.mjs';
+import { transform } from './extended/transform.mjs';
+import { union } from './extended/union.mjs';
+import { nullable } from './extended/nullable.mjs';
+import { optional } from './extended/optional.mjs';
+import { pipe as pipe$1 } from './extended/pipe.mjs';
+
+const dataParserExtendedKind = createKind("data-parser-extended");
+function dataParserExtendedInit(dataParser, rest) {
+    const self = dataParserExtendedKind.setTo({
+        ...dataParser,
+        ...pipe(rest, entries, map(([key, value]) => entry(key, typeof value === "function"
+            ? (...args) => value(self, ...args)
+            : value)), fromEntries),
+        array(definition) {
+            return array(self, definition);
+        },
+        transform(theFunction, definition) {
+            return transform(self, theFunction, definition);
+        },
+        arrayCoalescing() {
+            return union([
+                self.array(),
+                self.transform((data) => [data]),
+            ]);
+        },
+        pipe(output, definition) {
+            return pipe$1(self, output, definition);
+        },
+        nullable(definition) {
+            return nullable(self, definition);
+        },
+        optional(definition) {
+            return optional(self, definition);
+        },
+        or(option, definition) {
+            return union([self, option], definition);
+        },
+        addChecker: (...checkers) => dataParserExtendedInit(dataParser.addChecker(...checkers), rest),
+        clone: () => dataParserExtendedInit(dataParser.clone(), rest),
+    });
+    return self;
+}
+
+export { dataParserExtendedInit, dataParserExtendedKind };

package/dist/dataParser/error.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
+const SymbolDataParserErrorIssue = Symbol.for(SymbolDataParserErrorIssueLabel);
+const dataParserErrorIssueKind = kind.createKind("data-parser-error-issue");
+const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
+const SymbolDataParserErrorPromiseIssue = Symbol.for(SymbolDataParserErrorPromiseIssueLabel);
+const dataParserErrorPromiseIssueKind = kind.createKind("data-parser-error-issue-promise");
+const dataParserErrorKind = kind.createKind("data-parser-error");
+function createError() {
+    return dataParserErrorKind.setTo({
+        issues: [],
+        currentPath: [],
+    });
+}
+function addIssue(error, source, data) {
+    error.issues.push(dataParserErrorIssueKind.setTo({
+        source,
+        path: error.currentPath.join("."),
+        data,
+    }));
+    return error;
+}
+function addPromiseIssue(error, source, data) {
+    error.issues.push(dataParserErrorPromiseIssueKind.setTo({
+        source,
+        path: error.currentPath.join("."),
+        data,
+    }));
+    return error;
+}
+function setErrorPath(error, value, index) {
+    error.currentPath[index] = value;
+    return error;
+}
+function popErrorPath(error) {
+    error.currentPath.pop();
+    return error;
+}
+
+exports.SymbolDataParserErrorIssue = SymbolDataParserErrorIssue;
+exports.SymbolDataParserErrorIssueLabel = SymbolDataParserErrorIssueLabel;
+exports.SymbolDataParserErrorPromiseIssue = SymbolDataParserErrorPromiseIssue;
+exports.SymbolDataParserErrorPromiseIssueLabel = SymbolDataParserErrorPromiseIssueLabel;
+exports.addIssue = addIssue;
+exports.addPromiseIssue = addPromiseIssue;
+exports.createError = createError;
+exports.dataParserErrorIssueKind = dataParserErrorIssueKind;
+exports.dataParserErrorKind = dataParserErrorKind;
+exports.dataParserErrorPromiseIssueKind = dataParserErrorPromiseIssueKind;
+exports.popErrorPath = popErrorPath;
+exports.setErrorPath = setErrorPath;

package/dist/dataParser/error.d.ts

@@ -0,0 +1,31 @@
+import { type Kind } from "../common";
+import { type DataParsers, type Checkers } from "./types";
+import { type DataParserTransform } from "./parsers";
+export declare const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
+export declare const SymbolDataParserErrorIssue: unique symbol;
+export type SymbolDataParserErrorIssue = typeof SymbolDataParserErrorIssue;
+export declare const dataParserErrorIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"data-parser-error-issue", unknown>>;
+export interface DataParserErrorIssue extends Kind<typeof dataParserErrorIssueKind.definition> {
+    readonly source: DataParsers | Checkers;
+    readonly path: string;
+    readonly data: unknown;
+}
+export declare const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
+export declare const SymbolDataParserErrorPromiseIssue: unique symbol;
+export type SymbolDataParserErrorPromiseIssue = typeof SymbolDataParserErrorPromiseIssue;
+export declare const dataParserErrorPromiseIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"data-parser-error-issue-promise", unknown>>;
+export interface DataParserErrorPromiseIssue extends Kind<typeof dataParserErrorPromiseIssueKind.definition> {
+    readonly source: DataParserTransform;
+    readonly path: string;
+    readonly data: unknown;
+}
+export declare const dataParserErrorKind: import("../common").KindHandler<import("../common").KindDefinition<"data-parser-error", unknown>>;
+export interface DataParserError extends Kind<typeof dataParserErrorKind.definition> {
+    readonly issues: (DataParserErrorIssue | DataParserErrorPromiseIssue)[];
+    readonly currentPath: string[];
+}
+export declare function createError(): DataParserError;
+export declare function addIssue(error: DataParserError, source: DataParsers | Checkers, data: unknown): DataParserError;
+export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown): DataParserError;
+export declare function setErrorPath(error: DataParserError, value: string, index: number): DataParserError;
+export declare function popErrorPath(error: DataParserError): DataParserError;

package/dist/dataParser/error.mjs

@@ -0,0 +1,41 @@
+import { createKind } from '../common/kind.mjs';
+
+const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
+const SymbolDataParserErrorIssue = Symbol.for(SymbolDataParserErrorIssueLabel);
+const dataParserErrorIssueKind = createKind("data-parser-error-issue");
+const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
+const SymbolDataParserErrorPromiseIssue = Symbol.for(SymbolDataParserErrorPromiseIssueLabel);
+const dataParserErrorPromiseIssueKind = createKind("data-parser-error-issue-promise");
+const dataParserErrorKind = createKind("data-parser-error");
+function createError() {
+    return dataParserErrorKind.setTo({
+        issues: [],
+        currentPath: [],
+    });
+}
+function addIssue(error, source, data) {
+    error.issues.push(dataParserErrorIssueKind.setTo({
+        source,
+        path: error.currentPath.join("."),
+        data,
+    }));
+    return error;
+}
+function addPromiseIssue(error, source, data) {
+    error.issues.push(dataParserErrorPromiseIssueKind.setTo({
+        source,
+        path: error.currentPath.join("."),
+        data,
+    }));
+    return error;
+}
+function setErrorPath(error, value, index) {
+    error.currentPath[index] = value;
+    return error;
+}
+function popErrorPath(error) {
+    error.currentPath.pop();
+    return error;
+}
+
+export { SymbolDataParserErrorIssue, SymbolDataParserErrorIssueLabel, SymbolDataParserErrorPromiseIssue, SymbolDataParserErrorPromiseIssueLabel, addIssue, addPromiseIssue, createError, dataParserErrorIssueKind, dataParserErrorKind, dataParserErrorPromiseIssueKind, popErrorPath, setErrorPath };

package/dist/dataParser/extended/array.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var index = require('../parsers/array/index.cjs');
+require('../../pattern/result.cjs');
+var max = require('../parsers/array/checkers/max.cjs');
+var min = require('../parsers/array/checkers/min.cjs');
+
+function array(element, definition) {
+    return baseExtended.dataParserExtendedInit(index.array(element, definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerArrayMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerArrayMax(max$1, definition));
+        },
+    });
+}
+
+exports.array = array;

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

@@ -0,0 +1,21 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type AddCheckersToDefinition, type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray> = (dataParsers.DataParserArray<GenericDefinition> & DataParserExtended);
+export interface DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray = dataParsers.DataParserDefinitionArray> extends _DataParserArrayExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserArrayCheckers,
+        ...dataParsers.DataParserArrayCheckers[]
+    ]>(...args: GenericChecker): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMin, "min">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerArrayMin
+    ]>>;
+    max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMax, "max">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerArrayMax
+    ]>>;
+}
+export declare function array<GenericElement extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
+    element: GenericElement;
+}>>;
+export {};

package/dist/dataParser/extended/array.mjs

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

package/dist/dataParser/extended/bigint.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var index = require('../parsers/bigint/index.cjs');
+require('../../pattern/result.cjs');
+var max = require('../parsers/bigint/checkers/max.cjs');
+var min = require('../parsers/bigint/checkers/min.cjs');
+
+function bigint(definition) {
+    return baseExtended.dataParserExtendedInit(index.bigint(definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerBigIntMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerBigIntMax(max$1, definition));
+        },
+    });
+}
+
+exports.bigint = bigint;

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;
+}>>;