@duplojs/utils 1.0.7 → 1.1.8

package/dist/dataParser/parsers/object.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+var entries = require('../../object/entries.cjs');
+var pipe = require('../../common/pipe.cjs');
+var forward = require('../../common/forward.cjs');
+var memo = require('../../common/memo.cjs');
+var filter = require('../../array/filter.cjs');
+var map = require('../../array/map.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+var kind = require('../kind.cjs');
+
+const dataParserObjectKind = kind.createDataParserKind("object");
+function object(shape, definition) {
+    return base.dataParserInit(dataParserObjectKind, {
+        definition: {
+            shape,
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            optimizedShape: memo.memo(() => pipe.pipe(forward.forward(shape), entries.entries, filter.filter((entry) => base.dataParserKind.has(entry[1])), map.map(([key, value]) => ({
+                key,
+                value,
+            })))),
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error$1.currentPath.length;
+            for (const entry of self.definition.optimizedShape.value) {
+                error.setErrorPath(error$1, entry.key, currentIndexPath);
+                const result = entry.value.exec(data[entry.key], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError
+                    && result !== undefined) {
+                    output[entry.key] = result;
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+        async: async (data, error$1, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error$1.currentPath.length;
+            for (const entry of self.definition.optimizedShape.value) {
+                error.setErrorPath(error$1, entry.key, currentIndexPath);
+                const result = await entry.value.asyncExec(data[entry.key], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError
+                    && result !== undefined) {
+                    output[entry.key] = result;
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+    });
+}
+
+exports.dataParserObjectKind = dataParserObjectKind;
+exports.object = object;

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

@@ -0,0 +1,26 @@
+import { type Kind, type IsEqual, type NeverCoalescing, type Memoized } from "../../common";
+import { dataParserKind, type Input, type Output, type DataParser, type DataParserDefinition } from "../base";
+import { type MergeDefinition, type DataParsers } from "../types";
+import * as DObject from "../../object";
+export type DataParserObjectShape = Readonly<Record<string, DataParsers>>;
+export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? DataParserObjectShape : {
+    -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Output<GenericShape[Prop]>;
+} extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
+export type DataParserObjectShapeInput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? DataParserObjectShape : {
+    -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Input<GenericShape[Prop]>;
+} extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
+export interface DataParserDefinitionObject extends DataParserDefinition<never> {
+    readonly shape: DataParserObjectShape;
+    readonly optimizedShape: Memoized<{
+        readonly key: string;
+        readonly value: DataParsers;
+    }[]>;
+}
+export declare const dataParserObjectKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/object", unknown>>;
+type _DataParserObject<GenericDefinition extends DataParserDefinitionObject> = (DataParser<GenericDefinition, DataParserObjectShapeOutput<GenericDefinition["shape"]>, DataParserObjectShapeInput<GenericDefinition["shape"]>> & Kind<typeof dataParserObjectKind.definition>);
+export interface DataParserObject<GenericDefinition extends DataParserDefinitionObject = DataParserDefinitionObject> extends _DataParserObject<GenericDefinition> {
+}
+export declare function object<const GenericShape extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+    shape: GenericShape;
+}>>;
+export {};

package/dist/dataParser/parsers/object.mjs

@@ -0,0 +1,71 @@
+import { entries } from '../../object/entries.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { forward } from '../../common/forward.mjs';
+import { memo } from '../../common/memo.mjs';
+import { filter } from '../../array/filter.mjs';
+import { map } from '../../array/map.mjs';
+import { dataParserInit, SymbolDataParserError, dataParserKind } from '../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserObjectKind = createDataParserKind("object");
+function object(shape, definition) {
+    return dataParserInit(dataParserObjectKind, {
+        definition: {
+            shape,
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            optimizedShape: memo(() => pipe(forward(shape), entries, filter((entry) => dataParserKind.has(entry[1])), map(([key, value]) => ({
+                key,
+                value,
+            })))),
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error.currentPath.length;
+            for (const entry of self.definition.optimizedShape.value) {
+                setErrorPath(error, entry.key, currentIndexPath);
+                const result = entry.value.exec(data[entry.key], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError
+                    && result !== undefined) {
+                    output[entry.key] = result;
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+        async: async (data, error, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error.currentPath.length;
+            for (const entry of self.definition.optimizedShape.value) {
+                setErrorPath(error, entry.key, currentIndexPath);
+                const result = await entry.value.asyncExec(data[entry.key], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError
+                    && result !== undefined) {
+                    output[entry.key] = result;
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+    });
+}
+
+export { dataParserObjectKind, object };

package/dist/dataParser/parsers/optional.cjs

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

package/dist/dataParser/parsers/optional.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 DataParserDefinitionOptional extends DataParserDefinition<never> {
+    readonly inner: DataParsers;
+}
+export declare const dataParserOptionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/optional", unknown>>;
+type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | undefined, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof dataParserOptionalKind.definition>);
+export interface DataParserOptional<GenericDefinition extends DataParserDefinitionOptional = DataParserDefinitionOptional> extends _DataParserOptional<GenericDefinition> {
+}
+export declare function optional<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/parsers/optional.mjs

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

package/dist/dataParser/parsers/pipe.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var base = require('../base.cjs');
+var kind = require('../kind.cjs');
+
+const dataParserPipeKind = kind.createDataParserKind("pipe");
+function pipe(input, output, definition) {
+    return base.dataParserInit(dataParserPipeKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            input,
+            output,
+        },
+    }, {
+        sync: (data, error, self) => {
+            const result = self.definition.input.exec(data, error);
+            if (result === base.SymbolDataParserError) {
+                return base.SymbolDataParserError;
+            }
+            return self.definition.output.exec(result, error);
+        },
+        async: async (data, error, self) => {
+            const result = await self.definition.input.asyncExec(data, error);
+            if (result === base.SymbolDataParserError) {
+                return base.SymbolDataParserError;
+            }
+            return self.definition.output.asyncExec(result, error);
+        },
+    });
+}
+
+exports.dataParserPipeKind = dataParserPipeKind;
+exports.pipe = pipe;

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

@@ -0,0 +1,16 @@
+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 DataParserDefinitionPipe extends DataParserDefinition<never> {
+    readonly input: DataParsers;
+    readonly output: DataParsers;
+}
+export declare const dataParserPipeKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/pipe", unknown>>;
+type _DataParserPipe<GenericDefinition extends DataParserDefinitionPipe> = (DataParser<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>> & Kind<typeof dataParserPipeKind.definition>);
+export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPipe = DataParserDefinitionPipe> extends _DataParserPipe<GenericDefinition> {
+}
+export declare function pipe<GenericInput extends DataParsers, GenericOutput extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
+    input: GenericInput;
+    output: GenericOutput;
+}>>;
+export {};

package/dist/dataParser/parsers/pipe.mjs

@@ -0,0 +1,31 @@
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserPipeKind = createDataParserKind("pipe");
+function pipe(input, output, definition) {
+    return dataParserInit(dataParserPipeKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            input,
+            output,
+        },
+    }, {
+        sync: (data, error, self) => {
+            const result = self.definition.input.exec(data, error);
+            if (result === SymbolDataParserError) {
+                return SymbolDataParserError;
+            }
+            return self.definition.output.exec(result, error);
+        },
+        async: async (data, error, self) => {
+            const result = await self.definition.input.asyncExec(data, error);
+            if (result === SymbolDataParserError) {
+                return SymbolDataParserError;
+            }
+            return self.definition.output.asyncExec(result, error);
+        },
+    });
+}
+
+export { dataParserPipeKind, pipe };

package/dist/dataParser/parsers/record.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+var kind = require('../kind.cjs');
+
+const dataParserRecordKind = kind.createDataParserKind("record");
+function record(key, value, definition) {
+    return base.dataParserInit(dataParserRecordKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            key,
+            value,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error$1.currentPath.length;
+            for (const key in data) {
+                error.setErrorPath(error$1, key, currentIndexPath);
+                const resultKey = self
+                    .definition
+                    .key
+                    .exec(key, error$1);
+                if (resultKey === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                const resultValue = self
+                    .definition
+                    .value
+                    .exec(data[key], error$1);
+                if (resultValue === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                if (output !== base.SymbolDataParserError) {
+                    output[resultKey] = resultValue;
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+        async: async (data, error$1, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error$1.currentPath.length;
+            for (const key in data) {
+                error.setErrorPath(error$1, key, currentIndexPath);
+                const resultKey = await self
+                    .definition
+                    .key
+                    .asyncExec(key, error$1);
+                if (resultKey === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                const resultValue = await self
+                    .definition
+                    .value
+                    .asyncExec(data[key], error$1);
+                if (resultValue === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                if (output !== base.SymbolDataParserError) {
+                    output[resultKey] = resultValue;
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+    });
+}
+
+exports.dataParserRecordKind = dataParserRecordKind;
+exports.record = record;

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

@@ -0,0 +1,30 @@
+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";
+import { type DataParserString } from "./string";
+import { type DataParserTemplateLiteral } from "./templateLiteral";
+import { type DataParserDefinitionLiteral, type DataParserLiteral } from "./literal";
+import { type DataParserDefinitionNumber, type DataParserNumber } from "./number";
+import { type DataParserDefinitionUnion, type DataParserUnion } from "./union";
+export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral | DataParserLiteral<DataParserDefinitionLiteral & {
+    value: string[];
+}> | DataParserNumber<DataParserDefinitionNumber & {
+    coerce: true;
+}> | DataParserUnion<DataParserDefinitionUnion & {
+    options: DataParserRecordKey[];
+}>);
+export interface DataParserDefinitionRecord extends DataParserDefinition<never> {
+    readonly key: DataParserRecordKey;
+    readonly value: DataParsers;
+}
+export declare const dataParserRecordKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/record", unknown>>;
+export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers> = Extract<Record<Output<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Output<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
+export type DataParserRecordShapeInput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers> = Extract<Record<Input<GenericDataParserKey> extends infer InferredKey extends string | number ? InferredKey : never, Input<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
+type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredOutput ? InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof dataParserRecordKind.definition>);
+export interface DataParserRecord<GenericDefinition extends DataParserDefinitionRecord = DataParserDefinitionRecord> extends _DataParserRecord<GenericDefinition> {
+}
+export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
+    key: GenericDataParserKey;
+    value: GenericDataParserValue;
+}>>;
+export {};

package/dist/dataParser/parsers/record.mjs

@@ -0,0 +1,80 @@
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserRecordKind = createDataParserKind("record");
+function record(key, value, definition) {
+    return dataParserInit(dataParserRecordKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            key,
+            value,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error.currentPath.length;
+            for (const key in data) {
+                setErrorPath(error, key, currentIndexPath);
+                const resultKey = self
+                    .definition
+                    .key
+                    .exec(key, error);
+                if (resultKey === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                const resultValue = self
+                    .definition
+                    .value
+                    .exec(data[key], error);
+                if (resultValue === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                if (output !== SymbolDataParserError) {
+                    output[resultKey] = resultValue;
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+        async: async (data, error, self) => {
+            if (!data
+                || typeof data !== "object"
+                || data instanceof Array) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = {};
+            const currentIndexPath = error.currentPath.length;
+            for (const key in data) {
+                setErrorPath(error, key, currentIndexPath);
+                const resultKey = await self
+                    .definition
+                    .key
+                    .asyncExec(key, error);
+                if (resultKey === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                const resultValue = await self
+                    .definition
+                    .value
+                    .asyncExec(data[key], error);
+                if (resultValue === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                if (output !== SymbolDataParserError) {
+                    output[resultKey] = resultValue;
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+    });
+}
+
+export { dataParserRecordKind, record };

package/dist/dataParser/parsers/string/checkers/email.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var index = require('../index.cjs');
+var kind = require('../../../kind.cjs');
+
+const dataParserCheckerEmailKind = kind.createDataParserKind("checker-string-email");
+const emailPattern = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
+function checkerEmail(definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerEmailKind, {
+        definition: {
+            ...definition,
+            pattern: emailPattern,
+        },
+    }, (input, self) => {
+        if (!self.definition.pattern.test(input)) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return self.definition.normalize ? input.toLowerCase() : input;
+    });
+}
+function email(definition) {
+    return index.string({
+        checkers: [checkerEmail(definition)],
+    });
+}
+
+exports.checkerEmail = checkerEmail;
+exports.dataParserCheckerEmailKind = dataParserCheckerEmailKind;
+exports.email = email;

package/dist/dataParser/parsers/string/checkers/email.d.ts

@@ -0,0 +1,17 @@
+import { type Kind } from "../../../../common";
+import { type DataParserChecker, type DataParserCheckerDefinition } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionEmail extends DataParserCheckerDefinition {
+    normalize?: boolean;
+    pattern: RegExp;
+}
+export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-email", unknown>>;
+type _DataParserCheckerEmail = (Kind<typeof dataParserCheckerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
+export interface DataParserCheckerEmail extends _DataParserCheckerEmail {
+}
+export declare function checkerEmail(definition?: Partial<DataParserCheckerDefinitionEmail>): DataParserCheckerEmail;
+export declare function email(definition?: Partial<DataParserCheckerDefinitionEmail>): import("..").DataParserString<{
+    readonly checkers: readonly [DataParserCheckerEmail];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

package/dist/dataParser/parsers/string/checkers/email.mjs

@@ -0,0 +1,27 @@
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { string } from '../index.mjs';
+import { createDataParserKind } from '../../../kind.mjs';
+
+const dataParserCheckerEmailKind = createDataParserKind("checker-string-email");
+const emailPattern = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
+function checkerEmail(definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerEmailKind, {
+        definition: {
+            ...definition,
+            pattern: emailPattern,
+        },
+    }, (input, self) => {
+        if (!self.definition.pattern.test(input)) {
+            return SymbolDataParserErrorIssue;
+        }
+        return self.definition.normalize ? input.toLowerCase() : input;
+    });
+}
+function email(definition) {
+    return string({
+        checkers: [checkerEmail(definition)],
+    });
+}
+
+export { checkerEmail, dataParserCheckerEmailKind, email };

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

@@ -0,0 +1,5 @@
+export * from "./url";
+export * from "./email";
+export * from "./max";
+export * from "./min";
+export * from "./regex";

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var kind = require('../../../kind.cjs');
+
+const dataParserCheckerStringMaxKind = kind.createDataParserKind("checker-string-max");
+function checkerStringMax(max, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (value, self) => value.length <= self.definition.max ? value : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerStringMax = checkerStringMax;
+exports.dataParserCheckerStringMaxKind = dataParserCheckerStringMaxKind;

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

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionStringMax extends DataParserCheckerDefinition {
+    max: number;
+}
+export declare const dataParserCheckerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-max", unknown>>;
+type _DataParserCheckerStringMax = (Kind<typeof dataParserCheckerStringMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMax, string>);
+export interface DataParserCheckerStringMax extends _DataParserCheckerStringMax {
+}
+export declare function checkerStringMax(max: number, definition?: Partial<Omit<DataParserCheckerDefinitionStringMax, "max">>): DataParserCheckerStringMax;
+export {};