@duplojs/utils 1.1.13 → 1.1.14

package/dist/dataParser/parsers/refine.mjs

@@ -0,0 +1,15 @@
+import { dataParserCheckerInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserCheckerRefineKind = createDataParserKind("checker-string-max");
+function checkerRefine(theFunction, definition) {
+    return dataParserCheckerInit(dataParserCheckerRefineKind, {
+        definition: {
+            ...definition,
+            theFunction,
+        },
+    }, (value, self) => self.definition.theFunction(value) ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerRefine, dataParserCheckerRefineKind };

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

@@ -5,10 +5,10 @@ var error = require('../../../error.cjs');
 var index = require('../index.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerEmailKind = kind.createDataParserKind("checker-string-email");
+const checkerEmailKind = 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, {
+    return base.dataParserCheckerInit(checkerEmailKind, {
         definition: {
             ...definition,
             pattern: emailPattern,
@@ -27,5 +27,5 @@ function email(definition) {
 }
 
 exports.checkerEmail = checkerEmail;
-exports.dataParserCheckerEmailKind = dataParserCheckerEmailKind;
+exports.checkerEmailKind = checkerEmailKind;
 exports.email = email;

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

@@ -4,8 +4,8 @@ export interface DataParserCheckerDefinitionEmail extends DataParserCheckerDefin
     normalize?: boolean;
     pattern: RegExp;
 }
-export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-email", unknown>>;
-type _DataParserCheckerEmail = (Kind<typeof dataParserCheckerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
+export declare const checkerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-email", unknown>>;
+type _DataParserCheckerEmail = (Kind<typeof checkerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
 export interface DataParserCheckerEmail extends _DataParserCheckerEmail {
 }
 export declare function checkerEmail(definition?: Partial<DataParserCheckerDefinitionEmail>): DataParserCheckerEmail;

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

@@ -3,10 +3,10 @@ import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { string } from '../index.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerEmailKind = createDataParserKind("checker-string-email");
+const checkerEmailKind = 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, {
+    return dataParserCheckerInit(checkerEmailKind, {
         definition: {
             ...definition,
             pattern: emailPattern,
@@ -24,4 +24,4 @@ function email(definition) {
     });
 }
 
-export { checkerEmail, dataParserCheckerEmailKind, email };
+export { checkerEmail, checkerEmailKind, email };

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

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerStringMaxKind = kind.createDataParserKind("checker-string-max");
+const checkerStringMaxKind = kind.createDataParserKind("checker-string-max");
 function checkerStringMax(max, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+    return base.dataParserCheckerInit(checkerStringMaxKind, {
         definition: {
             ...definition,
             max,
@@ -15,4 +15,4 @@ function checkerStringMax(max, definition = {}) {
 }
 
 exports.checkerStringMax = checkerStringMax;
-exports.dataParserCheckerStringMaxKind = dataParserCheckerStringMaxKind;
+exports.checkerStringMaxKind = checkerStringMaxKind;

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

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

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

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerStringMaxKind = createDataParserKind("checker-string-max");
+const checkerStringMaxKind = createDataParserKind("checker-string-max");
 function checkerStringMax(max, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerStringMaxKind, {
+    return dataParserCheckerInit(checkerStringMaxKind, {
         definition: {
             ...definition,
             max,
@@ -12,4 +12,4 @@ function checkerStringMax(max, definition = {}) {
     }, (value, self) => value.length <= self.definition.max ? value : SymbolDataParserErrorIssue);
 }
 
-export { checkerStringMax, dataParserCheckerStringMaxKind };
+export { checkerStringMax, checkerStringMaxKind };

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

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerStringMinKind = kind.createDataParserKind("checker-string-min");
+const checkerStringMinKind = kind.createDataParserKind("checker-string-min");
 function checkerStringMin(min, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerStringMinKind, {
+    return base.dataParserCheckerInit(checkerStringMinKind, {
         definition: {
             ...definition,
             min,
@@ -15,4 +15,4 @@ function checkerStringMin(min, definition = {}) {
 }
 
 exports.checkerStringMin = checkerStringMin;
-exports.dataParserCheckerStringMinKind = dataParserCheckerStringMinKind;
+exports.checkerStringMinKind = checkerStringMinKind;

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

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

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

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerStringMinKind = createDataParserKind("checker-string-min");
+const checkerStringMinKind = createDataParserKind("checker-string-min");
 function checkerStringMin(min, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerStringMinKind, {
+    return dataParserCheckerInit(checkerStringMinKind, {
         definition: {
             ...definition,
             min,
@@ -12,4 +12,4 @@ function checkerStringMin(min, definition = {}) {
     }, (value, self) => value.length >= self.definition.min ? value : SymbolDataParserErrorIssue);
 }
 
-export { checkerStringMin, dataParserCheckerStringMinKind };
+export { checkerStringMin, checkerStringMinKind };

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

@@ -4,9 +4,9 @@ var base = require('../../../base.cjs');
 var error = require('../../../error.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerStringRegexKind = kind.createDataParserKind("checker-string-regex");
+const checkerStringRegexKind = kind.createDataParserKind("checker-string-regex");
 function checkerStringRegex(regex, definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+    return base.dataParserCheckerInit(checkerStringRegexKind, {
         definition: {
             ...definition,
             regex,
@@ -17,4 +17,4 @@ function checkerStringRegex(regex, definition = {}) {
 }
 
 exports.checkerStringRegex = checkerStringRegex;
-exports.dataParserCheckerStringRegexKind = dataParserCheckerStringRegexKind;
+exports.checkerStringRegexKind = checkerStringRegexKind;

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

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

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

@@ -2,9 +2,9 @@ import { dataParserCheckerInit } from '../../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerStringRegexKind = createDataParserKind("checker-string-regex");
+const checkerStringRegexKind = createDataParserKind("checker-string-regex");
 function checkerStringRegex(regex, definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerStringRegexKind, {
+    return dataParserCheckerInit(checkerStringRegexKind, {
         definition: {
             ...definition,
             regex,
@@ -14,4 +14,4 @@ function checkerStringRegex(regex, definition = {}) {
         : SymbolDataParserErrorIssue);
 }
 
-export { checkerStringRegex, dataParserCheckerStringRegexKind };
+export { checkerStringRegex, checkerStringRegexKind };

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

@@ -5,10 +5,10 @@ var error = require('../../../error.cjs');
 var index = require('../index.cjs');
 var kind = require('../../../kind.cjs');
 
-const dataParserCheckerUrlKind = kind.createDataParserKind("checker-string-url");
+const checkerUrlKind = kind.createDataParserKind("checker-string-url");
 const regexRemoveDote = /:$/;
 function checkerUrl(definition = {}) {
-    return base.dataParserCheckerInit(dataParserCheckerUrlKind, {
+    return base.dataParserCheckerInit(checkerUrlKind, {
         definition: definition,
     }, (input, self) => {
         try {
@@ -44,5 +44,5 @@ function url(definition) {
 }
 
 exports.checkerUrl = checkerUrl;
-exports.dataParserCheckerUrlKind = dataParserCheckerUrlKind;
+exports.checkerUrlKind = checkerUrlKind;
 exports.url = url;

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

@@ -5,8 +5,8 @@ export interface DataParserCheckerDefinitionUrl extends DataParserCheckerDefinit
     protocol?: RegExp;
     normalize?: boolean;
 }
-export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-url", unknown>>;
-type _DataParserCheckerUrl = (Kind<typeof dataParserCheckerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
+export declare const checkerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-url", unknown>>;
+type _DataParserCheckerUrl = (Kind<typeof checkerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
 export interface DataParserCheckerUrl extends _DataParserCheckerUrl {
 }
 export declare function checkerUrl(definition?: Partial<DataParserCheckerDefinitionUrl>): DataParserCheckerUrl;

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

@@ -3,10 +3,10 @@ import { SymbolDataParserErrorIssue } from '../../../error.mjs';
 import { string } from '../index.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 
-const dataParserCheckerUrlKind = createDataParserKind("checker-string-url");
+const checkerUrlKind = createDataParserKind("checker-string-url");
 const regexRemoveDote = /:$/;
 function checkerUrl(definition = {}) {
-    return dataParserCheckerInit(dataParserCheckerUrlKind, {
+    return dataParserCheckerInit(checkerUrlKind, {
         definition: definition,
     }, (input, self) => {
         try {
@@ -41,4 +41,4 @@ function url(definition) {
     });
 }
 
-export { checkerUrl, dataParserCheckerUrlKind, url };
+export { checkerUrl, checkerUrlKind, url };

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

@@ -1,9 +1,13 @@
-import { type NeverCoalescing, type Kind } from "../../../common";
-import { type DataParserDefinition, type DataParser } from "../../base";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserCheckerUrl, type DataParserCheckerEmail, type DataParserCheckerStringMin, type DataParserCheckerStringMax, type DataParserCheckerStringRegex } from "./checkers";
+import { type CheckerRefineImplementation } from "../refine";
+import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./checkers";
-export type DataParserStringCheckers = (DataParserCheckerUrl | DataParserCheckerEmail | DataParserCheckerStringMin | DataParserCheckerStringMax | DataParserCheckerStringRegex);
+export interface DataParserStringCheckerCustom {
+}
+export type DataParserStringCheckers = (DataParserStringCheckerCustom[GetPropsWithValueExtends<DataParserStringCheckerCustom, DataParserChecker>] | DataParserCheckerUrl | DataParserCheckerEmail | DataParserCheckerStringMin | DataParserCheckerStringMax | DataParserCheckerStringRegex | CheckerRefineImplementation<string>);
 export interface DataParserDefinitionString extends DataParserDefinition<DataParserStringCheckers> {
     readonly coerce: boolean;
 }
@@ -13,6 +17,9 @@ export interface DataParserString<GenericDefinition extends DataParserDefinition
     addChecker<GenericChecker extends readonly [
         DataParserStringCheckers,
         ...DataParserStringCheckers[]
-    ]>(...args: GenericChecker): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserStringCheckers,
+        ...DataParserStringCheckers[]
+    ], 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/templateLiteral/createTemplateLiteralPattern.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var escapeRegExp = require('../../../common/escapeRegExp.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 or = require('../../../common/or.cjs');
+var justReturn = require('../../../common/justReturn.cjs');
+var find = require('../../../array/find.cjs');
+var to = require('../../../object/to.cjs');
+var map = require('../../../array/map.cjs');
+var join = require('../../../array/join.cjs');
+require('../../../common/globalStore.cjs');
+require('../../../common/builder.cjs');
+var index = require('./index.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$3 = require('../number/index.cjs');
+var index$2 = require('../bigint/index.cjs');
+var boolean = require('../boolean.cjs');
+var nil = require('../nil.cjs');
+var empty = require('../empty.cjs');
+var literal = require('../literal.cjs');
+var index$1 = require('../string/index.cjs');
+var union = require('../union.cjs');
+var regex = require('../string/checkers/regex.cjs');
+var max = require('../string/checkers/max.cjs');
+var min = require('../string/checkers/min.cjs');
+var email = require('../string/checkers/email.cjs');
+var int = require('../number/checkers/int.cjs');
+
+function createTemplateLiteralPattern(templatePart) {
+    return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when(or.or([
+        isType.isType("string"),
+        isType.isType("boolean"),
+        isType.isType("bigint"),
+        isType.isType("null"),
+        isType.isType("undefined"),
+        isType.isType("number"),
+    ]), innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp, (value) => `(?:${value})`)), when.when(index$3.numberKind.has, (dataParser) => pipe.pipe(dataParser.definition.checkers, to.to({
+        int: innerPipe.innerPipe(find.find(int.checkerIntKind.has), when$1.when(int.checkerIntKind.has, justReturn.justReturn(true))),
+    }), ({ int }) => {
+        if (int) {
+            return "(?:[0-9]+)";
+        }
+        return "(?:[0-9]+(\\.[0-9]+)?)";
+    })), when.when(index$2.bigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.booleanKind.has, () => "(?:true|false)"), when.when(nil.nilKind.has, () => "(?:null)"), when.when(empty.emptyKind.has, () => "(?:undefined)"), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map((element) => createTemplateLiteralPattern([element])), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index$1.stringKind.has, (dataParser) => pipe.pipe(dataParser.definition.checkers, to.to({
+        email: innerPipe.innerPipe(find.find(email.checkerEmailKind.has), when$1.when(email.checkerEmailKind.has, (checker) => pipe.pipe(checker.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, "")))),
+        min: innerPipe.innerPipe(find.find(min.checkerStringMinKind.has), when$1.when(min.checkerStringMinKind.has, (checker) => checker.definition.min)),
+        max: innerPipe.innerPipe(find.find(max.checkerStringMaxKind.has), when$1.when(max.checkerStringMaxKind.has, (checker) => checker.definition.max)),
+        regex: innerPipe.innerPipe(find.find(regex.checkerStringRegexKind.has), when$1.when(regex.checkerStringRegexKind.has, (checker) => pipe.pipe(checker.definition.regex.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, "")))),
+    }), ({ email, regex, max, min }) => {
+        if (email) {
+            return email;
+        }
+        else if (regex) {
+            return regex;
+        }
+        else if (max !== undefined && min !== undefined) {
+            return `(?:[^]{${min},${max}})`;
+        }
+        else if (max !== undefined) {
+            return `(?:[^]{0,${max}})`;
+        }
+        else if (min !== undefined) {
+            return `(?:[^]{${min},})`;
+        }
+        return "(?:[^]*)";
+    })), innerPipe.innerPipe(when.when(index.templateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map((option) => createTemplateLiteralPattern([option])), join.join("|"), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive))), join.join(""));
+}
+
+exports.createTemplateLiteralPattern = createTemplateLiteralPattern;

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

@@ -0,0 +1,2 @@
+import { type TemplateLiteralParts } from ".";
+export declare function createTemplateLiteralPattern(templatePart: readonly TemplateLiteralParts[]): string;

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.mjs

@@ -0,0 +1,73 @@
+import { escapeRegExp } from '../../../common/escapeRegExp.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 { or } from '../../../common/or.mjs';
+import { justReturn } from '../../../common/justReturn.mjs';
+import { find } from '../../../array/find.mjs';
+import { to } from '../../../object/to.mjs';
+import { map } from '../../../array/map.mjs';
+import { join } from '../../../array/join.mjs';
+import '../../../common/globalStore.mjs';
+import '../../../common/builder.mjs';
+import { templateLiteralKind } from './index.mjs';
+import '../../../pattern/result.mjs';
+import { exhaustive } from '../../../pattern/exhaustive.mjs';
+import { when } from '../../../pattern/when.mjs';
+import { replace } from '../../../string/replace.mjs';
+import { numberKind } from '../number/index.mjs';
+import { bigIntKind } from '../bigint/index.mjs';
+import { booleanKind } from '../boolean.mjs';
+import { nilKind } from '../nil.mjs';
+import { emptyKind } from '../empty.mjs';
+import { literalKind } from '../literal.mjs';
+import { stringKind } from '../string/index.mjs';
+import { unionKind } from '../union.mjs';
+import { checkerStringRegexKind } from '../string/checkers/regex.mjs';
+import { checkerStringMaxKind } from '../string/checkers/max.mjs';
+import { checkerStringMinKind } from '../string/checkers/min.mjs';
+import { checkerEmailKind } from '../string/checkers/email.mjs';
+import { checkerIntKind } from '../number/checkers/int.mjs';
+
+function createTemplateLiteralPattern(templatePart) {
+    return pipe(templatePart, map(innerPipe(when(or([
+        isType("string"),
+        isType("boolean"),
+        isType("bigint"),
+        isType("null"),
+        isType("undefined"),
+        isType("number"),
+    ]), innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp, (value) => `(?:${value})`)), when(numberKind.has, (dataParser) => pipe(dataParser.definition.checkers, to({
+        int: innerPipe(find(checkerIntKind.has), when$1(checkerIntKind.has, justReturn(true))),
+    }), ({ int }) => {
+        if (int) {
+            return "(?:[0-9]+)";
+        }
+        return "(?:[0-9]+(\\.[0-9]+)?)";
+    })), when(bigIntKind.has, () => "(?:[0-9]+n)"), when(booleanKind.has, () => "(?:true|false)"), when(nilKind.has, () => "(?:null)"), when(emptyKind.has, () => "(?:undefined)"), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map((element) => createTemplateLiteralPattern([element])), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, (dataParser) => pipe(dataParser.definition.checkers, to({
+        email: innerPipe(find(checkerEmailKind.has), when$1(checkerEmailKind.has, (checker) => pipe(checker.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, "")))),
+        min: innerPipe(find(checkerStringMinKind.has), when$1(checkerStringMinKind.has, (checker) => checker.definition.min)),
+        max: innerPipe(find(checkerStringMaxKind.has), when$1(checkerStringMaxKind.has, (checker) => checker.definition.max)),
+        regex: innerPipe(find(checkerStringRegexKind.has), when$1(checkerStringRegexKind.has, (checker) => pipe(checker.definition.regex.source, replace(/^\^/, ""), replace(/\$$/, "")))),
+    }), ({ email, regex, max, min }) => {
+        if (email) {
+            return email;
+        }
+        else if (regex) {
+            return regex;
+        }
+        else if (max !== undefined && min !== undefined) {
+            return `(?:[^]{${min},${max}})`;
+        }
+        else if (max !== undefined) {
+            return `(?:[^]{0,${max}})`;
+        }
+        else if (min !== undefined) {
+            return `(?:[^]{${min},})`;
+        }
+        return "(?:[^]*)";
+    })), innerPipe(when(templateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map((option) => createTemplateLiteralPattern([option])), join("|"), (pattern) => `(?:${pattern})`)), exhaustive))), join(""));
+}
+
+export { createTemplateLiteralPattern };

package/dist/dataParser/parsers/templateLiteral/index.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var pipe = require('../../../common/pipe.cjs');
+require('../../../common/globalStore.cjs');
+require('../../../common/builder.cjs');
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+var kind = require('../../kind.cjs');
+var createTemplateLiteralPattern = require('./createTemplateLiteralPattern.cjs');
+
+const templateLiteralKind = kind.createDataParserKind("template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe.pipe(createTemplateLiteralPattern.createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
+    return base.dataParserInit(templateLiteralKind, {
+        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.createTemplateLiteralPattern = createTemplateLiteralPattern.createTemplateLiteralPattern;
+exports.templateLiteral = templateLiteral;
+exports.templateLiteralKind = templateLiteralKind;

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

@@ -0,0 +1,66 @@
+import { type Adaptor, type AnyTuple, type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserCheckerStringMax, type DataParserCheckerStringMin, type DataParserCheckerStringRegex, type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "../string";
+import { type DataParserCheckerInt, 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";
+import { type CheckerRefineImplementation } from "../refine";
+import { type DataParserDefinitionUnion, type DataParserUnion } from "../union";
+import { type GetPropsWithValueExtends } from "../../../object";
+export * from "./createTemplateLiteralPattern";
+export type TemplateLiteralPrimitiveParts = (string | number | null | undefined | bigint | boolean);
+export type TemplateLiteralParts = (TemplateLiteralPrimitiveParts | DataParserString<Omit<DataParserDefinitionString, "checkers"> & {
+    readonly checkers: readonly (DataParserCheckerEmail | DataParserCheckerStringMax | DataParserCheckerStringMin | DataParserCheckerStringRegex)[];
+}> | DataParserNumber<Omit<DataParserDefinitionNumber, "checkers"> & {
+    readonly checkers: readonly DataParserCheckerInt[];
+}> | DataParserBigInt<Omit<DataParserDefinitionBigInt, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserBoolean<Omit<DataParserDefinitionBoolean, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserLiteral<Omit<DataParserDefinitionLiteral, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserEmpty<Omit<DataParserDefinitionEmpty, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserNil<Omit<DataParserDefinitionNil, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserTemplateLiteral<Omit<DataParserDefinitionTemplateLiteral, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserUnion<Omit<DataParserDefinitionUnion, "checkers" | "options"> & {
+    readonly options: AnyTuple<Exclude<TemplateLiteralParts, TemplateLiteralPrimitiveParts>>;
+    readonly checkers: readonly [];
+}>);
+export type TemplateLiteralShape = readonly [TemplateLiteralParts, ...TemplateLiteralParts[]];
+type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
+export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends TemplateLiteralParts,
+    ...infer InferredRest extends TemplateLiteralParts[]
+] ? (`${GenericLastResult}${InferredFirst extends TemplateLiteralPrimitiveParts ? InferredFirst extends bigint ? `${InferredFirst}n` : InferredFirst : Adaptor<Output<Exclude<InferredFirst, TemplateLiteralPrimitiveParts>>, 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 TemplateLiteralParts,
+    ...infer InferredRest extends TemplateLiteralParts[]
+] ? (`${GenericLastResult}${InferredFirst extends TemplateLiteralPrimitiveParts ? InferredFirst extends bigint ? `${InferredFirst}n` : InferredFirst : Adaptor<Input<Exclude<InferredFirst, TemplateLiteralPrimitiveParts>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeInput<InferredRest, InferredResult> : TemplateLiteralShapeInput<[InferredRest[number]], InferredResult> : never : never;
+export interface DataParserTemplateLiteralCheckerCustom<GenericInput extends string = string> {
+}
+export type DataParserTemplateLiteralCheckers<GenericInput extends string = string> = (DataParserTemplateLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTemplateLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<DataParserTemplateLiteralCheckers> {
+    readonly template: TemplateLiteralShape;
+    readonly pattern: RegExp;
+}
+export declare const templateLiteralKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>>;
+type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof templateLiteralKind.definition>);
+export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserTemplateLiteralCheckers<Output<this>>,
+        ...DataParserTemplateLiteralCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserTemplateLiteralCheckers<Output<this>>,
+        ...DataParserTemplateLiteralCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTemplateLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+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;
+}>>;

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

@@ -0,0 +1,27 @@
+import { pipe } from '../../../common/pipe.mjs';
+import '../../../common/globalStore.mjs';
+import '../../../common/builder.mjs';
+import { dataParserInit } from '../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../error.mjs';
+import { createDataParserKind } from '../../kind.mjs';
+import { createTemplateLiteralPattern } from './createTemplateLiteralPattern.mjs';
+
+const templateLiteralKind = createDataParserKind("template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe(createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
+    return dataParserInit(templateLiteralKind, {
+        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 { createTemplateLiteralPattern, templateLiteral, templateLiteralKind };

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

@@ -1,14 +1,26 @@
-import { type Kind, type NeverCoalescing } from "../../common";
-import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type DataParserError, type SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from "../../dataParser/error";
-export interface DataParserDefinitionTransform extends DataParserDefinition<never> {
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserTransformCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserTransformCheckers<GenericInput extends unknown = unknown> = (DataParserTransformCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTransformCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionTransform extends DataParserDefinition<DataParserTransformCheckers> {
     readonly inner: DataParser;
     theFunction(input: any, error: DataParserError): unknown;
 }
 export declare const transformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>>;
 type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, Exclude<Awaited<ReturnType<GenericDefinition["theFunction"]>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>, Input<GenericDefinition["inner"]>> & Kind<typeof transformKind.definition>);
 export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserTransformCheckers<Output<this>>,
+        ...DataParserTransformCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserTransformCheckers<Output<this>>,
+        ...DataParserTransformCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTransform<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function transform<GenericDataParser extends DataParser, 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;