@duplojs/utils 1.0.6 → 1.1.7

package/dist/dataParser/index.mjs

@@ -0,0 +1,38 @@
+export { SymbolDataParserError, SymbolDataParserErrorLabel, dataParserCheckerInit, dataParserCheckerKind, dataParserInit, dataParserKind } from './base.mjs';
+export { dataParserExtendedInit, dataParserExtendedKind } from './baseExtended.mjs';
+export { SymbolDataParserErrorIssue, SymbolDataParserErrorIssueLabel, SymbolDataParserErrorPromiseIssue, SymbolDataParserErrorPromiseIssueLabel, addIssue, addPromiseIssue, createError, dataParserErrorIssueKind, dataParserErrorKind, dataParserErrorPromiseIssueKind, popErrorPath, setErrorPath } from './error.mjs';
+import * as index$1 from './parsers/coerce/index.mjs';
+export { index$1 as coerce };
+export { dataParserStringKind, string } from './parsers/string/index.mjs';
+export { dataParserObjectKind, object } from './parsers/object.mjs';
+export { dataParserNumberKind, number } from './parsers/number/index.mjs';
+export { dataParserLiteralKind, literal } from './parsers/literal.mjs';
+export { dataParserUnionKind, union } from './parsers/union.mjs';
+export { array, dataParserArrayKind } from './parsers/array/index.mjs';
+export { bigint, dataParserBigIntKind } from './parsers/bigint/index.mjs';
+export { dataParserTupleKind, tuple } from './parsers/tuple.mjs';
+export { dataParserTransformKind, transform } from './parsers/transform.mjs';
+export { dataParserNilKind, nil } from './parsers/nil.mjs';
+export { boolean, dataParserBooleanKind } from './parsers/boolean.mjs';
+export { dataParserEmptyKind, empty } from './parsers/empty.mjs';
+export { dataParserTemplateLiteralKind, templateLiteral } from './parsers/templateLiteral.mjs';
+export { dataParserPipeKind, pipe } from './parsers/pipe.mjs';
+export { dataParserOptionalKind, optional } from './parsers/optional.mjs';
+export { dataParserNullableKind, nullable } from './parsers/nullable.mjs';
+export { dataParserLazyKind, lazy } from './parsers/lazy.mjs';
+export { dataParserUnknownKind, unknown } from './parsers/unknown.mjs';
+export { dataParserRecordKind, record } from './parsers/record.mjs';
+import * as index from './extended/index.mjs';
+export { index as extended };
+export { checkerUrl, dataParserCheckerUrlKind, url } from './parsers/string/checkers/url.mjs';
+export { checkerEmail, dataParserCheckerEmailKind, email } from './parsers/string/checkers/email.mjs';
+export { checkerStringMax, dataParserCheckerStringMaxKind } from './parsers/string/checkers/max.mjs';
+export { checkerStringMin, dataParserCheckerStringMinKind } from './parsers/string/checkers/min.mjs';
+export { checkerStringRegex, dataParserCheckerStringRegexKind } from './parsers/string/checkers/regex.mjs';
+export { checkerInt, dataParserCheckerIntKind, int } from './parsers/number/checkers/int.mjs';
+export { checkerNumberMin, dataParserCheckerNumberMinKind } from './parsers/number/checkers/min.mjs';
+export { checkerNumberMax, dataParserCheckerNumberMaxKind } from './parsers/number/checkers/max.mjs';
+export { checkerArrayMin, dataParserCheckerArrayMinKind } from './parsers/array/checkers/min.mjs';
+export { checkerArrayMax, dataParserCheckerArrayMaxKind } from './parsers/array/checkers/max.mjs';
+export { checkerBigIntMin, dataParserCheckerBigIntMinKind } from './parsers/bigint/checkers/min.mjs';
+export { checkerBigIntMax, dataParserCheckerBigIntMaxKind } from './parsers/bigint/checkers/max.mjs';

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

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

package/dist/dataParser/parsers/array/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 dataParserCheckerArrayMaxKind = kind.createKind("data-parser-checker-array-max");
+function checkerArrayMax(max, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerArrayMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (data, self) => {
+        if (data.length > self.definition.max) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return data;
+    });
+}
+
+exports.checkerArrayMax = checkerArrayMax;
+exports.dataParserCheckerArrayMaxKind = dataParserCheckerArrayMaxKind;

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

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionArrayMax extends DataParserCheckerDefinition {
+    max: number;
+}
+export declare const dataParserCheckerArrayMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-array-max", unknown>>;
+type _DataParserCheckerArrayMax = (Kind<typeof dataParserCheckerArrayMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMax, unknown[]>);
+export interface DataParserCheckerArrayMax extends _DataParserCheckerArrayMax {
+}
+export declare function checkerArrayMax(max: number, definition?: Partial<Omit<DataParserCheckerDefinitionArrayMax, "max">>): DataParserCheckerArrayMax;
+export {};

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

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

package/dist/dataParser/parsers/array/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 dataParserCheckerArrayMinKind = kind.createKind("data-parser-checker-array-min");
+function checkerArrayMin(min, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerArrayMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (data, self) => {
+        if (data.length < self.definition.min) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return data;
+    });
+}
+
+exports.checkerArrayMin = checkerArrayMin;
+exports.dataParserCheckerArrayMinKind = dataParserCheckerArrayMinKind;

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

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionArrayMin extends DataParserCheckerDefinition {
+    min: number;
+}
+export declare const dataParserCheckerArrayMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-array-min", unknown>>;
+type _DataParserCheckerArrayMin = (Kind<typeof dataParserCheckerArrayMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMin, unknown[]>);
+export interface DataParserCheckerArrayMin extends _DataParserCheckerArrayMin {
+}
+export declare function checkerArrayMin(min: number, definition?: Partial<Omit<DataParserCheckerDefinitionArrayMin, "min">>): DataParserCheckerArrayMin;
+export {};

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

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

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