@duplojs/lang 0.0.0

package/dist/common/when.mjs

@@ -0,0 +1,12 @@
+//#region scripts/common/when.ts
+function when(...args) {
+	if (args.length === 2) {
+		const [ifFunction, theFunction] = args;
+		return (input) => when(input, ifFunction, theFunction);
+	}
+	const [input, ifFunction, theFunction] = args;
+	if (ifFunction(input)) return theFunction(input);
+	return input;
+}
+//#endregion
+export { when };

package/dist/common/whenElse.cjs

@@ -0,0 +1,12 @@
+//#region scripts/common/whenElse.ts
+function whenElse(...args) {
+	if (args.length === 3) {
+		const [predicate, thenFunction, elseFunction] = args;
+		return (input) => whenElse(input, predicate, thenFunction, elseFunction);
+	}
+	const [input, predicate, thenFunction, elseFunction] = args;
+	if (predicate(input)) return thenFunction(input);
+	else return elseFunction(input);
+}
+//#endregion
+exports.whenElse = whenElse;

package/dist/common/whenElse.d.ts

@@ -0,0 +1,5 @@
+import { EscapeVoid, AnyValue, BreakGenericLink } from './types';
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => input is GenericPredicatedInput, thenFunction: (predicatedInput: Extract<GenericInput, GenericPredicatedInput>) => GenericOutput1, elseFunction: (excludedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): (input: GenericInput) => BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicatedInput, thenFunction: (predicatedInput: Extract<GenericInput, GenericPredicatedInput>) => GenericOutput1, elseFunction: (excludedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => boolean, thenFunction: (input: GenericInput) => GenericOutput1, elseFunction: (input: GenericInput) => GenericOutput2): (input: GenericInput) => GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => boolean, thenFunction: (input: GenericInput) => GenericOutput1, elseFunction: (input: GenericInput) => GenericOutput2): BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;

package/dist/common/whenElse.mjs

@@ -0,0 +1,12 @@
+//#region scripts/common/whenElse.ts
+function whenElse(...args) {
+	if (args.length === 3) {
+		const [predicate, thenFunction, elseFunction] = args;
+		return (input) => whenElse(input, predicate, thenFunction, elseFunction);
+	}
+	const [input, predicate, thenFunction, elseFunction] = args;
+	if (predicate(input)) return thenFunction(input);
+	else return elseFunction(input);
+}
+//#endregion
+export { whenElse };

package/dist/common/whenNot.cjs

@@ -0,0 +1,12 @@
+//#region scripts/common/whenNot.ts
+function whenNot(...args) {
+	if (args.length === 2) {
+		const [ifFunction, theFunction] = args;
+		return (input) => whenNot(input, ifFunction, theFunction);
+	}
+	const [input, ifFunction, theFunction] = args;
+	if (!ifFunction(input)) return theFunction(input);
+	return input;
+}
+//#endregion
+exports.whenNot = whenNot;

package/dist/common/whenNot.d.ts

@@ -0,0 +1,5 @@
+import { EscapeVoid, AnyValue, BreakGenericLink } from './types';
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => (GenericOutput | BreakGenericLink<GenericPredicatedInput>);
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (GenericOutput | GenericPredicatedInput);
+export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => (GenericOutput | GenericInput);
+export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (GenericOutput | GenericInput);

package/dist/common/whenNot.mjs

@@ -0,0 +1,12 @@
+//#region scripts/common/whenNot.ts
+function whenNot(...args) {
+	if (args.length === 2) {
+		const [ifFunction, theFunction] = args;
+		return (input) => whenNot(input, ifFunction, theFunction);
+	}
+	const [input, ifFunction, theFunction] = args;
+	if (!ifFunction(input)) return theFunction(input);
+	return input;
+}
+//#endregion
+export { whenNot };

package/dist/dataStructure/common/codec.cjs

@@ -0,0 +1,28 @@
+const require_callThen = require("../../common/callThen.cjs");
+const require_memo = require("../../common/memo.cjs");
+const require_kind = require("../kind.cjs");
+const require_resultSymbol = require("./resultSymbol.cjs");
+//#region scripts/dataStructure/common/codec.ts
+const codecKind = require_kind.createKind("codec");
+const codecsKind = require_kind.createKind("codecs");
+function createCodec(fundamentalType, predicateEncode, encode, decode) {
+	return {
+		fundamentalType,
+		predicateEncode,
+		encode: (data, errorHandler) => errorHandler?.().setCurrentContext("encode") ?? require_callThen.callThen(encode(data, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? (result === false ? require_resultSymbol.ErrorSymbol : encodedData))),
+		decode: (data, errorHandler) => errorHandler?.().setCurrentContext("decode") ?? require_callThen.callThen(predicateEncode(data, errorHandler), (result) => result === false ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(decode(data, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? result)),
+		[codecKind.runTimeKey]: null
+	};
+}
+function createCodecs(definition) {
+	return {
+		context: require_memo.memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
+		definition,
+		[codecsKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.codecKind = codecKind;
+exports.codecsKind = codecsKind;
+exports.createCodec = createCodec;
+exports.createCodecs = createCodecs;

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

@@ -0,0 +1,29 @@
+import { FundamentalTypeValue, FundamentalType } from '../fundamentalType';
+import { GetErrorHandler } from './error';
+import { ErrorSymbol } from './resultSymbol';
+import { DObject } from '../../index.ts';
+import type * as DKind from '../../kind';
+import * as DCommon from '../../common';
+export declare const codecKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/codec", unknown>>;
+export interface Codec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown> extends DKind.Kind<typeof codecKind> {
+    readonly fundamentalType: GenericFundamentalType;
+    predicateEncode(input: unknown, errorHandler?: GetErrorHandler): input is GenericEncodedValue;
+    encode(data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler): DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>;
+    decode(data: GenericEncodedValue, errorHandler?: GetErrorHandler): DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>;
+}
+export type CodecContext = Map<FundamentalType, Codec>;
+export declare const codecsKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/codecs", unknown>>;
+export interface Codecs<GenericCodecMapper extends Record<string, Codec> = Record<string, Codec>> extends DKind.Kind<typeof codecsKind> {
+    readonly definition: GenericCodecMapper;
+    readonly context: DCommon.Memoized<CodecContext>;
+}
+export declare function createCodec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown>(fundamentalType: GenericFundamentalType, predicateEncode: (input: unknown, errorHandler?: GetErrorHandler) => input is GenericEncodedValue, encode: (data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>, decode: (data: GenericEncodedValue, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>): Codec<GenericFundamentalType, GenericEncodedValue>;
+type ForbiddenDuplicateFundamentalType<GenericDefinition extends Record<string, Codec>> = {
+    [Prop in keyof GenericDefinition]: [GenericDefinition[Prop]];
+}[keyof GenericDefinition] extends infer InferredResult extends [unknown] ? DCommon.IsEqual<DCommon.RemoveDuplicateInUnion<InferredResult>, InferredResult> extends true ? unknown : DCommon.ComputedTypeError<"Several codecs use the same fundamental type."> : never;
+export declare function createCodecs<GenericDefinition extends Record<string, Codec>>(definition: (GenericDefinition & ForbiddenDuplicateFundamentalType<GenericDefinition>)): Codecs<GenericDefinition>;
+export interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends Codecs> {
+}
+type TreatValue<GenericEncodedStructure extends unknown, GenericValue extends unknown, GenericCodec extends Codec> = DCommon.IsNever<GenericEncodedStructure> extends true ? DCommon.NeverCoalescing<GenericCodec extends Codec<infer InferredFundamentalType, infer InferredEncodedValue> ? GenericValue extends FundamentalTypeValue<InferredFundamentalType> ? InferredEncodedValue : never : never, GenericValue> : GenericEncodedStructure;
+export type EncodedValue<GenericValue extends unknown, GenericCodecs extends Codecs> = GenericValue extends unknown ? TreatValue<DObject.Values<EncodeStructure<GenericValue, GenericCodecs>>, GenericValue, DObject.Values<GenericCodecs["definition"]>> : never;
+export {};

package/dist/dataStructure/common/codec.mjs

@@ -0,0 +1,25 @@
+import { callThen } from "../../common/callThen.mjs";
+import { memo } from "../../common/memo.mjs";
+import { createKind } from "../kind.mjs";
+import { ErrorSymbol } from "./resultSymbol.mjs";
+//#region scripts/dataStructure/common/codec.ts
+const codecKind = createKind("codec");
+const codecsKind = createKind("codecs");
+function createCodec(fundamentalType, predicateEncode, encode, decode) {
+	return {
+		fundamentalType,
+		predicateEncode,
+		encode: (data, errorHandler) => errorHandler?.().setCurrentContext("encode") ?? callThen(encode(data, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? (result === false ? ErrorSymbol : encodedData))),
+		decode: (data, errorHandler) => errorHandler?.().setCurrentContext("decode") ?? callThen(predicateEncode(data, errorHandler), (result) => result === false ? ErrorSymbol : callThen(decode(data, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? result)),
+		[codecKind.runTimeKey]: null
+	};
+}
+function createCodecs(definition) {
+	return {
+		context: memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
+		definition,
+		[codecsKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { codecKind, codecsKind, createCodec, createCodecs };

package/dist/dataStructure/common/error.cjs

@@ -0,0 +1,53 @@
+//#region scripts/dataStructure/common/error.ts
+function createErrorHandler() {
+	let currentStagePath = -1;
+	const issues = [];
+	let currentPath = [];
+	let currentStage = void 0;
+	let context = "default";
+	return {
+		currentPath,
+		issues,
+		createPathStage: () => {
+			if (currentStage === void 0) currentStage = {
+				setCurrentPath: (path) => {
+					currentPath[currentStagePath] = path;
+				},
+				close: () => {
+					if (currentStagePath === -1) return;
+					if (currentPath.length !== currentStagePath) currentPath.pop();
+					currentStagePath--;
+				}
+			};
+			currentStagePath++;
+			return currentStage;
+		},
+		setCurrentContext: (newContext) => {
+			context = newContext;
+		},
+		addIssue: (source, data) => {
+			issues.push({
+				context,
+				data,
+				path: currentPath.join("."),
+				getSource: () => source
+			});
+		},
+		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;
+		}
+	};
+}
+function createGetErrorHandler() {
+	let errorHandler = void 0;
+	return () => {
+		if (errorHandler === void 0) errorHandler = createErrorHandler();
+		return errorHandler;
+	};
+}
+//#endregion
+exports.createErrorHandler = createErrorHandler;
+exports.createGetErrorHandler = createGetErrorHandler;

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

@@ -0,0 +1,30 @@
+import { Constraint } from '../constraint';
+import { FundamentalType } from '../fundamentalType';
+import { Structure } from '../structure';
+import { Type } from '../type';
+export interface Issue {
+    readonly context: ("default" | "encode" | "decode");
+    readonly path: string;
+    readonly data: unknown;
+    getSource(): (Type | Structure | FundamentalType | Constraint);
+}
+export interface PathStageErrorHandler {
+    setCurrentPath(path: string): void;
+    close(): void;
+}
+export interface Error {
+    readonly issues: readonly Issue[];
+}
+export interface ErrorHandler {
+    readonly issues: readonly Issue[];
+    readonly currentPath: string[];
+    setCurrentContext(context: Issue["context"]): void;
+    addIssue(source: ReturnType<Issue["getSource"]>, data: unknown): void;
+    importIssues(errorHandler: (GetErrorHandler | ErrorHandler)[]): void;
+    createPathStage(): PathStageErrorHandler;
+    createError(): Error;
+    usePath(path: string[]): void;
+}
+export declare function createErrorHandler(): ErrorHandler;
+export type GetErrorHandler = () => ErrorHandler;
+export declare function createGetErrorHandler(): GetErrorHandler;

package/dist/dataStructure/common/error.mjs

@@ -0,0 +1,52 @@
+//#region scripts/dataStructure/common/error.ts
+function createErrorHandler() {
+	let currentStagePath = -1;
+	const issues = [];
+	let currentPath = [];
+	let currentStage = void 0;
+	let context = "default";
+	return {
+		currentPath,
+		issues,
+		createPathStage: () => {
+			if (currentStage === void 0) currentStage = {
+				setCurrentPath: (path) => {
+					currentPath[currentStagePath] = path;
+				},
+				close: () => {
+					if (currentStagePath === -1) return;
+					if (currentPath.length !== currentStagePath) currentPath.pop();
+					currentStagePath--;
+				}
+			};
+			currentStagePath++;
+			return currentStage;
+		},
+		setCurrentContext: (newContext) => {
+			context = newContext;
+		},
+		addIssue: (source, data) => {
+			issues.push({
+				context,
+				data,
+				path: currentPath.join("."),
+				getSource: () => source
+			});
+		},
+		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;
+		}
+	};
+}
+function createGetErrorHandler() {
+	let errorHandler = void 0;
+	return () => {
+		if (errorHandler === void 0) errorHandler = createErrorHandler();
+		return errorHandler;
+	};
+}
+//#endregion
+export { createErrorHandler, createGetErrorHandler };

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

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

package/dist/dataStructure/common/resultSymbol.cjs

@@ -0,0 +1,6 @@
+//#region scripts/dataStructure/common/resultSymbol.ts
+const SuccessSymbol = Symbol("SuccessSymbol");
+const ErrorSymbol = Symbol("ErrorSymbol");
+//#endregion
+exports.ErrorSymbol = ErrorSymbol;
+exports.SuccessSymbol = SuccessSymbol;

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

@@ -0,0 +1,4 @@
+export declare const SuccessSymbol: unique symbol;
+export type SuccessSymbol = typeof SuccessSymbol;
+export declare const ErrorSymbol: unique symbol;
+export type ErrorSymbol = typeof ErrorSymbol;

package/dist/dataStructure/common/resultSymbol.mjs

@@ -0,0 +1,5 @@
+//#region scripts/dataStructure/common/resultSymbol.ts
+const SuccessSymbol = Symbol("SuccessSymbol");
+const ErrorSymbol = Symbol("ErrorSymbol");
+//#endregion
+export { ErrorSymbol, SuccessSymbol };

package/dist/dataStructure/constraint/base.cjs

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

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

@@ -0,0 +1,22 @@
+import { SuccessSymbol, ErrorSymbol, GetErrorHandler } from '../common';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+export declare const constraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/constraint", unknown>>;
+export interface ConstraintDefinition {
+}
+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>;
+    isAsynchronous(): boolean;
+}
+export interface CreateConstraintInitParams<GenericConstraint extends Constraint = Constraint> {
+    executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0], errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    isAsynchronous(self: GenericConstraint): boolean;
+}
+export interface CreateConstraintConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
+    init<GenericConstraint extends (Constraint & DKind.Kind<GenericKindHandler>)>(definition: GenericConstraint["definition"], params: CreateConstraintInitParams<GenericConstraint>): GenericConstraint;
+}
+export declare function createConstraint<GenericKindHandler extends DKind.Handler, GenericConstructor extends ((...args: any[]) => (Constraint & DKind.Kind<GenericKindHandler>))>(kindHandler: GenericKindHandler, createConstructor: (params: CreateConstraintConstructorParams<GenericKindHandler>) => GenericConstructor): GenericConstructor;
+export {};

package/dist/dataStructure/constraint/base.mjs

@@ -0,0 +1,17 @@
+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 self = {
+			definition,
+			executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+			isAsynchronous: () => isAsynchronous(self),
+			[constraintKind.runTimeKey]: null,
+			[kindHandler.runTimeKey]: null
+		};
+		return self;
+	} });
+}
+//#endregion
+export { constraintKind, createConstraint };

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

@@ -0,0 +1,13 @@
+const require_isComposedOf = require("../../../string/isComposedOf.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+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,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.AllowedCharactersConstraint = AllowedCharactersConstraint;
+exports.allowedCharactersConstraintKind = allowedCharactersConstraintKind;

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

@@ -0,0 +1,13 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DString from '../../../string';
+export declare const allowedCharactersConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/allowed-characters-constraint", unknown>>;
+type AllowedCharactersConstraintValue<GenericCharactersRange extends DString.CharactersRange> = string & DCommon.UnionToIntersection<GenericCharactersRange extends any ? DString.AllowedCharacters<GenericCharactersRange> : never>;
+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 declare const AllowedCharactersConstraint: <GenericCharactersRange extends DString.CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>) => AllowedCharactersConstraint<GenericCharactersRange>;
+export {};

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

@@ -0,0 +1,12 @@
+import { isComposedOf } from "../../../string/isComposedOf.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+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,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { AllowedCharactersConstraint, allowedCharactersConstraintKind };

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

@@ -0,0 +1,14 @@
+const require_lengthEqual = require("../../../array/lengthEqual.cjs");
+const require_forward = require("../../../common/forward.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+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,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.ArrayLengthEqualConstraint = ArrayLengthEqualConstraint;
+exports.arrayLengthEqualConstraintKind = arrayLengthEqualConstraintKind;

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

@@ -0,0 +1,11 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DArray from '../../../array';
+export declare const arrayLengthEqualConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/array-length-equal-constraint", unknown>>;
+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 declare const ArrayLengthEqualConstraint: <GenericLength extends number>(length: GenericLength) => ArrayLengthEqualConstraint<GenericLength>;

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

@@ -0,0 +1,13 @@
+import { lengthEqual } from "../../../array/lengthEqual.mjs";
+import { forward } from "../../../common/forward.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+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,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { ArrayLengthEqualConstraint, arrayLengthEqualConstraintKind };

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

@@ -0,0 +1,17 @@
+const require_forward = require("../../../common/forward.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_betweenThan = require("../../../number/betweenThan.cjs");
+//#region scripts/dataStructure/constraint/defaults/betweenThan.ts
+const betweenThanConstraintKind = require_kind.createKind("between-than-constraint");
+const BetweenThanConstraint = require_base.createConstraint(betweenThanConstraintKind, ({ init }) => (greater, less) => init({
+	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,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.BetweenThanConstraint = BetweenThanConstraint;
+exports.betweenThanConstraintKind = betweenThanConstraintKind;

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

@@ -0,0 +1,12 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DNumber from '../../../number';
+export declare const betweenThanConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/between-than-constraint", unknown>>;
+export interface BetweenThanConstraintDefinition<GenericGreater extends number = number, GenericLess extends number = number> extends ConstraintDefinition {
+    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 declare const BetweenThanConstraint: <GenericGreater extends number, GenericLess extends number>(greater: GenericGreater, less: GenericLess) => BetweenThanConstraint<GenericGreater, GenericLess>;

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

@@ -0,0 +1,16 @@
+import { forward } from "../../../common/forward.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { betweenThan } from "../../../number/betweenThan.mjs";
+//#region scripts/dataStructure/constraint/defaults/betweenThan.ts
+const betweenThanConstraintKind = createKind("between-than-constraint");
+const BetweenThanConstraint = createConstraint(betweenThanConstraintKind, ({ init }) => (greater, less) => init({
+	greater,
+	less
+}, {
+	executeCheck: (self, data, errorHandler) => betweenThan(data, forward(self.definition.greater), forward(self.definition.less)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { BetweenThanConstraint, betweenThanConstraintKind };

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

@@ -0,0 +1,17 @@
+const require_forward = require("../../../common/forward.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_betweenThanOrEqual = require("../../../number/betweenThanOrEqual.cjs");
+//#region scripts/dataStructure/constraint/defaults/betweenThanOrEqual.ts
+const betweenThanOrEqualConstraintKind = require_kind.createKind("between-than-or-equal-constraint");
+const BetweenThanOrEqualConstraint = require_base.createConstraint(betweenThanOrEqualConstraintKind, ({ init }) => (greater, less) => init({
+	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,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.BetweenThanOrEqualConstraint = BetweenThanOrEqualConstraint;
+exports.betweenThanOrEqualConstraintKind = betweenThanOrEqualConstraintKind;

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

@@ -0,0 +1,12 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DNumber from '../../../number';
+export declare const betweenThanOrEqualConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/between-than-or-equal-constraint", unknown>>;
+export interface BetweenThanOrEqualConstraintDefinition<GenericGreater extends number = number, GenericLess extends number = number> extends ConstraintDefinition {
+    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 declare const BetweenThanOrEqualConstraint: <GenericGreater extends number, GenericLess extends number>(greater: GenericGreater, less: GenericLess) => BetweenThanOrEqualConstraint<GenericGreater, GenericLess>;

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

@@ -0,0 +1,16 @@
+import { forward } from "../../../common/forward.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { betweenThanOrEqual } from "../../../number/betweenThanOrEqual.mjs";
+//#region scripts/dataStructure/constraint/defaults/betweenThanOrEqual.ts
+const betweenThanOrEqualConstraintKind = createKind("between-than-or-equal-constraint");
+const BetweenThanOrEqualConstraint = createConstraint(betweenThanOrEqualConstraintKind, ({ init }) => (greater, less) => init({
+	greater,
+	less
+}, {
+	executeCheck: (self, data, errorHandler) => betweenThanOrEqual(data, forward(self.definition.greater), forward(self.definition.less)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { BetweenThanOrEqualConstraint, betweenThanOrEqualConstraintKind };

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

@@ -0,0 +1,13 @@
+const require_isEmail = require("../../../string/isEmail.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+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,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.EmailConstraint = EmailConstraint;
+exports.emailConstraintKind = emailConstraintKind;

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

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+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 declare const EmailConstraint: () => EmailConstraint;