@duplojs/utils 1.0.7 → 1.1.7

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerStringMaxKind = kind.createKind("data-parser-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<"data-parser-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 {};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+
+const dataParserCheckerStringRegexKind = kind.createKind("data-parser-checker-string-regex");
+function checkerStringRegex(regex, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+        definition: {
+            ...definition,
+            regex,
+        },
+    }, (value, self) => self.definition.regex.test(value)
+        ? value
+        : error.SymbolDataParserErrorIssue);
+}
+
+exports.checkerStringRegex = checkerStringRegex;
+exports.dataParserCheckerStringRegexKind = dataParserCheckerStringRegexKind;

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

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionStringRegex extends DataParserCheckerDefinition {
+    regex: RegExp;
+}
+export declare const dataParserCheckerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-string-regex", unknown>>;
+type _DataParserCheckerStringRegex = (Kind<typeof dataParserCheckerStringRegexKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringRegex, string>);
+export interface DataParserCheckerStringRegex extends _DataParserCheckerStringRegex {
+}
+export declare function checkerStringRegex(regex: RegExp, definition?: Partial<Omit<DataParserCheckerDefinitionStringRegex, "regex">>): DataParserCheckerStringRegex;
+export {};

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

@@ -0,0 +1,17 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+
+const dataParserCheckerStringRegexKind = createKind("data-parser-checker-string-regex");
+function checkerStringRegex(regex, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+        definition: {
+            ...definition,
+            regex,
+        },
+    }, (value, self) => self.definition.regex.test(value)
+        ? value
+        : SymbolDataParserErrorIssue);
+}
+
+export { checkerStringRegex, dataParserCheckerStringRegexKind };

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

@@ -0,0 +1,48 @@
+'use strict';
+
+var kind = require('../../../../common/kind.cjs');
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var index = require('../index.cjs');
+
+const dataParserCheckerUrlKind = kind.createKind("data-parser-checker-url");
+const regexRemoveDote = /:$/;
+function checkerUrl(definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerUrlKind, {
+        definition: definition,
+    }, (input, self) => {
+        try {
+            const url = new URL(input);
+            if (self.definition.hostname) {
+                self.definition.hostname.lastIndex = 0;
+                if (!self.definition.hostname.test(url.hostname)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.protocol) {
+                self.definition.protocol.lastIndex = 0;
+                if (!self.definition.protocol.test(url.protocol.replace(regexRemoveDote, ""))) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.normalize) {
+                return url.href;
+            }
+            else {
+                return input;
+            }
+        }
+        catch {
+            return error.SymbolDataParserErrorIssue;
+        }
+    });
+}
+function url(definition) {
+    return index.string({
+        checkers: [checkerUrl(definition)],
+    });
+}
+
+exports.checkerUrl = checkerUrl;
+exports.dataParserCheckerUrlKind = dataParserCheckerUrlKind;
+exports.url = url;

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

@@ -0,0 +1,18 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionUrl extends DataParserCheckerDefinition {
+    hostname?: RegExp;
+    protocol?: RegExp;
+    normalize?: boolean;
+}
+export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"data-parser-checker-url", unknown>>;
+type _DataParserCheckerUrl = (Kind<typeof dataParserCheckerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
+export interface DataParserCheckerUrl extends _DataParserCheckerUrl {
+}
+export declare function checkerUrl(definition?: Partial<DataParserCheckerDefinitionUrl>): DataParserCheckerUrl;
+export declare function url(definition?: Partial<DataParserCheckerDefinitionUrl>): import("..").DataParserString<{
+    readonly checkers: readonly [DataParserCheckerUrl];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

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

@@ -0,0 +1,44 @@
+import { createKind } from '../../../../common/kind.mjs';
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { string } from '../index.mjs';
+
+const dataParserCheckerUrlKind = createKind("data-parser-checker-url");
+const regexRemoveDote = /:$/;
+function checkerUrl(definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerUrlKind, {
+        definition: definition,
+    }, (input, self) => {
+        try {
+            const url = new URL(input);
+            if (self.definition.hostname) {
+                self.definition.hostname.lastIndex = 0;
+                if (!self.definition.hostname.test(url.hostname)) {
+                    return SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.protocol) {
+                self.definition.protocol.lastIndex = 0;
+                if (!self.definition.protocol.test(url.protocol.replace(regexRemoveDote, ""))) {
+                    return SymbolDataParserErrorIssue;
+                }
+            }
+            if (self.definition.normalize) {
+                return url.href;
+            }
+            else {
+                return input;
+            }
+        }
+        catch {
+            return SymbolDataParserErrorIssue;
+        }
+    });
+}
+function url(definition) {
+    return string({
+        checkers: [checkerUrl(definition)],
+    });
+}
+
+export { checkerUrl, dataParserCheckerUrlKind, url };

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

package/dist/dataParser/parsers/string/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 DataParserCheckerUrl, type DataParserCheckerEmail, type DataParserCheckerStringMin, type DataParserCheckerStringMax, type DataParserCheckerStringRegex } from "./checkers";
+export * from "./checkers";
+export type DataParserStringCheckers = (DataParserCheckerUrl | DataParserCheckerEmail | DataParserCheckerStringMin | DataParserCheckerStringMax | DataParserCheckerStringRegex);
+export interface DataParserDefinitionString extends DataParserDefinition<DataParserStringCheckers> {
+    readonly coerce: boolean;
+}
+export declare const dataParserStringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"data-parser-string", unknown>>;
+type _DataParserString<GenericDefinition extends DataParserDefinitionString> = (DataParser<GenericDefinition, string, string> & Kind<typeof dataParserStringKind.definition>);
+export interface DataParserString<GenericDefinition extends DataParserDefinitionString = DataParserDefinitionString> extends _DataParserString<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserStringCheckers,
+        ...DataParserStringCheckers[]
+    ]>(...args: GenericChecker): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function string<const GenericDefinition extends Partial<DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserString<MergeDefinition<DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;

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

@@ -0,0 +1,28 @@
+import { createKind } from '../../../common/kind.mjs';
+import { dataParserInit } from '../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../error.mjs';
+
+const dataParserStringKind = createKind("data-parser-string");
+function string(definition) {
+    return dataParserInit(dataParserStringKind, {
+        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 = String(data);
+            }
+            catch { }
+        }
+        if (typeof data === "string") {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserStringKind, string };

package/dist/dataParser/parsers/templateLiteral.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var escapeRegExp = require('../../common/escapeRegExp.cjs');
+var kind = require('../../common/kind.cjs');
+var pipe = require('../../common/pipe.cjs');
+var innerPipe = require('../../common/innerPipe.cjs');
+var when$1 = require('../../common/when.cjs');
+var isType = require('../../common/isType.cjs');
+var whenElse = require('../../common/whenElse.cjs');
+var map = require('../../array/map.cjs');
+var join = require('../../array/join.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+require('../../pattern/result.cjs');
+var exhaustive = require('../../pattern/exhaustive.cjs');
+var when = require('../../pattern/when.cjs');
+var replace = require('../../string/replace.cjs');
+var index = require('./string/index.cjs');
+var index$2 = require('./number/index.cjs');
+var index$1 = require('./bigint/index.cjs');
+var literal = require('./literal.cjs');
+var empty = require('./empty.cjs');
+var nil = require('./nil.cjs');
+var boolean = require('./boolean.cjs');
+
+const dataParserTemplateLiteralKind = kind.createKind("data-parser-template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe.pipe(template, map.map(innerPipe.innerPipe(when.when(isType.isType("string"), (value) => `(?:${escapeRegExp.escapeRegExp(value)})`), when.when(index$2.dataParserNumberKind.has, () => "(:?[0-9]+)"), when.when(index$1.dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.dataParserBooleanKind.has, () => "(?:true|false)"), when.when(nil.dataParserNilKind.has, () => "(?:null)"), when.when(empty.dataParserEmptyKind.has, () => "(?:undefined)"), when.when(literal.dataParserLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp)), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index.dataParserStringKind.has, innerPipe.innerPipe(whenElse.whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe.pipe(dataParser.definition.checkers, map.map((element) => pipe.pipe(element.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""))), join.join("")), () => "(?:[^]*)"))), when.when(dataParserTemplateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive)), join.join(""), (pattern) => new RegExp(`^${pattern}$`));
+    return base.dataParserInit(dataParserTemplateLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            template,
+            pattern,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "string" && self.definition.pattern.test(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.dataParserTemplateLiteralKind = dataParserTemplateLiteralKind;
+exports.templateLiteral = templateLiteral;

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

@@ -0,0 +1,49 @@
+import { type Adaptor, type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type MergeDefinition } from "../../dataParser/types";
+import { type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "./string";
+import { type DataParserDefinitionNumber, type DataParserNumber } from "./number";
+import { type DataParserDefinitionBigInt, type DataParserBigInt } from "./bigint";
+import { type DataParserDefinitionLiteral, type DataParserLiteral } from "./literal";
+import { type DataParserDefinitionEmpty, type DataParserEmpty } from "./empty";
+import { type DataParserDefinitionNil, type DataParserNil } from "./nil";
+import { type DataParserDefinitionBoolean, type DataParserBoolean } from "./boolean";
+export type DataParsersTemplateLiteral = (string | DataParserString<DataParserDefinitionString & {
+    readonly checkers: readonly (DataParserCheckerEmail)[];
+}> | DataParserNumber<DataParserDefinitionNumber & {
+    readonly checkers: readonly [];
+}> | DataParserBigInt<DataParserDefinitionBigInt & {
+    readonly checkers: readonly [];
+}> | DataParserBoolean<DataParserDefinitionBoolean & {
+    readonly checkers: readonly [];
+}> | DataParserLiteral<DataParserDefinitionLiteral & {
+    readonly checkers: readonly [];
+}> | DataParserEmpty<DataParserDefinitionEmpty & {
+    readonly checkers: readonly [];
+}> | DataParserNil<DataParserDefinitionNil & {
+    readonly checkers: readonly [];
+}> | DataParserTemplateLiteral<DataParserDefinitionTemplateLiteral & {
+    readonly checkers: readonly [];
+}>);
+export type TemplateLiteralShape = readonly [DataParsersTemplateLiteral, ...DataParsersTemplateLiteral[]];
+type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
+export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends DataParsersTemplateLiteral,
+    ...infer InferredRest extends DataParsersTemplateLiteral[]
+] ? (`${GenericLastResult}${InferredFirst extends string ? InferredFirst : Adaptor<Output<Exclude<InferredFirst, string>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeOutput<InferredRest, InferredResult> : TemplateLiteralShapeOutput<[InferredRest[number]], InferredResult> : never : never;
+export type TemplateLiteralShapeInput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends DataParsersTemplateLiteral,
+    ...infer InferredRest extends DataParsersTemplateLiteral[]
+] ? (`${GenericLastResult}${InferredFirst extends string ? InferredFirst : Adaptor<Input<Exclude<InferredFirst, string>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeInput<InferredRest, InferredResult> : TemplateLiteralShapeInput<[InferredRest[number]], InferredResult> : never : never;
+export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<never> {
+    readonly template: TemplateLiteralShape;
+    readonly pattern: RegExp;
+}
+export declare const dataParserTemplateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-template-literal", unknown>>;
+type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof dataParserTemplateLiteralKind.definition>);
+export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
+}
+export declare function templateLiteral<const GenericTemplate extends TemplateLiteralShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
+    template: GenericTemplate;
+}>>;
+export {};

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -0,0 +1,42 @@
+import { escapeRegExp } from '../../common/escapeRegExp.mjs';
+import { createKind } from '../../common/kind.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { innerPipe } from '../../common/innerPipe.mjs';
+import { when as when$1 } from '../../common/when.mjs';
+import { isType } from '../../common/isType.mjs';
+import { whenElse } from '../../common/whenElse.mjs';
+import { map } from '../../array/map.mjs';
+import { join } from '../../array/join.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+import '../../pattern/result.mjs';
+import { exhaustive } from '../../pattern/exhaustive.mjs';
+import { when } from '../../pattern/when.mjs';
+import { replace } from '../../string/replace.mjs';
+import { dataParserStringKind } from './string/index.mjs';
+import { dataParserNumberKind } from './number/index.mjs';
+import { dataParserBigIntKind } from './bigint/index.mjs';
+import { dataParserLiteralKind } from './literal.mjs';
+import { dataParserEmptyKind } from './empty.mjs';
+import { dataParserNilKind } from './nil.mjs';
+import { dataParserBooleanKind } from './boolean.mjs';
+
+const dataParserTemplateLiteralKind = createKind("data-parser-template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(dataParserNumberKind.has, () => "(:?[0-9]+)"), when(dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when(dataParserBooleanKind.has, () => "(?:true|false)"), when(dataParserNilKind.has, () => "(?:null)"), when(dataParserEmptyKind.has, () => "(?:undefined)"), when(dataParserLiteralKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(dataParserStringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(dataParserTemplateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
+    return dataParserInit(dataParserTemplateLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            template,
+            pattern,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "string" && self.definition.pattern.test(data)) {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { dataParserTemplateLiteralKind, templateLiteral };

package/dist/dataParser/parsers/transform.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserTransformKind = kind.createKind("data-parser-transform");
+function transform(inner, theFunction, definition) {
+    return base.dataParserInit(dataParserTransformKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+            theFunction,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            const innerResult = self.definition.inner.exec(data, error$1);
+            if (innerResult === base.SymbolDataParserError) {
+                return base.SymbolDataParserError;
+            }
+            const result = self.definition.theFunction(innerResult, error$1);
+            if (result instanceof Promise) {
+                return error.SymbolDataParserErrorPromiseIssue;
+            }
+            return result;
+        },
+        async: async (data, error$1, self) => {
+            const innerResult = await self.definition.inner.asyncExec(data, error$1);
+            if (innerResult === base.SymbolDataParserError) {
+                return base.SymbolDataParserError;
+            }
+            let result = self.definition.theFunction(innerResult, error$1);
+            if (result instanceof Promise) {
+                result = result.catch(() => error.SymbolDataParserErrorPromiseIssue);
+            }
+            return result;
+        },
+    });
+}
+
+exports.dataParserTransformKind = dataParserTransformKind;
+exports.transform = transform;

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

@@ -0,0 +1,17 @@
+import { type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError } from "../base";
+import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type DataParserError, type SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from "../../dataParser/error";
+export interface DataParserDefinitionTransform extends DataParserDefinition<never> {
+    readonly inner: DataParsers;
+    theFunction(input: any, error: DataParserError): unknown;
+}
+export declare const dataParserTransformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-transform", unknown>>;
+type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, Exclude<Awaited<ReturnType<GenericDefinition["theFunction"]>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>, Input<GenericDefinition["inner"]>> & Kind<typeof dataParserTransformKind.definition>);
+export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
+}
+export declare function transform<GenericDataParser extends DataParsers, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+    theFunction(input: Output<GenericDataParser>): GenericOutput;
+}>>;
+export {};

package/dist/dataParser/parsers/transform.mjs

@@ -0,0 +1,40 @@
+import { createKind } from '../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorPromiseIssue } from '../error.mjs';
+
+const dataParserTransformKind = createKind("data-parser-transform");
+function transform(inner, theFunction, definition) {
+    return dataParserInit(dataParserTransformKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            inner,
+            theFunction,
+        },
+    }, {
+        sync: (data, error, self) => {
+            const innerResult = self.definition.inner.exec(data, error);
+            if (innerResult === SymbolDataParserError) {
+                return SymbolDataParserError;
+            }
+            const result = self.definition.theFunction(innerResult, error);
+            if (result instanceof Promise) {
+                return SymbolDataParserErrorPromiseIssue;
+            }
+            return result;
+        },
+        async: async (data, error, self) => {
+            const innerResult = await self.definition.inner.asyncExec(data, error);
+            if (innerResult === SymbolDataParserError) {
+                return SymbolDataParserError;
+            }
+            let result = self.definition.theFunction(innerResult, error);
+            if (result instanceof Promise) {
+                result = result.catch(() => SymbolDataParserErrorPromiseIssue);
+            }
+            return result;
+        },
+    });
+}
+
+export { dataParserTransformKind, transform };