@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.3

package/dist/dataStructure/common/error.mjs

@@ -1,10 +1,13 @@
+import { createKind } from "../kind.mjs";
 //#region scripts/dataStructure/common/error.ts
-function createErrorHandler() {
-	let currentStagePath = -1;
+const issueKind = createKind("issue");
+const encodeIssueKind = createKind("encode-issue");
+const decodeIssueKind = createKind("decode-issue");
+function createErrorHandler(defaultPath) {
 	const issues = [];
-	let currentPath = [];
+	const currentPath = defaultPath ? [...defaultPath] : [];
+	let currentStagePath = currentPath.length - 1;
 	let currentStage = void 0;
-	let context = "default";
 	return {
 		currentPath,
 		issues,
@@ -22,31 +25,43 @@ function createErrorHandler() {
 			currentStagePath++;
 			return currentStage;
 		},
-		setCurrentContext: (newContext) => {
-			context = newContext;
+		addIssue: (source, data, subSource) => {
+			issues.push({
+				data,
+				path: currentPath.join("."),
+				getSource: () => source,
+				getSubSource: subSource ? () => subSource : void 0,
+				[issueKind.runTimeKey]: null
+			});
+		},
+		addEncodeIssue: (source, data, message) => {
+			issues.push({
+				data,
+				path: currentPath.join("."),
+				message,
+				getSource: () => source,
+				[encodeIssueKind.runTimeKey]: null
+			});
 		},
-		addIssue: (source, data) => {
+		addDecodeIssue: (source, data, message) => {
 			issues.push({
-				context,
 				data,
 				path: currentPath.join("."),
-				getSource: () => source
+				message,
+				getSource: () => source,
+				[decodeIssueKind.runTimeKey]: null
 			});
 		},
 		createError: () => ({ issues }),
-		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues)),
-		usePath: (path) => {
-			currentPath = [...path];
-			currentStagePath = currentPath.length - 1;
-		}
+		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues))
 	};
 }
-function createGetErrorHandler() {
+function createGetErrorHandler(defaultPath) {
 	let errorHandler = void 0;
 	return () => {
-		if (errorHandler === void 0) errorHandler = createErrorHandler();
+		if (errorHandler === void 0) errorHandler = createErrorHandler(defaultPath);
 		return errorHandler;
 	};
 }
 //#endregion
-export { createErrorHandler, createGetErrorHandler };
+export { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind };

package/dist/dataStructure/common/errorInterpreter.cjs

@@ -0,0 +1,45 @@
+const require_base = require("../../kind/base.cjs");
+const require_entries = require("../../object/entries.cjs");
+const require_entry = require("../../object/entry.cjs");
+const require_map = require("../../array/map.cjs");
+const require_reduce = require("../../array/reduce.cjs");
+const require_pipe = require("../../common/pipe.cjs");
+const require_error = require("./error.cjs");
+//#region scripts/dataStructure/common/errorInterpreter.ts
+const kindNamespaceName = "DuplojsLangDataStructure";
+function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
+	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const getInterpretedMessageStructure = (structure) => require_reduce.reduce(formattedStructureDictionary, require_reduce.reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure)) : next(void 0));
+	const getInterpretedMessageCodec = (codec) => require_reduce.reduce(codecDictionary, require_reduce.reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message) : next(void 0));
+	return (error) => require_map.map(error.issues, (issue) => {
+		if (require_error.issueKind.has(issue)) {
+			const source = issue.getSource();
+			const subSource = issue.getSubSource?.();
+			return {
+				...issue,
+				interpretedMessage: {
+					source: source.definition.message,
+					subSource: subSource?.definition.message,
+					interpretedSource: getInterpretedMessageStructure(source),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource)
+				}
+			};
+		}
+		if (require_error.encodeIssueKind.has(issue)) return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+			}
+		};
+		return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+			}
+		};
+	});
+}
+//#endregion
+exports.createErrorInterpreter = createErrorInterpreter;

package/dist/dataStructure/common/errorInterpreter.d.ts

@@ -0,0 +1,32 @@
+import { Structure, Structures } from '../structure';
+import { createKind } from '../kind';
+import { Type, Types } from '../type';
+import { Constraint, Constraints } from '../constraint';
+import { Error, DecodeIssue, EncodeIssue, Issue } from './error';
+import { Codec } from './codec';
+import * as DKind from '../../kind';
+import * as DCommon from '../../common';
+declare const kindNamespaceName: DKind.GetNamespaceName<typeof createKind>;
+type RemoveNamespace<GenericString> = GenericString extends `@${typeof kindNamespaceName}/${infer InferredKindName}` ? InferredKindName : never;
+export interface InterpretedMessage {
+    source?: string;
+    interpretedSource?: string;
+    subSource?: string;
+    interpretedSubSource?: string;
+}
+export interface InterpretedIssue extends Issue {
+    interpretedMessage: InterpretedMessage;
+}
+export interface InterpretedEncodedIssue extends EncodeIssue {
+    interpretedMessage: InterpretedMessage;
+}
+export interface InterpretedDecodedIssue extends DecodeIssue {
+    interpretedMessage: InterpretedMessage;
+}
+export type InterpretedIssues = (InterpretedIssue | InterpretedEncodedIssue | InterpretedDecodedIssue);
+type CreateDictionaryParams = DCommon.SimplifyTopLevel<Omit<{
+    [DataStructure in (Types | Structures | Constraints) as RemoveNamespace<DKind.GetName<DataStructure>>]?: (structure: DataStructure) => string;
+}, RemoveNamespace<DKind.GetName<Type>> | RemoveNamespace<DKind.GetName<Structure>> | RemoveNamespace<DKind.GetName<Constraint>>>>;
+export declare function createErrorInterpreter(structureDictionary?: CreateDictionaryParams, codecDictionary?: [Codec, string][]): (error: Error) => readonly InterpretedIssues[];
+export type ErrorInterpreter = ReturnType<typeof createErrorInterpreter>;
+export {};

package/dist/dataStructure/common/errorInterpreter.mjs

@@ -0,0 +1,45 @@
+import { keyKindPrefix } from "../../kind/base.mjs";
+import { entries } from "../../object/entries.mjs";
+import { entry } from "../../object/entry.mjs";
+import { map } from "../../array/map.mjs";
+import { reduce, reduceFrom } from "../../array/reduce.mjs";
+import { pipe } from "../../common/pipe.mjs";
+import { encodeIssueKind, issueKind } from "./error.mjs";
+//#region scripts/dataStructure/common/errorInterpreter.ts
+const kindNamespaceName = "DuplojsLangDataStructure";
+function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
+	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const getInterpretedMessageStructure = (structure) => reduce(formattedStructureDictionary, reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure)) : next(void 0));
+	const getInterpretedMessageCodec = (codec) => reduce(codecDictionary, reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message) : next(void 0));
+	return (error) => map(error.issues, (issue) => {
+		if (issueKind.has(issue)) {
+			const source = issue.getSource();
+			const subSource = issue.getSubSource?.();
+			return {
+				...issue,
+				interpretedMessage: {
+					source: source.definition.message,
+					subSource: subSource?.definition.message,
+					interpretedSource: getInterpretedMessageStructure(source),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource)
+				}
+			};
+		}
+		if (encodeIssueKind.has(issue)) return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+			}
+		};
+		return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource())
+			}
+		};
+	});
+}
+//#endregion
+export { createErrorInterpreter };

package/dist/dataStructure/common/index.d.ts

@@ -1,3 +1,4 @@
 export * from './codec';
 export * from './error';
+export * from './errorInterpreter';
 export * from './resultSymbol';

package/dist/dataStructure/constraint/base.cjs

@@ -1,16 +1,29 @@
+const require_simpleClone = require("../../common/simpleClone.cjs");
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = require("../kind.cjs").createKind("constraint");
 function createConstraint(kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
 			definition,
-			executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
+			clone: () => init(require_simpleClone.simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 exports.constraintKind = constraintKind;

package/dist/dataStructure/constraint/base.d.ts

@@ -1,18 +1,22 @@
-import { SuccessSymbol, ErrorSymbol, GetErrorHandler } from '../common';
+import { SuccessSymbol, ErrorSymbol } from '../common';
 import type * as DKind from '../../kind';
-import type * as DCommon from '../../common';
+import * as DCommon from '../../common';
 export declare const constraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/constraint", unknown>>;
 export interface ConstraintDefinition {
+    readonly message?: string;
 }
 declare const BivariousSymbol: unique symbol;
 export interface Constraint<GenericInput extends unknown = unknown, GenericChecked extends GenericInput = GenericInput, GenericDefinition extends ConstraintDefinition = ConstraintDefinition> extends DKind.Kind<typeof constraintKind, DCommon.IsEqual<GenericInput, GenericChecked> extends true ? any : GenericChecked> {
     readonly definition: GenericDefinition;
     readonly [BivariousSymbol]?: DCommon.IsUnion<GenericInput> extends true ? (input: GenericInput) => void : unknown;
-    executeCheck(data: GenericInput, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(data: GenericInput): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(): boolean;
+    clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateConstraintInitParams<GenericConstraint extends Constraint = Constraint> {
-    executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0], errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0]): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericConstraint): boolean;
 }
 export interface CreateConstraintConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {

package/dist/dataStructure/constraint/base.mjs

@@ -1,17 +1,30 @@
+import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = createKind("constraint");
 function createConstraint(kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
 			definition,
-			executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
+			clone: () => init(simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 export { constraintKind, createConstraint };

package/dist/dataStructure/constraint/defaults/allowedCharacters.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/allowedCharacters.ts
 const allowedCharactersConstraintKind = require_kind.createKind("allowed-characters-constraint");
 const AllowedCharactersConstraint = require_base.createConstraint(allowedCharactersConstraintKind, ({ init }) => (charactersRange) => init({ charactersRange }, {
-	executeCheck: (self, data, errorHandler) => require_isComposedOf.isComposedOf(data, self.definition.charactersRange) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_isComposedOf.isComposedOf(data, self.definition.charactersRange) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/allowedCharacters.d.ts

@@ -7,7 +7,7 @@ type AllowedCharactersConstraintValue<GenericCharactersRange extends DString.Cha
 export interface AllowedCharactersConstraintDefinition<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends ConstraintDefinition {
     readonly charactersRange: DCommon.MaybeArray<GenericCharactersRange>;
 }
-export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.UnionToIntersection<Constraint<string, AllowedCharactersConstraintValue<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
+export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.Forward<Constraint<string, AllowedCharactersConstraintValue<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
 }
 export declare const AllowedCharactersConstraint: <GenericCharactersRange extends DString.CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>) => AllowedCharactersConstraint<GenericCharactersRange>;
 export {};

package/dist/dataStructure/constraint/defaults/allowedCharacters.mjs

@@ -5,7 +5,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/allowedCharacters.ts
 const allowedCharactersConstraintKind = createKind("allowed-characters-constraint");
 const AllowedCharactersConstraint = createConstraint(allowedCharactersConstraintKind, ({ init }) => (charactersRange) => init({ charactersRange }, {
-	executeCheck: (self, data, errorHandler) => isComposedOf(data, self.definition.charactersRange) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => isComposedOf(data, self.definition.charactersRange) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/arrayLengthEqual.cjs

@@ -6,7 +6,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/arrayLengthEqual.ts
 const arrayLengthEqualConstraintKind = require_kind.createKind("array-length-equal-constraint");
 const ArrayLengthEqualConstraint = require_base.createConstraint(arrayLengthEqualConstraintKind, ({ init }) => (length) => init({ length }, {
-	executeCheck: (self, data, errorHandler) => require_lengthEqual.lengthEqual(data, require_forward.forward(self.definition.length)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_lengthEqual.lengthEqual(data, require_forward.forward(self.definition.length)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/arrayLengthEqual.d.ts

@@ -6,6 +6,6 @@ export declare const arrayLengthEqualConstraintKind: DKind.Handler<DKind.Definit
 export interface ArrayLengthEqualConstraintDefinition<GenericLength extends number = number> extends ConstraintDefinition {
     readonly length: GenericLength;
 }
-export interface ArrayLengthEqualConstraint<GenericLength extends number = number> extends DCommon.UnionToIntersection<Constraint<readonly unknown[], readonly unknown[] & DArray.LengthEqual<GenericLength>, ArrayLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof arrayLengthEqualConstraintKind>> {
+export interface ArrayLengthEqualConstraint<GenericLength extends number = number> extends DCommon.Forward<Constraint<readonly unknown[], readonly unknown[] & DArray.LengthEqual<GenericLength>, ArrayLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof arrayLengthEqualConstraintKind>> {
 }
 export declare const ArrayLengthEqualConstraint: <GenericLength extends number>(length: GenericLength) => ArrayLengthEqualConstraint<GenericLength>;

package/dist/dataStructure/constraint/defaults/arrayLengthEqual.mjs

@@ -6,7 +6,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/arrayLengthEqual.ts
 const arrayLengthEqualConstraintKind = createKind("array-length-equal-constraint");
 const ArrayLengthEqualConstraint = createConstraint(arrayLengthEqualConstraintKind, ({ init }) => (length) => init({ length }, {
-	executeCheck: (self, data, errorHandler) => lengthEqual(data, forward(self.definition.length)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => lengthEqual(data, forward(self.definition.length)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/betweenThan.cjs

@@ -9,7 +9,7 @@ const BetweenThanConstraint = require_base.createConstraint(betweenThanConstrain
 	greater,
 	less
 }, {
-	executeCheck: (self, data, errorHandler) => require_betweenThan.betweenThan(data, require_forward.forward(self.definition.greater), require_forward.forward(self.definition.less)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_betweenThan.betweenThan(data, require_forward.forward(self.definition.greater), require_forward.forward(self.definition.less)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/betweenThan.d.ts

@@ -7,6 +7,6 @@ export interface BetweenThanConstraintDefinition<GenericGreater extends number =
     readonly greater: GenericGreater;
     readonly less: GenericLess;
 }
-export interface BetweenThanConstraint<GenericGreater extends number = number, GenericLess extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.GreaterThan<GenericGreater> & DNumber.LessThan<GenericLess>, BetweenThanConstraintDefinition<GenericGreater, GenericLess>> & DKind.Kind<typeof betweenThanConstraintKind>> {
+export interface BetweenThanConstraint<GenericGreater extends number = number, GenericLess extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.GreaterThan<GenericGreater> & DNumber.LessThan<GenericLess>, BetweenThanConstraintDefinition<GenericGreater, GenericLess>> & DKind.Kind<typeof betweenThanConstraintKind>> {
 }
 export declare const BetweenThanConstraint: <GenericGreater extends number, GenericLess extends number>(greater: GenericGreater, less: GenericLess) => BetweenThanConstraint<GenericGreater, GenericLess>;

package/dist/dataStructure/constraint/defaults/betweenThan.mjs

@@ -9,7 +9,7 @@ const BetweenThanConstraint = createConstraint(betweenThanConstraintKind, ({ ini
 	greater,
 	less
 }, {
-	executeCheck: (self, data, errorHandler) => betweenThan(data, forward(self.definition.greater), forward(self.definition.less)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => betweenThan(data, forward(self.definition.greater), forward(self.definition.less)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/betweenThanOrEqual.cjs

@@ -9,7 +9,7 @@ const BetweenThanOrEqualConstraint = require_base.createConstraint(betweenThanOr
 	greater,
 	less
 }, {
-	executeCheck: (self, data, errorHandler) => require_betweenThanOrEqual.betweenThanOrEqual(data, require_forward.forward(self.definition.greater), require_forward.forward(self.definition.less)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_betweenThanOrEqual.betweenThanOrEqual(data, require_forward.forward(self.definition.greater), require_forward.forward(self.definition.less)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/betweenThanOrEqual.d.ts

@@ -7,6 +7,6 @@ export interface BetweenThanOrEqualConstraintDefinition<GenericGreater extends n
     readonly greater: GenericGreater;
     readonly less: GenericLess;
 }
-export interface BetweenThanOrEqualConstraint<GenericGreater extends number = number, GenericLess extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.GreaterThanOrEqual<GenericGreater> & DNumber.LessThanOrEqual<GenericLess>, BetweenThanOrEqualConstraintDefinition<GenericGreater, GenericLess>> & DKind.Kind<typeof betweenThanOrEqualConstraintKind>> {
+export interface BetweenThanOrEqualConstraint<GenericGreater extends number = number, GenericLess extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.GreaterThanOrEqual<GenericGreater> & DNumber.LessThanOrEqual<GenericLess>, BetweenThanOrEqualConstraintDefinition<GenericGreater, GenericLess>> & DKind.Kind<typeof betweenThanOrEqualConstraintKind>> {
 }
 export declare const BetweenThanOrEqualConstraint: <GenericGreater extends number, GenericLess extends number>(greater: GenericGreater, less: GenericLess) => BetweenThanOrEqualConstraint<GenericGreater, GenericLess>;

package/dist/dataStructure/constraint/defaults/betweenThanOrEqual.mjs

@@ -9,7 +9,7 @@ const BetweenThanOrEqualConstraint = createConstraint(betweenThanOrEqualConstrai
 	greater,
 	less
 }, {
-	executeCheck: (self, data, errorHandler) => betweenThanOrEqual(data, forward(self.definition.greater), forward(self.definition.less)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => betweenThanOrEqual(data, forward(self.definition.greater), forward(self.definition.less)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/email.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/email.ts
 const emailConstraintKind = require_kind.createKind("email-constraint");
 const EmailConstraint = require_base.createConstraint(emailConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isEmail.isEmail(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isEmail.isEmail(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/email.d.ts

@@ -5,6 +5,6 @@ import * as DString from '../../../string';
 export declare const emailConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/email-constraint", unknown>>;
 export interface EmailConstraintDefinition extends ConstraintDefinition {
 }
-export interface EmailConstraint extends DCommon.UnionToIntersection<Constraint<string, string & DString.Email, EmailConstraintDefinition> & DKind.Kind<typeof emailConstraintKind>> {
+export interface EmailConstraint extends DCommon.Forward<Constraint<string, string & DString.Email, EmailConstraintDefinition> & DKind.Kind<typeof emailConstraintKind>> {
 }
 export declare const EmailConstraint: () => EmailConstraint;

package/dist/dataStructure/constraint/defaults/email.mjs

@@ -5,7 +5,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/email.ts
 const emailConstraintKind = createKind("email-constraint");
 const EmailConstraint = createConstraint(emailConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isEmail(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isEmail(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/even.cjs

@@ -5,7 +5,7 @@ const require_isEven = require("../../../number/isEven.cjs");
 //#region scripts/dataStructure/constraint/defaults/even.ts
 const evenConstraintKind = require_kind.createKind("even-constraint");
 const EvenConstraint = require_base.createConstraint(evenConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isEven.isEven(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isEven.isEven(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/even.d.ts

@@ -5,6 +5,6 @@ import * as DNumber from '../../../number';
 export declare const evenConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/even-constraint", unknown>>;
 export interface EvenConstraintDefinition extends ConstraintDefinition {
 }
-export interface EvenConstraint extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.Even, EvenConstraintDefinition> & DKind.Kind<typeof evenConstraintKind>> {
+export interface EvenConstraint extends DCommon.Forward<Constraint<number, number & DNumber.Even, EvenConstraintDefinition> & DKind.Kind<typeof evenConstraintKind>> {
 }
 export declare const EvenConstraint: () => EvenConstraint;

package/dist/dataStructure/constraint/defaults/even.mjs

@@ -5,7 +5,7 @@ import { isEven } from "../../../number/isEven.mjs";
 //#region scripts/dataStructure/constraint/defaults/even.ts
 const evenConstraintKind = createKind("even-constraint");
 const EvenConstraint = createConstraint(evenConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isEven(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isEven(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/greaterThan.cjs

@@ -6,7 +6,7 @@ const require_greaterThan = require("../../../number/greaterThan.cjs");
 //#region scripts/dataStructure/constraint/defaults/greaterThan.ts
 const greaterThanConstraintKind = require_kind.createKind("greater-than-constraint");
 const GreaterThanConstraint = require_base.createConstraint(greaterThanConstraintKind, ({ init }) => (threshold) => init({ threshold }, {
-	executeCheck: (self, data, errorHandler) => require_greaterThan.greaterThan(data, require_forward.forward(self.definition.threshold)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_greaterThan.greaterThan(data, require_forward.forward(self.definition.threshold)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/greaterThan.d.ts

@@ -6,6 +6,6 @@ export declare const greaterThanConstraintKind: DKind.Handler<DKind.Definition<"
 export interface GreaterThanConstraintDefinition<GenericThreshold extends number = number> extends ConstraintDefinition {
     readonly threshold: GenericThreshold;
 }
-export interface GreaterThanConstraint<GenericThreshold extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.GreaterThan<GenericThreshold>, GreaterThanConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof greaterThanConstraintKind>> {
+export interface GreaterThanConstraint<GenericThreshold extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.GreaterThan<GenericThreshold>, GreaterThanConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof greaterThanConstraintKind>> {
 }
 export declare const GreaterThanConstraint: <GenericThreshold extends number>(threshold: GenericThreshold) => GreaterThanConstraint<GenericThreshold>;

package/dist/dataStructure/constraint/defaults/greaterThan.mjs

@@ -6,7 +6,7 @@ import { greaterThan } from "../../../number/greaterThan.mjs";
 //#region scripts/dataStructure/constraint/defaults/greaterThan.ts
 const greaterThanConstraintKind = createKind("greater-than-constraint");
 const GreaterThanConstraint = createConstraint(greaterThanConstraintKind, ({ init }) => (threshold) => init({ threshold }, {
-	executeCheck: (self, data, errorHandler) => greaterThan(data, forward(self.definition.threshold)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => greaterThan(data, forward(self.definition.threshold)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/greaterThanOrEqual.cjs

@@ -6,7 +6,7 @@ const require_greaterThanOrEqual = require("../../../number/greaterThanOrEqual.c
 //#region scripts/dataStructure/constraint/defaults/greaterThanOrEqual.ts
 const greaterThanOrEqualConstraintKind = require_kind.createKind("greater-than-or-equal-constraint");
 const GreaterThanOrEqualConstraint = require_base.createConstraint(greaterThanOrEqualConstraintKind, ({ init }) => (threshold) => init({ threshold }, {
-	executeCheck: (self, data, errorHandler) => require_greaterThanOrEqual.greaterThanOrEqual(data, require_forward.forward(self.definition.threshold)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_greaterThanOrEqual.greaterThanOrEqual(data, require_forward.forward(self.definition.threshold)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/greaterThanOrEqual.d.ts

@@ -6,6 +6,6 @@ export declare const greaterThanOrEqualConstraintKind: DKind.Handler<DKind.Defin
 export interface GreaterThanOrEqualConstraintDefinition<GenericThreshold extends number = number> extends ConstraintDefinition {
     readonly threshold: GenericThreshold;
 }
-export interface GreaterThanOrEqualConstraint<GenericThreshold extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.GreaterThanOrEqual<GenericThreshold>, GreaterThanOrEqualConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof greaterThanOrEqualConstraintKind>> {
+export interface GreaterThanOrEqualConstraint<GenericThreshold extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.GreaterThanOrEqual<GenericThreshold>, GreaterThanOrEqualConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof greaterThanOrEqualConstraintKind>> {
 }
 export declare const GreaterThanOrEqualConstraint: <GenericThreshold extends number>(threshold: GenericThreshold) => GreaterThanOrEqualConstraint<GenericThreshold>;

package/dist/dataStructure/constraint/defaults/greaterThanOrEqual.mjs

@@ -6,7 +6,7 @@ import { greaterThanOrEqual } from "../../../number/greaterThanOrEqual.mjs";
 //#region scripts/dataStructure/constraint/defaults/greaterThanOrEqual.ts
 const greaterThanOrEqualConstraintKind = createKind("greater-than-or-equal-constraint");
 const GreaterThanOrEqualConstraint = createConstraint(greaterThanOrEqualConstraintKind, ({ init }) => (threshold) => init({ threshold }, {
-	executeCheck: (self, data, errorHandler) => greaterThanOrEqual(data, forward(self.definition.threshold)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => greaterThanOrEqual(data, forward(self.definition.threshold)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/index.d.ts

@@ -24,5 +24,7 @@ export * from './safe';
 export * from './strictNegative';
 export * from './strictPositive';
 export * from './stringLengthEqual';
+export * from './trimmed';
 export * from './url';
 export * from './uuid';
+export * from './regex';

package/dist/dataStructure/constraint/defaults/integer.cjs

@@ -5,7 +5,7 @@ const require_isInteger = require("../../../number/isInteger.cjs");
 //#region scripts/dataStructure/constraint/defaults/integer.ts
 const integerConstraintKind = require_kind.createKind("integer-constraint");
 const IntegerConstraint = require_base.createConstraint(integerConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isInteger.isInteger(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isInteger.isInteger(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/integer.d.ts

@@ -5,6 +5,6 @@ import * as DNumber from '../../../number';
 export declare const integerConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/integer-constraint", unknown>>;
 export interface IntegerConstraintDefinition extends ConstraintDefinition {
 }
-export interface IntegerConstraint extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.Integer, IntegerConstraintDefinition> & DKind.Kind<typeof integerConstraintKind>> {
+export interface IntegerConstraint extends DCommon.Forward<Constraint<number, number & DNumber.Integer, IntegerConstraintDefinition> & DKind.Kind<typeof integerConstraintKind>> {
 }
 export declare const IntegerConstraint: () => IntegerConstraint;

package/dist/dataStructure/constraint/defaults/integer.mjs

@@ -5,7 +5,7 @@ import { isInteger } from "../../../number/isInteger.mjs";
 //#region scripts/dataStructure/constraint/defaults/integer.ts
 const integerConstraintKind = createKind("integer-constraint");
 const IntegerConstraint = createConstraint(integerConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isInteger(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isInteger(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/lessThan.cjs

@@ -6,7 +6,7 @@ const require_lessThan = require("../../../number/lessThan.cjs");
 //#region scripts/dataStructure/constraint/defaults/lessThan.ts
 const lessThanConstraintKind = require_kind.createKind("less-than-constraint");
 const LessThanConstraint = require_base.createConstraint(lessThanConstraintKind, ({ init }) => (threshold) => init({ threshold }, {
-	executeCheck: (self, data, errorHandler) => require_lessThan.lessThan(data, require_forward.forward(self.definition.threshold)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_lessThan.lessThan(data, require_forward.forward(self.definition.threshold)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/lessThan.d.ts

@@ -6,6 +6,6 @@ export declare const lessThanConstraintKind: DKind.Handler<DKind.Definition<"@Du
 export interface LessThanConstraintDefinition<GenericThreshold extends number = number> extends ConstraintDefinition {
     readonly threshold: GenericThreshold;
 }
-export interface LessThanConstraint<GenericThreshold extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.LessThan<GenericThreshold>, LessThanConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof lessThanConstraintKind>> {
+export interface LessThanConstraint<GenericThreshold extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.LessThan<GenericThreshold>, LessThanConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof lessThanConstraintKind>> {
 }
 export declare const LessThanConstraint: <GenericThreshold extends number>(threshold: GenericThreshold) => LessThanConstraint<GenericThreshold>;