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

package/dist/dataStructure/fundamentalType/defaults/time.d.ts

@@ -1,8 +1,8 @@
 import { FundamentalType } from '../base';
 import * as DChrono from '../../../chrono';
-declare const FundamentalTypeTheTimeSymbol: unique symbol;
-export type FundamentalTypeTheTimeSymbol = typeof FundamentalTypeTheTimeSymbol;
-export interface TheTime extends FundamentalType<FundamentalTypeTheTimeSymbol, DChrono.TheTime> {
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const timeFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-fundamental-type", unknown>>;
+export interface TheTime extends DCommon.Forward<FundamentalType<DChrono.TheTime> & DKind.Kind<typeof timeFundamentalTypeKind>> {
 }
 export declare const TheTime: TheTime;
-export {};

package/dist/dataStructure/fundamentalType/defaults/time.mjs

@@ -1,6 +1,9 @@
 import { TheTime as TheTime$1 } from "../../../chrono/theTime.mjs";
+import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createFundamentalType } from "../base.mjs";
-const TheTime = createFundamentalType(Symbol("FundamentalTypeTheTimeSymbol"), (self, data, errorHandler) => data instanceof TheTime$1 ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol);
+//#region scripts/dataStructure/fundamentalType/defaults/time.ts
+const timeFundamentalTypeKind = createKind("time-fundamental-type");
+const TheTime = createFundamentalType(timeFundamentalTypeKind, (self, data) => data instanceof TheTime$1 ? SuccessSymbol : ErrorSymbol);
 //#endregion
-export { TheTime };
+export { TheTime, timeFundamentalTypeKind };

package/dist/dataStructure/fundamentalType/defaults/undefined.cjs

@@ -1,7 +1,9 @@
+const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/fundamentalType/defaults/undefined.ts
-const FundamentalTypeTheUndefinedSymbol = Symbol("FundamentalTypeTheUndefinedSymbol");
-const TheUndefined = require_base.createFundamentalType(FundamentalTypeTheUndefinedSymbol, (self, data, errorHandler) => data === void 0 ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const undefinedFundamentalTypeKind = require_kind.createKind("undefined-fundamental-type");
+const TheUndefined = require_base.createFundamentalType(undefinedFundamentalTypeKind, (self, data) => data === void 0 ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheUndefined = TheUndefined;
+exports.undefinedFundamentalTypeKind = undefinedFundamentalTypeKind;

package/dist/dataStructure/fundamentalType/defaults/undefined.d.ts

@@ -1,7 +1,7 @@
 import { FundamentalType } from '../base';
-declare const FundamentalTypeTheUndefinedSymbol: unique symbol;
-export type FundamentalTypeTheUndefinedSymbol = typeof FundamentalTypeTheUndefinedSymbol;
-export interface TheUndefined extends FundamentalType<FundamentalTypeTheUndefinedSymbol, undefined> {
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const undefinedFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/undefined-fundamental-type", unknown>>;
+export interface TheUndefined extends DCommon.Forward<FundamentalType<undefined> & DKind.Kind<typeof undefinedFundamentalTypeKind>> {
 }
 export declare const TheUndefined: TheUndefined;
-export {};

package/dist/dataStructure/fundamentalType/defaults/undefined.mjs

@@ -1,5 +1,8 @@
+import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createFundamentalType } from "../base.mjs";
-const TheUndefined = createFundamentalType(Symbol("FundamentalTypeTheUndefinedSymbol"), (self, data, errorHandler) => data === void 0 ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol);
+//#region scripts/dataStructure/fundamentalType/defaults/undefined.ts
+const undefinedFundamentalTypeKind = createKind("undefined-fundamental-type");
+const TheUndefined = createFundamentalType(undefinedFundamentalTypeKind, (self, data) => data === void 0 ? SuccessSymbol : ErrorSymbol);
 //#endregion
-export { TheUndefined };
+export { TheUndefined, undefinedFundamentalTypeKind };

package/dist/dataStructure/fundamentalType/identifier.d.ts

@@ -1,5 +1,7 @@
 import { FundamentalType } from './base';
+import { FundamentalTypes } from './types';
+import * as DKind from '../../kind';
 export declare const fundamentalTypeIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, FundamentalType<symbol, unknown>> extends true ? Extract<import('..').TheBigint, GenericGroupedKind> | Extract<import('..').TheBoolean, GenericGroupedKind> | Extract<import('..').TheDate, GenericGroupedKind> | Extract<import('..').TheNull, GenericGroupedKind> | Extract<import('..').TheNumber, GenericGroupedKind> | Extract<import('..').TheString, GenericGroupedKind> | Extract<import('..').TheTime, GenericGroupedKind> | Extract<import('..').TheUndefined, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, FundamentalType<symbol, unknown>> extends true ? Extract<import('..').TheBigint, GenericGroupedKind> | Extract<import('..').TheBoolean, GenericGroupedKind> | Extract<import('..').TheDate, GenericGroupedKind> | Extract<import('..').TheNull, GenericGroupedKind> | Extract<import('..').TheNumber, GenericGroupedKind> | Extract<import('..').TheString, GenericGroupedKind> | Extract<import('..').TheTime, GenericGroupedKind> | Extract<import('..').TheUndefined, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends DKind.GetHandler<import('..').TheBigint> | DKind.GetHandler<import('..').TheBoolean> | DKind.GetHandler<import('..').TheDate> | DKind.GetHandler<import('..').TheNull> | DKind.GetHandler<import('..').TheNumber> | DKind.GetHandler<import('..').TheString> | DKind.GetHandler<import('..').TheTime> | DKind.GetHandler<import('..').TheUndefined>, GenericInput extends unknown, GenericGroupedKind extends GenericKindHandler extends DKind.Handler<DKind.Definition<string, unknown>> ? DKind.Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (GenericInput extends FundamentalType<unknown> ? (import('..').TheBigint extends infer T ? T extends import('..').TheBigint ? T extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheBoolean extends infer T_1 ? T_1 extends import('..').TheBoolean ? T_1 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheDate extends infer T_2 ? T_2 extends import('..').TheDate ? T_2 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheNull extends infer T_3 ? T_3 extends import('..').TheNull ? T_3 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheNumber extends infer T_4 ? T_4 extends import('..').TheNumber ? T_4 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheString extends infer T_5 ? T_5 extends import('..').TheString ? T_5 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheTime extends infer T_6 ? T_6 extends import('..').TheTime ? T_6 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheUndefined extends infer T_7 ? T_7 extends import('..').TheUndefined ? T_7 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends DKind.GetHandler<import('..').TheBigint> | DKind.GetHandler<import('..').TheBoolean> | DKind.GetHandler<import('..').TheDate> | DKind.GetHandler<import('..').TheNull> | DKind.GetHandler<import('..').TheNumber> | DKind.GetHandler<import('..').TheString> | DKind.GetHandler<import('..').TheTime> | DKind.GetHandler<import('..').TheUndefined>, GenericInput extends unknown, GenericGroupedKind extends GenericKindHandler extends DKind.Handler<DKind.Definition<string, unknown>> ? DKind.Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (GenericInput extends FundamentalType<unknown> ? (import('..').TheBigint extends infer T ? T extends import('..').TheBigint ? T extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheBoolean extends infer T_1 ? T_1 extends import('..').TheBoolean ? T_1 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheDate extends infer T_2 ? T_2 extends import('..').TheDate ? T_2 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheNull extends infer T_3 ? T_3 extends import('..').TheNull ? T_3 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheNumber extends infer T_4 ? T_4 extends import('..').TheNumber ? T_4 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheString extends infer T_5 ? T_5 extends import('..').TheString ? T_5 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheTime extends infer T_6 ? T_6 extends import('..').TheTime ? T_6 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) | (import('..').TheUndefined extends infer T_7 ? T_7 extends import('..').TheUndefined ? T_7 extends GenericInput ? GenericInput & FundamentalTypes extends GenericGroupedKind ? GenericGroupedKind & GenericInput & FundamentalTypes : never : never : never : never) : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/dataStructure/helpers/array.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { ArrayStructure, StructureValue, Structure } from '../structure';
-export declare function array<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericStructure>[]>[] = readonly []>(element: GenericStructure, constraints?: GenericConstraints): ArrayStructure<readonly StructureValue<GenericStructure>[], readonly [...GenericConstraints]>;
+export declare function array<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericStructure>[]>[] = readonly []>(element: GenericStructure, constraints?: GenericConstraints): NoInfer<ArrayStructure<readonly StructureValue<GenericStructure>[], readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/bigint.d.ts

@@ -1,3 +1,3 @@
 import { TypeStructure } from '../structure';
 import { Constraint } from '../constraint';
-export declare function bigint<const GenericConstraints extends readonly Constraint<bigint>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<bigint, readonly [...GenericConstraints]>;
+export declare function bigint<const GenericConstraints extends readonly Constraint<bigint>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<bigint, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/boolean.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-export declare function boolean<const GenericConstraints extends readonly Constraint<boolean>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<boolean, readonly [...GenericConstraints]>;
+export declare function boolean<const GenericConstraints extends readonly Constraint<boolean>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<boolean, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/date.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
 import type * as DChrono from '../../chrono';
-export declare function date<const GenericConstraints extends readonly Constraint<DChrono.TheDate>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<DChrono.TheDate, readonly [...GenericConstraints]>;
+export declare function date<const GenericConstraints extends readonly Constraint<DChrono.TheDate>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<DChrono.TheDate, readonly [...GenericConstraints]>>;

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

@@ -43,7 +43,9 @@ export * from './strictNegative';
 export * from './strictPositive';
 export * from './stringLengthEqual';
 export * from './time';
+export * from './trimmed';
 export * from './undefined';
 export * from './union';
 export * from './url';
 export * from './uuid';
+export * from './regex';

package/dist/dataStructure/helpers/lazy.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { LazyStructure, StructureValue, Structure } from '../structure';
-export declare function lazy<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[] = readonly []>(getStructure: () => GenericStructure, constraints?: GenericConstraints): LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>;
+export declare function lazy<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[] = readonly []>(getStructure: () => GenericStructure, constraints?: GenericConstraints): NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/null.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-declare function nullHelper<const GenericConstraints extends readonly Constraint<null>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<null, readonly [...GenericConstraints]>;
+declare function nullHelper<const GenericConstraints extends readonly Constraint<null>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<null, readonly [...GenericConstraints]>>;
 export { nullHelper as null };

package/dist/dataStructure/helpers/nullable.cjs

@@ -1,12 +1,15 @@
 const require_identifier = require("../structure/identifier.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isNullStructure = require("./isNullStructure.cjs");
+const require_lazy = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_null = require("./null.cjs");
 //#region scripts/dataStructure/helpers/nullable.ts
 function nullable(structure) {
-	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.some(require_isNullStructure.isNullStructure) ? require_union$1.union(structure.definition.values) : require_union$1.union([require_null.null(), ...structure.definition.values]);
-	return require_union$1.union([require_null.null(), structure]);
+	return require_union$1.union([require_lazy.lazy(() => {
+		if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.value.some(require_isNullStructure.isNullStructure) ? structure : require_union$1.union([require_null.null(), require_union$1.union(structure.definition.values.value)]);
+		return require_union$1.union([require_null.null(), structure]);
+	})]);
 }
 //#endregion
 exports.nullable = nullable;

package/dist/dataStructure/helpers/nullable.mjs

@@ -1,12 +1,15 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isNullStructure } from "./isNullStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { null as nullHelper } from "./null.mjs";
 //#region scripts/dataStructure/helpers/nullable.ts
 function nullable(structure) {
-	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.some(isNullStructure) ? union(structure.definition.values) : union([nullHelper(), ...structure.definition.values]);
-	return union([nullHelper(), structure]);
+	return union([lazy(() => {
+		if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.some(isNullStructure) ? structure : union([nullHelper(), union(structure.definition.values.value)]);
+		return union([nullHelper(), structure]);
+	})]);
 }
 //#endregion
 export { nullable };

package/dist/dataStructure/helpers/number.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-export declare function number<const GenericConstraints extends readonly Constraint<number>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<number, readonly [...GenericConstraints]>;
+export declare function number<const GenericConstraints extends readonly Constraint<number>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<number, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/object.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { ObjectStructure, ShapeObjectStructureValue, ShapeObjectStructure } from '../structure';
-export declare function object<GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[] = readonly []>(shape: GenericShape, constraints?: GenericConstraints): ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>;
+export declare function object<GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[] = readonly []>(shape: GenericShape, constraints?: GenericConstraints): NoInfer<ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/optional.cjs

@@ -1,12 +1,15 @@
 const require_identifier = require("../structure/identifier.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+const require_lazy = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_undefined = require("./undefined.cjs");
 //#region scripts/dataStructure/helpers/optional.ts
 function optional(structure) {
-	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.some(require_isUndefinedStructure.isUndefinedStructure) ? require_union$1.union(structure.definition.values) : require_union$1.union([require_undefined.undefined(), ...structure.definition.values]);
-	return require_union$1.union([require_undefined.undefined(), structure]);
+	return require_union$1.union([require_lazy.lazy(() => {
+		if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.value.some(require_isUndefinedStructure.isUndefinedStructure) ? structure : require_union$1.union([require_undefined.undefined(), require_union$1.union(structure.definition.values.value)]);
+		return require_union$1.union([require_undefined.undefined(), structure]);
+	})]);
 }
 //#endregion
 exports.optional = optional;

package/dist/dataStructure/helpers/optional.mjs

@@ -1,12 +1,15 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { undefined as undefinedHelper } from "./undefined.mjs";
 //#region scripts/dataStructure/helpers/optional.ts
 function optional(structure) {
-	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.some(isUndefinedStructure) ? union(structure.definition.values) : union([undefinedHelper(), ...structure.definition.values]);
-	return union([undefinedHelper(), structure]);
+	return union([lazy(() => {
+		if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.some(isUndefinedStructure) ? structure : union([undefinedHelper(), union(structure.definition.values.value)]);
+		return union([undefinedHelper(), structure]);
+	})]);
 }
 //#endregion
 export { optional };

package/dist/dataStructure/helpers/partial.cjs

@@ -1,17 +1,20 @@
 const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+const require_lazy$1 = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_object = require("./object.cjs");
 const require_undefined = require("./undefined.cjs");
 //#region scripts/dataStructure/helpers/partial.ts
 function partialStructure(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return partialStructure(structure.definition.getter.value);
 	if (require_isUndefinedStructure.isUndefinedStructure(structure)) return structure;
-	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.some(require_isUndefinedStructure.isUndefinedStructure) ? structure : require_union$1.union([require_undefined.undefined(), ...structure.definition.values]);
+	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.value.some(require_isUndefinedStructure.isUndefinedStructure) ? structure : require_union$1.union([require_undefined.undefined(), ...structure.definition.values.value]);
 	return require_union$1.union([require_undefined.undefined(), structure]);
 }
 function partial(structure) {
-	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, partialStructure(entry.value)])));
+	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => partialStructure(entry.value))])));
 }
 //#endregion
 exports.partial = partial;

package/dist/dataStructure/helpers/partial.mjs

@@ -1,17 +1,20 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { object } from "./object.mjs";
 import { undefined as undefinedHelper } from "./undefined.mjs";
 //#region scripts/dataStructure/helpers/partial.ts
 function partialStructure(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return partialStructure(structure.definition.getter.value);
 	if (isUndefinedStructure(structure)) return structure;
-	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.some(isUndefinedStructure) ? structure : union([undefinedHelper(), ...structure.definition.values]);
+	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.some(isUndefinedStructure) ? structure : union([undefinedHelper(), ...structure.definition.values.value]);
 	return union([undefinedHelper(), structure]);
 }
 function partial(structure) {
-	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, partialStructure(entry.value)])));
+	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, lazy(() => partialStructure(entry.value))])));
 }
 //#endregion
 export { partial };

package/dist/dataStructure/helpers/record.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { RecordStructure, RecordStructureValue, Structure, TypeStructure, UnionStructure } from '../structure';
-export declare function record<GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[] = readonly []>(key: GenericKey, value: GenericValueStructure, constraints?: GenericConstraints): RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>;
+export declare function record<GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[] = readonly []>(key: GenericKey, value: GenericValueStructure, constraints?: GenericConstraints): NoInfer<RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/regex.cjs

@@ -0,0 +1,7 @@
+const require_regex = require("../constraint/defaults/regex.cjs");
+//#region scripts/dataStructure/helpers/regex.ts
+function regex(regex) {
+	return require_regex.RegexConstraint(regex);
+}
+//#endregion
+exports.regex = regex;

package/dist/dataStructure/helpers/regex.d.ts

@@ -0,0 +1,2 @@
+import { RegexConstraint } from '../constraint';
+export declare function regex(regex: RegExp): RegexConstraint;

package/dist/dataStructure/helpers/regex.mjs

@@ -0,0 +1,7 @@
+import { RegexConstraint } from "../constraint/defaults/regex.mjs";
+//#region scripts/dataStructure/helpers/regex.ts
+function regex(regex) {
+	return RegexConstraint(regex);
+}
+//#endregion
+export { regex };

package/dist/dataStructure/helpers/required.cjs

@@ -1,18 +1,21 @@
 const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+const require_lazy$1 = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_object = require("./object.cjs");
 //#region scripts/dataStructure/helpers/required.ts
 function requiredStructure(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return requiredStructure(structure.definition.getter.value);
 	if (!require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure;
-	const values = structure.definition.values.filter((value) => !require_isUndefinedStructure.isUndefinedStructure(value));
+	const values = structure.definition.values.value.filter((value) => !require_isUndefinedStructure.isUndefinedStructure(value));
 	if (values.length === 1) return values[0];
-	if (values.length === structure.definition.values.length) return structure;
+	if (values.length === structure.definition.values.value.length) return structure;
 	return require_union$1.union(values);
 }
 function required(structure) {
-	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, requiredStructure(entry.value)])));
+	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => requiredStructure(entry.value))])));
 }
 //#endregion
 exports.required = required;

package/dist/dataStructure/helpers/required.d.ts

@@ -1,4 +1,5 @@
 import { ObjectStructure, StructureInitialValue } from '../structure';
+import type * as DCommon from '../../common';
 export declare function required<GenericObjectStructure extends ObjectStructure, GenericObjectStructureValue extends StructureInitialValue<GenericObjectStructure>>(structure: GenericObjectStructure): ObjectStructure<{
-    readonly [Prop in keyof GenericObjectStructureValue]-?: Exclude<GenericObjectStructureValue[Prop], undefined>;
+    readonly [Prop in keyof GenericObjectStructureValue]-?: DCommon.IsEqual<GenericObjectStructureValue[Prop], undefined> extends true ? undefined : Exclude<GenericObjectStructureValue[Prop], undefined>;
 }, readonly []>;

package/dist/dataStructure/helpers/required.mjs

@@ -1,18 +1,21 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { object } from "./object.mjs";
 //#region scripts/dataStructure/helpers/required.ts
 function requiredStructure(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return requiredStructure(structure.definition.getter.value);
 	if (!structureIdentifier(structure, unionStructureKind)) return structure;
-	const values = structure.definition.values.filter((value) => !isUndefinedStructure(value));
+	const values = structure.definition.values.value.filter((value) => !isUndefinedStructure(value));
 	if (values.length === 1) return values[0];
-	if (values.length === structure.definition.values.length) return structure;
+	if (values.length === structure.definition.values.value.length) return structure;
 	return union(values);
 }
 function required(structure) {
-	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, requiredStructure(entry.value)])));
+	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, lazy(() => requiredStructure(entry.value))])));
 }
 //#endregion
 export { required };

package/dist/dataStructure/helpers/string.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-export declare function string<const GenericConstraints extends readonly Constraint<string>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<string, readonly [...GenericConstraints]>;
+export declare function string<const GenericConstraints extends readonly Constraint<string>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<string, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/time.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
 import type * as DChrono from '../../chrono';
-export declare function time<const GenericConstraints extends readonly Constraint<DChrono.TheTime>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<DChrono.TheTime, readonly [...GenericConstraints]>;
+export declare function time<const GenericConstraints extends readonly Constraint<DChrono.TheTime>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<DChrono.TheTime, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/trimmed.cjs

@@ -0,0 +1,7 @@
+const require_trimmed = require("../constraint/defaults/trimmed.cjs");
+//#region scripts/dataStructure/helpers/trimmed.ts
+function trimmed() {
+	return require_trimmed.TrimmedConstraint();
+}
+//#endregion
+exports.trimmed = trimmed;

package/dist/dataStructure/helpers/trimmed.d.ts

@@ -0,0 +1,2 @@
+import { TrimmedConstraint } from '../constraint';
+export declare function trimmed(): TrimmedConstraint;

package/dist/dataStructure/helpers/trimmed.mjs

@@ -0,0 +1,7 @@
+import { TrimmedConstraint } from "../constraint/defaults/trimmed.mjs";
+//#region scripts/dataStructure/helpers/trimmed.ts
+function trimmed() {
+	return TrimmedConstraint();
+}
+//#endregion
+export { trimmed };

package/dist/dataStructure/helpers/undefined.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-declare function undefinedHelper<const GenericConstraints extends readonly Constraint<undefined>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<undefined, readonly [...GenericConstraints]>;
+declare function undefinedHelper<const GenericConstraints extends readonly Constraint<undefined>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<undefined, readonly [...GenericConstraints]>>;
 export { undefinedHelper as undefined };

package/dist/dataStructure/helpers/union.d.ts

@@ -1,4 +1,4 @@
 import { UnionStructure, Structure, StructureValue } from '../structure';
 import { Constraint } from '../constraint';
 import type * as DCommon from '../../common';
-export declare function union<GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[] = readonly []>(values: GenericValues, constraints?: GenericConstraints): UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>;
+export declare function union<GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[] = readonly []>(values: GenericValues, constraints?: GenericConstraints): NoInfer<UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/url.cjs

@@ -1,7 +1,7 @@
 const require_url = require("../constraint/defaults/url.cjs");
 //#region scripts/dataStructure/helpers/url.ts
-function url(params) {
-	return require_url.UrlConstraint(params);
+function url() {
+	return require_url.UrlConstraint();
 }
 //#endregion
 exports.url = url;

package/dist/dataStructure/helpers/url.d.ts

@@ -1,3 +1,2 @@
 import { UrlConstraint } from '../constraint';
-import type * as DString from '../../string';
-export declare function url(params?: DString.IsUrlParams): UrlConstraint;
+export declare function url(): UrlConstraint;

package/dist/dataStructure/helpers/url.mjs

@@ -1,7 +1,7 @@
 import { UrlConstraint } from "../constraint/defaults/url.mjs";
 //#region scripts/dataStructure/helpers/url.ts
-function url(params) {
-	return UrlConstraint(params);
+function url() {
+	return UrlConstraint();
 }
 //#endregion
 export { url };