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

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

@@ -1,2 +1,3 @@
 export * from './cast';
+export * from './remove';
 export * from './types';

package/dist/common/constraint/remove.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/constraint/remove.ts
+function removeConstraint(value) {
+	return value;
+}
+//#endregion
+exports.removeConstraint = removeConstraint;

package/dist/common/constraint/remove.d.ts

@@ -0,0 +1,2 @@
+import { RemoveConstraint } from './types';
+export declare function removeConstraint<GenericValue extends unknown>(value: GenericValue): GenericValue extends unknown ? RemoveConstraint<GenericValue> : never;

package/dist/common/constraint/remove.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/constraint/remove.ts
+function removeConstraint(value) {
+	return value;
+}
+//#endregion
+export { removeConstraint };

package/dist/common/index.cjs

@@ -13,6 +13,7 @@ const require_builder = require("./builder.cjs");
 const require_callThen = require("./callThen.cjs");
 const require_clone = require("./clone.cjs");
 const require_index = require("./constraint/cast/index.cjs");
+const require_remove = require("./constraint/remove.cjs");
 const require_detachObjectMethod = require("./detachObjectMethod.cjs");
 const require_enum = require("./enum.cjs");
 const require_equal = require("./equal.cjs");
@@ -104,6 +105,7 @@ var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	promiseAll: () => require_promiseAll.promiseAll,
 	promiseObject: () => require_promiseObject.promiseObject,
 	queueKind: () => require_queue.queueKind,
+	removeConstraint: () => require_remove.removeConstraint,
 	shameOnYou: () => require_index.shameOnYou,
 	simpleClone: () => require_simpleClone.simpleClone,
 	stringToBytes: () => require_stringToBytes.stringToBytes,
@@ -177,6 +179,7 @@ exports.preparePipe = require_preparePipe.preparePipe;
 exports.promiseAll = require_promiseAll.promiseAll;
 exports.promiseObject = require_promiseObject.promiseObject;
 exports.queueKind = require_queue.queueKind;
+exports.removeConstraint = require_remove.removeConstraint;
 exports.shameOnYou = require_index.shameOnYou;
 exports.simpleClone = require_simpleClone.simpleClone;
 exports.stringToBytes = require_stringToBytes.stringToBytes;

package/dist/common/index.mjs

@@ -13,6 +13,7 @@ import { MissingBuilderMethodsError, builderKind, createBuilder } from "./builde
 import { callThen } from "./callThen.mjs";
 import { clone } from "./clone.mjs";
 import { cast, shameOnYou } from "./constraint/cast/index.mjs";
+import { removeConstraint } from "./constraint/remove.mjs";
 import { detachObjectMethod } from "./detachObjectMethod.mjs";
 import { createEnum } from "./enum.mjs";
 import { equal } from "./equal.mjs";
@@ -104,6 +105,7 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	promiseAll: () => promiseAll,
 	promiseObject: () => promiseObject,
 	queueKind: () => queueKind,
+	removeConstraint: () => removeConstraint,
 	shameOnYou: () => shameOnYou,
 	simpleClone: () => simpleClone,
 	stringToBytes: () => stringToBytes,
@@ -121,4 +123,4 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	whenNot: () => whenNot
 });
 //#endregion
-export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/common/types/forward.d.ts

@@ -0,0 +1 @@
+export type Forward<GenericValue extends unknown> = GenericValue;

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

@@ -22,6 +22,7 @@ export type * from './fixDeepFunctionInfer';
 export type * from './forbiddenPromise';
 export type * from './forbiddenUnion';
 export type * from './forcePredicate';
+export type * from './forward';
 export type * from './hasSomething';
 export type * from './isEqual';
 export type * from './isNever';

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

@@ -1,9 +1,9 @@
 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';
+import type * as DObject from '../../object';
 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;

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/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/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/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/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/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/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/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/index.d.ts

@@ -27,3 +27,4 @@ export * from './stringLengthEqual';
 export * from './trimmed';
 export * from './url';
 export * from './uuid';
+export * from './regex';

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/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>;

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

@@ -6,6 +6,6 @@ export declare const lessThanOrEqualConstraintKind: DKind.Handler<DKind.Definiti
 export interface LessThanOrEqualConstraintDefinition<GenericThreshold extends number = number> extends ConstraintDefinition {
     readonly threshold: GenericThreshold;
 }
-export interface LessThanOrEqualConstraint<GenericThreshold extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.LessThanOrEqual<GenericThreshold>, LessThanOrEqualConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof lessThanOrEqualConstraintKind>> {
+export interface LessThanOrEqualConstraint<GenericThreshold extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.LessThanOrEqual<GenericThreshold>, LessThanOrEqualConstraintDefinition<GenericThreshold>> & DKind.Kind<typeof lessThanOrEqualConstraintKind>> {
 }
 export declare const LessThanOrEqualConstraint: <GenericThreshold extends number>(threshold: GenericThreshold) => LessThanOrEqualConstraint<GenericThreshold>;

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

@@ -6,6 +6,6 @@ export declare const maxCharactersConstraintKind: DKind.Handler<DKind.Definition
 export interface MaxCharactersConstraintDefinition<GenericMax extends number = number> extends ConstraintDefinition {
     readonly max: GenericMax;
 }
-export interface MaxCharactersConstraint<GenericMax extends number = number> extends DCommon.UnionToIntersection<Constraint<string, string & DString.MaxCharacters<GenericMax>, MaxCharactersConstraintDefinition<GenericMax>> & DKind.Kind<typeof maxCharactersConstraintKind>> {
+export interface MaxCharactersConstraint<GenericMax extends number = number> extends DCommon.Forward<Constraint<string, string & DString.MaxCharacters<GenericMax>, MaxCharactersConstraintDefinition<GenericMax>> & DKind.Kind<typeof maxCharactersConstraintKind>> {
 }
 export declare const MaxCharactersConstraint: <GenericMax extends number>(max: GenericMax) => MaxCharactersConstraint<GenericMax>;

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

@@ -6,6 +6,6 @@ export declare const maxElementsConstraintKind: DKind.Handler<DKind.Definition<"
 export interface MaxElementsConstraintDefinition<GenericMax extends number = number> extends ConstraintDefinition {
     readonly max: GenericMax;
 }
-export interface MaxElementsConstraint<GenericMax extends number = number> extends DCommon.UnionToIntersection<Constraint<readonly unknown[], readonly unknown[] & DArray.MaxElements<GenericMax>, MaxElementsConstraintDefinition<GenericMax>> & DKind.Kind<typeof maxElementsConstraintKind>> {
+export interface MaxElementsConstraint<GenericMax extends number = number> extends DCommon.Forward<Constraint<readonly unknown[], readonly unknown[] & DArray.MaxElements<GenericMax>, MaxElementsConstraintDefinition<GenericMax>> & DKind.Kind<typeof maxElementsConstraintKind>> {
 }
 export declare const MaxElementsConstraint: <GenericMax extends number>(max: GenericMax) => MaxElementsConstraint<GenericMax>;

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

@@ -4,11 +4,11 @@ const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/minCharacters.ts
-const stringMinConstraintKind = require_kind.createKind("string-min-constraint");
-const MinCharactersConstraint = require_base.createConstraint(stringMinConstraintKind, ({ init }) => (min) => init({ min }, {
+const minCharactersConstraintKind = require_kind.createKind("min-characters-constraint");
+const MinCharactersConstraint = require_base.createConstraint(minCharactersConstraintKind, ({ init }) => (min) => init({ min }, {
 	executeCheck: (self, data) => require_minCharacters.minCharacters(data, require_forward.forward(self.definition.min)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion
 exports.MinCharactersConstraint = MinCharactersConstraint;
-exports.stringMinConstraintKind = stringMinConstraintKind;
+exports.minCharactersConstraintKind = minCharactersConstraintKind;

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

@@ -2,10 +2,10 @@ import { ConstraintDefinition, Constraint } from '../base';
 import * as DCommon from '../../../common';
 import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
-export declare const stringMinConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-min-constraint", unknown>>;
+export declare const minCharactersConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/min-characters-constraint", unknown>>;
 export interface StringMinConstraintDefinition<GenericMin extends number = number> extends ConstraintDefinition {
     readonly min: GenericMin;
 }
-export interface MinCharactersConstraint<GenericMin extends number = number> extends DCommon.UnionToIntersection<Constraint<string, string & DString.MinCharacters<GenericMin>, StringMinConstraintDefinition<GenericMin>> & DKind.Kind<typeof stringMinConstraintKind>> {
+export interface MinCharactersConstraint<GenericMin extends number = number> extends DCommon.Forward<Constraint<string, string & DString.MinCharacters<GenericMin>, StringMinConstraintDefinition<GenericMin>> & DKind.Kind<typeof minCharactersConstraintKind>> {
 }
 export declare const MinCharactersConstraint: <GenericMin extends number>(min: GenericMin) => MinCharactersConstraint<GenericMin>;

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

@@ -4,10 +4,10 @@ import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/minCharacters.ts
-const stringMinConstraintKind = createKind("string-min-constraint");
-const MinCharactersConstraint = createConstraint(stringMinConstraintKind, ({ init }) => (min) => init({ min }, {
+const minCharactersConstraintKind = createKind("min-characters-constraint");
+const MinCharactersConstraint = createConstraint(minCharactersConstraintKind, ({ init }) => (min) => init({ min }, {
 	executeCheck: (self, data) => minCharacters(data, forward(self.definition.min)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion
-export { MinCharactersConstraint, stringMinConstraintKind };
+export { MinCharactersConstraint, minCharactersConstraintKind };

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

@@ -6,6 +6,6 @@ export declare const minElementsConstraintKind: DKind.Handler<DKind.Definition<"
 export interface MinElementsConstraintDefinition<GenericMin extends number = number> extends ConstraintDefinition {
     readonly min: GenericMin;
 }
-export interface MinElementsConstraint<GenericMin extends number = number> extends DCommon.UnionToIntersection<Constraint<readonly unknown[], readonly unknown[] & DArray.MinElements<GenericMin>, MinElementsConstraintDefinition<GenericMin>> & DKind.Kind<typeof minElementsConstraintKind>> {
+export interface MinElementsConstraint<GenericMin extends number = number> extends DCommon.Forward<Constraint<readonly unknown[], readonly unknown[] & DArray.MinElements<GenericMin>, MinElementsConstraintDefinition<GenericMin>> & DKind.Kind<typeof minElementsConstraintKind>> {
 }
 export declare const MinElementsConstraint: <GenericMin extends number>(min: GenericMin) => MinElementsConstraint<GenericMin>;

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

@@ -6,6 +6,6 @@ export declare const multipleOfConstraintKind: DKind.Handler<DKind.Definition<"@
 export interface MultipleOfConstraintDefinition<GenericMultiple extends number = number> extends ConstraintDefinition {
     readonly multiple: GenericMultiple;
 }
-export interface MultipleOfConstraint<GenericMultiple extends number = number> extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.MultipleOf<GenericMultiple>, MultipleOfConstraintDefinition<GenericMultiple>> & DKind.Kind<typeof multipleOfConstraintKind>> {
+export interface MultipleOfConstraint<GenericMultiple extends number = number> extends DCommon.Forward<Constraint<number, number & DNumber.MultipleOf<GenericMultiple>, MultipleOfConstraintDefinition<GenericMultiple>> & DKind.Kind<typeof multipleOfConstraintKind>> {
 }
 export declare const MultipleOfConstraint: <GenericMultiple extends number>(multiple: GenericMultiple) => MultipleOfConstraint<GenericMultiple>;

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

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

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

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

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

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

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

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

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

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

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

@@ -5,6 +5,6 @@ export declare const refineConstraintKind: DKind.Handler<DKind.Definition<"@Dupl
 export interface RefineConstraintDefinition<GenericInput extends unknown = unknown> extends ConstraintDefinition {
     refine(data: GenericInput): boolean;
 }
-export interface RefineConstraint<GenericInput extends unknown = unknown, GenericPredicate extends GenericInput = GenericInput> extends DCommon.UnionToIntersection<Constraint<GenericInput, GenericPredicate, RefineConstraintDefinition<GenericInput>> & DKind.Kind<typeof refineConstraintKind>> {
+export interface RefineConstraint<GenericInput extends unknown = unknown, GenericPredicate extends GenericInput = GenericInput> extends DCommon.Forward<Constraint<GenericInput, GenericPredicate, RefineConstraintDefinition<GenericInput>> & DKind.Kind<typeof refineConstraintKind>> {
 }
 export declare const RefineConstraint: <GenericInput extends unknown, GenericPredicate extends GenericInput = GenericInput>(refine: (((data: GenericInput) => data is GenericPredicate) | ((data: GenericInput) => boolean))) => RefineConstraint<GenericInput, GenericPredicate>;

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

@@ -0,0 +1,13 @@
+const require_test = require("../../../string/test.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/regex.ts
+const regexConstraintKind = require_kind.createKind("regex-constraint");
+const RegexConstraint = require_base.createConstraint(regexConstraintKind, ({ init }) => (regex) => init({ regex }, {
+	executeCheck: (self, data) => require_test.test(data, self.definition.regex) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.RegexConstraint = RegexConstraint;
+exports.regexConstraintKind = regexConstraintKind;

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

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const regexConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/regex-constraint", unknown>>;
+export interface RegexConstraintDefinition extends ConstraintDefinition {
+    readonly regex: RegExp;
+}
+export interface RegexConstraint extends DCommon.Forward<Constraint<string, string, RegexConstraintDefinition> & DKind.Kind<typeof regexConstraintKind>> {
+}
+export declare const RegexConstraint: (regex: RegExp) => RegexConstraint;

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

@@ -0,0 +1,12 @@
+import { test } from "../../../string/test.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+//#region scripts/dataStructure/constraint/defaults/regex.ts
+const regexConstraintKind = createKind("regex-constraint");
+const RegexConstraint = createConstraint(regexConstraintKind, ({ init }) => (regex) => init({ regex }, {
+	executeCheck: (self, data) => test(data, self.definition.regex) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { RegexConstraint, regexConstraintKind };

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

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

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

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

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

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

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

@@ -6,6 +6,6 @@ export declare const stringLengthEqualConstraintKind: DKind.Handler<DKind.Defini
 export interface StringLengthEqualConstraintDefinition<GenericLength extends number = number> extends ConstraintDefinition {
     readonly length: GenericLength;
 }
-export interface StringLengthEqualConstraint<GenericLength extends number = number> extends DCommon.UnionToIntersection<Constraint<string, string & DString.LengthEqual<GenericLength>, StringLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof stringLengthEqualConstraintKind>> {
+export interface StringLengthEqualConstraint<GenericLength extends number = number> extends DCommon.Forward<Constraint<string, string & DString.LengthEqual<GenericLength>, StringLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof stringLengthEqualConstraintKind>> {
 }
 export declare const StringLengthEqualConstraint: <GenericLength extends number>(length: GenericLength) => StringLengthEqualConstraint<GenericLength>;

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

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

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

@@ -4,8 +4,8 @@ const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/url.ts
 const urlConstraintKind = require_kind.createKind("url-constraint");
-const UrlConstraint = require_base.createConstraint(urlConstraintKind, ({ init }) => (params) => init({ params }, {
-	executeCheck: (self, data) => require_isUrl.isUrl(data, self.definition.params) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+const UrlConstraint = require_base.createConstraint(urlConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isUrl.isUrl(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -4,8 +4,7 @@ import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const urlConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/url-constraint", unknown>>;
 export interface UrlConstraintDefinition extends ConstraintDefinition {
-    readonly params?: DString.IsUrlParams;
 }
-export interface UrlConstraint extends DCommon.UnionToIntersection<Constraint<string, string & DString.Url, UrlConstraintDefinition> & DKind.Kind<typeof urlConstraintKind>> {
+export interface UrlConstraint extends DCommon.Forward<Constraint<string, string & DString.Url, UrlConstraintDefinition> & DKind.Kind<typeof urlConstraintKind>> {
 }
-export declare const UrlConstraint: (params?: DString.IsUrlParams) => UrlConstraint;
+export declare const UrlConstraint: () => UrlConstraint;

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

@@ -4,8 +4,8 @@ import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/url.ts
 const urlConstraintKind = createKind("url-constraint");
-const UrlConstraint = createConstraint(urlConstraintKind, ({ init }) => (params) => init({ params }, {
-	executeCheck: (self, data) => isUrl(data, self.definition.params) ? SuccessSymbol : ErrorSymbol,
+const UrlConstraint = createConstraint(urlConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isUrl(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -4,12 +4,10 @@ const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/uuid.ts
 const uuidConstraintKind = require_kind.createKind("uuid-constraint");
-const uuidRegex = require_isUuid.uuidRegex;
-const UuidConstraint = require_base.createConstraint(uuidConstraintKind, ({ init }) => () => init({ regex: uuidRegex }, {
+const UuidConstraint = require_base.createConstraint(uuidConstraintKind, ({ init }) => () => init({}, {
 	executeCheck: (_self, data) => require_isUuid.isUuid(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion
 exports.UuidConstraint = UuidConstraint;
 exports.uuidConstraintKind = uuidConstraintKind;
-exports.uuidRegex = uuidRegex;

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

@@ -4,9 +4,7 @@ import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const uuidConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/uuid-constraint", unknown>>;
 export interface UuidConstraintDefinition extends ConstraintDefinition {
-    readonly regex: RegExp;
 }
-export interface UuidConstraint extends DCommon.UnionToIntersection<Constraint<string, string & DString.Uuid, UuidConstraintDefinition> & DKind.Kind<typeof uuidConstraintKind>> {
+export interface UuidConstraint extends DCommon.Forward<Constraint<string, string & DString.Uuid, UuidConstraintDefinition> & DKind.Kind<typeof uuidConstraintKind>> {
 }
-export declare const uuidRegex: RegExp;
 export declare const UuidConstraint: () => UuidConstraint;

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

@@ -1,13 +1,12 @@
-import { isUuid, uuidRegex as uuidRegex$1 } from "../../../string/isUuid.mjs";
+import { isUuid } from "../../../string/isUuid.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/uuid.ts
 const uuidConstraintKind = createKind("uuid-constraint");
-const uuidRegex = uuidRegex$1;
-const UuidConstraint = createConstraint(uuidConstraintKind, ({ init }) => () => init({ regex: uuidRegex }, {
+const UuidConstraint = createConstraint(uuidConstraintKind, ({ init }) => () => init({}, {
 	executeCheck: (_self, data) => isUuid(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion
-export { UuidConstraint, uuidConstraintKind, uuidRegex };
+export { UuidConstraint, uuidConstraintKind };