@duplojs/lang 0.0.1-beta.8 → 0.1.0-beta.1

package/dist/array/concat.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type ConcatOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][] = []> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number] | GenericElementsRest[number][number])[], "minElements"> : never;
+type ConcatOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly (readonly unknown[])[] = []> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number] | GenericElementsRest[number][number])[], "minElements"> : never;
 export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(elements: GenericElements): (array: GenericArray) => ConcatOutput<GenericArray, GenericElements>;
-export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][]>(array: GenericArray, elements: GenericElements, ...elementsRest: GenericElementsRest): ConcatOutput<GenericArray, GenericElements, GenericElementsRest>;
+export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[] = []>(array: GenericArray, elements: GenericElements, ...elementsRest: GenericElementsRest[]): ConcatOutput<GenericArray, GenericElements, GenericElementsRest[]>;
 export {};

package/dist/array/flat.d.ts

@@ -1 +1 @@
-export declare function flat<const GenericArray extends readonly unknown[], const Depth extends number = 1>(array: GenericArray, depth?: Depth): FlatArray<GenericArray, Depth>[];
+export declare function flat<const GenericArray extends readonly unknown[], const Depth extends number = 1>(array: GenericArray, depth?: Depth): readonly FlatArray<GenericArray, Depth>[];

package/dist/array/flatMap.d.ts

@@ -2,5 +2,5 @@ export interface FlatMapTheFunctionParams<GenericArray extends readonly unknown[
     index: number;
     self: GenericArray;
 }
-export declare function flatMap<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: FlatMapTheFunctionParams<GenericArray>) => GenericOutput): (array: GenericArray) => FlatArray<GenericOutput, 1>[];
-export declare function flatMap<GenericArray extends readonly unknown[], GenericOutput extends unknown>(array: GenericArray, theFunction: (element: GenericArray[number], params: FlatMapTheFunctionParams<GenericArray>) => GenericOutput): FlatArray<GenericOutput, 1>[];
+export declare function flatMap<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: FlatMapTheFunctionParams<GenericArray>) => GenericOutput): (array: GenericArray) => readonly FlatArray<GenericOutput, 1>[];
+export declare function flatMap<GenericArray extends readonly unknown[], GenericOutput extends unknown>(array: GenericArray, theFunction: (element: GenericArray[number], params: FlatMapTheFunctionParams<GenericArray>) => GenericOutput): readonly FlatArray<GenericOutput, 1>[];

package/dist/array/from.d.ts

@@ -1,4 +1,4 @@
 type Enumerable = ArrayLike<unknown> | Iterable<unknown> | AsyncIterable<unknown>;
-type FromOutput<GenericEnumerable extends Enumerable> = GenericEnumerable extends AsyncIterable<infer InferredValue> ? Promise<InferredValue[]> : GenericEnumerable extends Iterable<infer InferredValue> ? InferredValue[] : GenericEnumerable extends ArrayLike<infer InferredValue> ? InferredValue[] : never;
+type FromOutput<GenericEnumerable extends Enumerable> = GenericEnumerable extends AsyncIterable<infer InferredValue> ? Promise<readonly InferredValue[]> : GenericEnumerable extends Iterable<infer InferredValue> ? readonly InferredValue[] : GenericEnumerable extends ArrayLike<infer InferredValue> ? readonly InferredValue[] : never;
 export declare function from<const GenericEnumerable extends Enumerable>(input: GenericEnumerable): FromOutput<GenericEnumerable>;
 export {};

package/dist/array/length.d.ts

@@ -1,5 +1,6 @@
+import { ExtractMinElements, MinElements, ExtractMaxElements, MaxElements } from './constraints';
 import type * as DCommon from '../common';
 import type * as DNumber from '../number';
-type LengthOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? DCommon.IsEqual<GenericArray["length"], number> extends true ? number & DNumber.Positive : DNumber.IsGreater<GenericArray["length"], 0> extends true ? GenericArray["length"] & DNumber.StrictPositive : 0 & DNumber.Positive : never;
-export declare function length<GenericArray extends readonly unknown[]>(array: GenericArray): LengthOutput<GenericArray>;
+type LengthOutput<GenericArray extends readonly unknown[]> = Extract<GenericArray extends unknown ? (number & DNumber.Positive & (ExtractMaxElements<GenericArray, unknown> extends MaxElements<infer InferredValue> ? DCommon.UnionToIntersection<InferredValue extends number ? DNumber.LessThanOrEqual<InferredValue> : never> : unknown) & (ExtractMinElements<GenericArray, unknown> extends MinElements<infer InferredValue> ? DCommon.UnionToIntersection<InferredValue extends number ? DNumber.GreaterThanOrEqual<InferredValue> : never> : unknown)) : never, any>;
+export declare function length<const GenericArray extends readonly unknown[]>(array: GenericArray): LengthOutput<GenericArray>;
 export {};

package/dist/array/push.d.ts

@@ -1,5 +1,7 @@
-import { ReapplyCompatiblesConstraints } from './constraints';
-type PushOutput<GenericArray extends readonly unknown[], GenericValue extends unknown, GenericValuesRest extends readonly unknown[] = []> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue | GenericValuesRest[number])[], "minElements"> : never;
+import { ExtractMaxElements, ExtractMinElements, MaxElements, MinElements } from './constraints';
+import type * as DCommon from '../common';
+import type * as DNumber from '../number';
+type PushOutput<GenericArray extends readonly unknown[], GenericValue extends unknown, GenericValuesRest extends readonly unknown[] = []> = GenericArray extends unknown ? (readonly (GenericArray[number] | GenericValue | GenericValuesRest[number])[] & (ExtractMinElements<GenericArray, unknown> extends MinElements<infer InferredValue> ? DCommon.UnionToIntersection<InferredValue extends number ? MinElements<DNumber.AddOne<InferredValue>> : never> : unknown) & (DCommon.IsEqual<GenericValuesRest, []> extends true ? ExtractMaxElements<GenericArray, unknown> extends MaxElements<infer InferredValue> ? DCommon.UnionToIntersection<InferredValue extends number ? MaxElements<DNumber.AddOne<InferredValue>> : never> : unknown : unknown)) : never;
 export declare function push<GenericArray extends readonly unknown[], const GenericValue extends unknown>(value: GenericValue): (array: GenericArray) => PushOutput<GenericArray, GenericValue>;
 export declare function push<GenericArray extends readonly unknown[], const GenericValue extends unknown, GenericValuesRest extends readonly unknown[]>(array: GenericArray, value: GenericValue, ...valuesRest: GenericValuesRest): PushOutput<GenericArray, GenericValue, GenericValuesRest>;
 export {};

package/dist/chrono/operators/addTime.d.ts

@@ -1,7 +1,5 @@
 import { TheDate } from '../theDate';
 import { TheTime } from '../theTime';
 import { SerializedTheDate, SerializedTheTime } from '../types';
-export declare function addTime<GenericInput extends TheDate | SerializedTheDate>(time: TheTime | SerializedTheTime): (input: GenericInput) => TheDate;
-export declare function addTime<GenericInput extends TheTime | SerializedTheTime>(time: TheTime | SerializedTheTime): (input: GenericInput) => TheTime;
-export declare function addTime<GenericInput extends TheDate | SerializedTheDate>(input: GenericInput, time: TheTime | SerializedTheTime): TheDate;
-export declare function addTime<GenericInput extends TheTime | SerializedTheTime>(input: GenericInput, time: TheTime | SerializedTheTime): TheTime;
+export declare function addTime<GenericInput extends (TheDate | SerializedTheDate | TheTime | SerializedTheTime)>(time: TheTime | SerializedTheTime): (input: GenericInput) => (GenericInput extends (TheDate | SerializedTheDate) ? TheDate : GenericInput extends (TheTime | SerializedTheTime) ? TheTime : never);
+export declare function addTime<GenericInput extends (TheDate | SerializedTheDate | TheTime | SerializedTheTime)>(input: GenericInput, time: TheTime | SerializedTheTime): (GenericInput extends (TheDate | SerializedTheDate) ? TheDate : GenericInput extends (TheTime | SerializedTheTime) ? TheTime : never);

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

@@ -3,7 +3,7 @@ import { UnbundlesConstraint, BaseConstraint, RemoveConstraint } from '../types'
 import { CastError, RemoveCastError } from './error';
 import { ComputeCastConstraintNumberRule } from './number';
 import { ComputeCastConstraintStringRule } from './string';
-import { AnyTuple, IsExtends, BreakGenericLink, NeverCoalescing, UnionContain, IsEqual } from '../../types';
+import { IsExtends, BreakGenericLink, NeverCoalescing, UnionContain, IsEqual, AnyTuple, IsNever } from '../../types';
 import type * as DArray from '../../../array';
 import type * as DTuple from '../../../tuple';
 import type * as DObject from '../../../object';
@@ -16,8 +16,8 @@ export interface ComputeCastConstraintRule<GenericValue extends unknown, Generic
     number: GenericValue extends number ? DObject.Values<ComputeCastConstraintNumberRule<GenericValue, GenericConstraint>> : never;
     array: GenericValue extends readonly unknown[] ? DObject.Values<ComputeCastConstraintArrayRule<GenericValue, GenericConstraint>> : never;
 }
-export type ComputeCastConstraint<GenericValue extends unknown, GenericExpectedValue extends unknown> = (GenericExpectedValue extends any ? [UnbundlesConstraint<GenericExpectedValue>] : never) extends infer InferredComputedExpectedValue extends [BaseConstraint] ? DArray.Unwrap<NeverCoalescing<Extract<GenericValue extends any ? (InferredComputedExpectedValue extends [infer InferredConstraint extends BaseConstraint] ? NeverCoalescing<Extract<InferredConstraint extends any ? [
-    NeverCoalescing<DObject.Values<ComputeCastConstraintRule<GenericValue, InferredConstraint>>, CastError<"None of the intended constraints is possible on the current value.", GenericValue, InferredConstraint>>
+export type ComputeCastConstraint<GenericValue extends unknown, GenericExpectedValue extends unknown> = (GenericExpectedValue extends any ? [UnbundlesConstraint<GenericExpectedValue>] : never) extends infer InferredComputedExpectedValue extends [BaseConstraint] ? DArray.Unwrap<NeverCoalescing<Extract<GenericValue extends any ? (InferredComputedExpectedValue extends [infer InferredConstraint extends BaseConstraint] ? IsNever<InferredConstraint> extends true ? never : NeverCoalescing<Extract<InferredConstraint extends any ? [
+    GenericValue extends InferredConstraint ? unknown : NeverCoalescing<DObject.Values<ComputeCastConstraintRule<GenericValue, InferredConstraint>>, CastError<"None of the intended constraints is possible on the current value.", GenericValue, InferredConstraint>>
 ] : never, [
     CastError<any, any, any>
 ]>, [
@@ -25,7 +25,7 @@ export type ComputeCastConstraint<GenericValue extends unknown, GenericExpectedV
 ]> : never) extends infer InferredResult ? UnionContain<InferredResult, [unknown]> extends true ? [unknown] : InferredResult : never : never, [
     CastError<any, any, any>
 ]>, unknown>> : never;
-type ComputeTransformCastValue<GenericValue extends unknown> = GenericValue extends (string | number | AnyTuple) ? RemoveConstraint<GenericValue> : GenericValue extends readonly unknown[] ? DArray.ExtractLengthEqual<GenericValue, unknown> extends DArray.LengthEqual<infer InferredLength> ? DTuple.Create<GenericValue[number], InferredLength> : DArray.ExtractMinElements<GenericValue, unknown> extends DArray.MinElements<infer InferredMin> ? readonly [...DTuple.Create<GenericValue[number], InferredMin>, ...GenericValue] : RemoveConstraint<GenericValue> : never;
+type ComputeTransformCastValue<GenericValue extends unknown> = GenericValue extends AnyTuple ? RemoveConstraint<GenericValue> : GenericValue extends readonly unknown[] ? DArray.ExtractLengthEqual<GenericValue, unknown> extends DArray.LengthEqual<infer InferredLength> ? DTuple.Create<GenericValue[number], InferredLength> : DArray.ExtractMinElements<GenericValue, unknown> extends DArray.MinElements<infer InferredMin> ? readonly [...DTuple.Create<GenericValue[number], InferredMin>, ...GenericValue[number][]] : RemoveConstraint<GenericValue> : RemoveConstraint<GenericValue>;
 export type ComputeCastValue<GenericValue extends unknown, GenericExpectedValue extends unknown> = [
     ComputeTransformCastValue<GenericValue>,
     ComputeTransformCastValue<GenericExpectedValue>
@@ -33,5 +33,5 @@ export type ComputeCastValue<GenericValue extends unknown, GenericExpectedValue
     infer InferredValue,
     infer InferredExpectedValue
 ] ? IsExtends<InferredValue, InferredExpectedValue> extends true ? unknown : CastError<"Input value are not Extends", InferredValue, InferredExpectedValue> : never;
-export declare function cast<GenericInput extends unknown, GenericExpectedValue extends unknown, GenericError = (RemoveCastError<GenericInput> extends infer InferredInput ? ComputeCastConstraint<InferredInput, GenericExpectedValue> extends infer InferredConstraintResult ? IsEqual<InferredConstraintResult, unknown> extends true ? ComputeCastValue<InferredInput, GenericExpectedValue> : InferredConstraintResult : never : never)>(input: (GenericInput & BreakGenericLink<GenericError>)): GenericExpectedValue;
+export declare function cast<const GenericInput extends unknown, GenericExpectedValue extends unknown, GenericError = (RemoveCastError<GenericInput> extends infer InferredInput ? ComputeCastConstraint<InferredInput, GenericExpectedValue> extends infer InferredConstraintResult ? IsEqual<InferredConstraintResult, unknown> extends true ? ComputeCastValue<InferredInput, GenericExpectedValue> : InferredConstraintResult : never : never)>(input: (GenericInput & BreakGenericLink<GenericError>)): GenericExpectedValue;
 export declare function shameOnYou<GenericOutput extends unknown>(value: NoInfer<RemoveConstraint<GenericOutput>>): GenericOutput;

package/dist/common/constraint/cast/string.d.ts

@@ -7,6 +7,10 @@ export interface ComputeCastConstraintStringRule<GenericValue extends string, Ge
     maxCharacters: GenericExpectedConstraint extends DString.MaxCharacters<number> ? DCommon.NeverCoalescing<(DString.ComputeMaxCharactersCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DString.ExtractLengthEqual<GenericValue>> extends true ? CastError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is more than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on MaxCharacters because value does not have MaxCharacters constraint.", GenericValue, GenericExpectedConstraint>> : never;
     minCharacters: GenericExpectedConstraint extends DString.MinCharacters<number> ? DCommon.NeverCoalescing<(DString.ComputeMinCharactersCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DString.ExtractLengthEqual<GenericValue>> extends true ? CastError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on MinCharacters because value does not have MinCharacters constraint.", GenericValue, GenericExpectedConstraint>> : never;
     lengthEqual: GenericExpectedConstraint extends DString.LengthEqual<number> ? DCommon.NeverCoalescing<(DString.ComputeLengthEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : CastError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LengthEqual because value does not have LengthEqual constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    allowedCharacters: GenericExpectedConstraint extends DString.AllowedCharacters<infer InferredCharactersRange> ? DCommon.Or<[
+        DString.IsAllowedString<Extract<DCommon.RemoveConstraint<GenericValue>, string>, DString.CharactersRangeStore[InferredCharactersRange]>,
+        DCommon.IsExtends<GenericValue, GenericExpectedConstraint>
+    ]> extends true ? unknown : CastError<`Impossible to cast on AllowedCharacters because value ${GenericValue} contains forbidden characters.`, GenericValue, GenericExpectedConstraint> : never;
     number: DCommon.IsExtends<GenericExpectedConstraint, DString.Number> extends true ? DCommon.Or<[
         DCommon.IsExtends<GenericValue, DString.NumberInString>,
         DCommon.IsExtends<GenericValue, DString.Number>

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

@@ -19,8 +19,9 @@ export type ComputeInferConstraint<GenericInput extends unknown, GenericOutput e
     DCommon.IsNever<GenericOutput>
 ]> extends true ? unknown : (GenericInput extends unknown ? (GenericOutput extends unknown ? DObject.Values<ComputeInferConstraintRule<GenericInput, GenericOutput>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : GenericInput & DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.IsExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? InferredResult : Extract<InferredResult, DCommon.BaseConstraint> : never : never) extends infer InferredResult ? DCommon.IsExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
 export type SupportedOutputInfer = (string | readonly unknown[] | number);
+type ComputeInput<GenericInput extends unknown> = GenericInput extends SupportedOutputInfer ? DCommon.RemoveConstraint<GenericInput> extends infer InferredResult ? InferredResult extends readonly unknown[] ? readonly [...InferredResult] : InferredResult : never : never;
 type ComputeInferInputRequirement<GenericInput extends unknown> = GenericInput extends string ? DString.RequireLiteral<GenericInput> : GenericInput extends number ? DNumber.RequireLiteral<GenericInput> : GenericInput extends readonly unknown[] ? DTuple.Require<GenericInput> : never;
-export declare function infer<GenericOutput extends SupportedOutputInfer, const GenericInput extends DCommon.RemoveConstraint<GenericOutput> = never, GenericComputedOutput = ComputeInferConstraint<GenericInput, GenericOutput>>(input: (GenericInput & ComputeInferInputRequirement<GenericInput> & DCommon.BreakGenericLink<DCommon.NeverCoalescing<GenericComputedOutput extends DCommon.ComputedTypeError<string> ? GenericComputedOutput : never, unknown>>)): DCommon.Or<[
+export declare function infer<GenericOutput extends unknown, const GenericInput extends ComputeInput<GenericOutput> = never, GenericComputedOutput = ComputeInferConstraint<GenericInput, Extract<GenericOutput, SupportedOutputInfer>>>(input: (GenericInput & ComputeInferInputRequirement<GenericInput> & DCommon.BreakGenericLink<DCommon.NeverCoalescing<GenericComputedOutput extends DCommon.ComputedTypeError<string> ? GenericComputedOutput : never, unknown>>)): DCommon.Or<[
     DCommon.IsNever<GenericInput>,
     DCommon.ContainExtends<GenericComputedOutput, DCommon.ComputedTypeError<string>>
 ]> extends true ? GenericOutput : DCommon.BreakGenericLink<DCommon.NeverCoalescing<GenericComputedOutput, GenericInput>>;

package/dist/common/constraint/infer/string.d.ts

@@ -5,6 +5,7 @@ export interface ComputeInferConstraintStringRule<GenericInput extends string, G
     maxCharacters: DString.ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never;
     minCharacters: DString.ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never;
     lengthEqual: DString.ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never;
+    allowedCharacters: GenericOutput extends DString.AllowedCharacters<infer InferredCharactersRange> ? DString.IsAllowedString<GenericInput, DString.CharactersRangeStore[InferredCharactersRange]> extends true ? DString.AllowedCharacters<InferredCharactersRange> : DCommon.ComputedTypeError<`Impossible to cast on AllowedCharacters because value ${GenericInput} contains forbidden characters.`> : never;
     number: DCommon.IsExtends<GenericOutput, DString.Number> extends true ? GenericInput extends DString.NumberInString ? DString.Number : DCommon.ComputedTypeError<`Impossible to cast on Number because value ${GenericInput} is not a number.`> : never;
     path: DCommon.IsExtends<GenericOutput, DPath.Path> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
     absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on AbsolutePath because value ${GenericInput} is not absolute path.`> : never;

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

@@ -2,5 +2,6 @@ export * from './base';
 export type * from './compatibilityResult';
 export type * from './dynamic';
 export type * from './get';
+export type * from './maybe';
 export type * from './remove';
 export type * from './unbundles';

package/dist/common/constraint/types/maybe.d.ts

@@ -0,0 +1,2 @@
+import { Constraint } from './base';
+export type MaybeConstraint<GenericValue extends unknown> = (GenericValue | (GenericValue & Constraint));

package/dist/common/formData.d.ts

@@ -1,5 +1,6 @@
+import { Constraint } from './constraint';
 import * as DChrono from '../chrono';
-export type EligibleFormDataValue = (boolean | number | null | string | File | undefined | DChrono.TheDate | DChrono.TheTime | {
+export type EligibleFormDataValue = (boolean | number | null | string | File | undefined | DChrono.TheDate | DChrono.TheTime | Constraint | {
     [key: string]: EligibleFormDataValue;
 } | EligibleFormDataValue[]);
 export declare class TheFormData<GenericValues extends Record<string, EligibleFormDataValue>> extends FormData {

package/dist/common/memo.cjs

@@ -1,10 +1,11 @@
 //#region scripts/common/memo.ts
 function memo(theFunction) {
-	return { get value() {
+	const payload = { get value() {
 		const value = theFunction();
-		Object.defineProperty(this, "value", { value });
+		Object.defineProperty(payload, "value", { value });
 		return value;
 	} };
+	return payload;
 }
 //#endregion
 exports.memo = memo;

package/dist/common/memo.mjs

@@ -1,10 +1,11 @@
 //#region scripts/common/memo.ts
 function memo(theFunction) {
-	return { get value() {
+	const payload = { get value() {
 		const value = theFunction();
-		Object.defineProperty(this, "value", { value });
+		Object.defineProperty(payload, "value", { value });
 		return value;
 	} };
+	return payload;
 }
 //#endregion
 export { memo };

package/dist/common/memoPromise.cjs

@@ -3,17 +3,18 @@ const require_forward = require("./forward.cjs");
 //#region scripts/common/memoPromise.ts
 function memoPromise(getter) {
 	let externalPromise = require_forward.forward(void 0);
-	return { get value() {
+	const payload = { get value() {
 		if (externalPromise) return externalPromise.promise;
 		externalPromise = require_externalPromise.createExternalPromise();
 		const { resolve, reject } = externalPromise;
 		const promise = getter();
 		(promise instanceof Promise ? promise : Promise.resolve(promise)).then((result) => {
-			Object.defineProperty(this, "value", { value: result });
+			Object.defineProperty(payload, "value", { value: result });
 			resolve(result);
 		}).catch(reject);
 		return externalPromise.promise;
 	} };
+	return payload;
 }
 //#endregion
 exports.memoPromise = memoPromise;

package/dist/common/memoPromise.mjs

@@ -3,17 +3,18 @@ import { forward } from "./forward.mjs";
 //#region scripts/common/memoPromise.ts
 function memoPromise(getter) {
 	let externalPromise = forward(void 0);
-	return { get value() {
+	const payload = { get value() {
 		if (externalPromise) return externalPromise.promise;
 		externalPromise = createExternalPromise();
 		const { resolve, reject } = externalPromise;
 		const promise = getter();
 		(promise instanceof Promise ? promise : Promise.resolve(promise)).then((result) => {
-			Object.defineProperty(this, "value", { value: result });
+			Object.defineProperty(payload, "value", { value: result });
 			resolve(result);
 		}).catch(reject);
 		return externalPromise.promise;
 	} };
+	return payload;
 }
 //#endregion
 export { memoPromise };

package/dist/common/timeout.cjs

@@ -1,6 +1,6 @@
 //#region scripts/common/timeout.ts
-function timeout(millieSeconde) {
-	return new Promise((resolve) => void setTimeout(resolve, millieSeconde));
+function timeout(milliSeconds) {
+	return new Promise((resolve) => void setTimeout(resolve, milliSeconds));
 }
 //#endregion
 exports.timeout = timeout;

package/dist/common/timeout.d.ts

@@ -1 +1 @@
-export declare function timeout(millieSeconde?: number): Promise<void>;
+export declare function timeout(milliSeconds?: number): Promise<void>;

package/dist/common/timeout.mjs

@@ -1,6 +1,6 @@
 //#region scripts/common/timeout.ts
-function timeout(millieSeconde) {
-	return new Promise((resolve) => void setTimeout(resolve, millieSeconde));
+function timeout(milliSeconds) {
+	return new Promise((resolve) => void setTimeout(resolve, milliSeconds));
 }
 //#endregion
 export { timeout };

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

@@ -0,0 +1 @@
+export type ApplyPromiseIf<GenericValue extends unknown, GenericBoolean extends boolean> = true extends GenericBoolean ? Promise<GenericValue> : GenericValue;

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

@@ -6,6 +6,7 @@ export type * from './anyObject';
 export type * from './anyPredicate';
 export type * from './anyTuple';
 export type * from './anyValue';
+export type * from './applyPromiseIf';
 export type * from './bivariantFunction';
 export type * from './breakGenericLink';
 export type * from './cleanObjectEntry';
@@ -26,6 +27,7 @@ export type * from './forward';
 export type * from './hasSomething';
 export type * from './isEqual';
 export type * from './isNever';
+export type * from './isObject';
 export type * from './isUnion';
 export type * from './json';
 export type * from './lastUnionElement';

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

@@ -0,0 +1,8 @@
+import { And } from './and';
+import { IsExtends } from './IsExtends';
+import { IsNever } from './isNever';
+import { Not } from './not';
+export type IsObject<GenericValue extends unknown> = And<[
+    IsExtends<GenericValue, object>,
+    Not<IsNever<keyof GenericValue>>
+]>;

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

@@ -1,4 +1,15 @@
+import { RemoveConstraint } from '../constraint';
 import { MaybeArray } from './maybeArray';
-export type Json = MaybeArray<string | undefined | boolean | number | null | {
+import type * as DModeling from '../../modeling';
+import type * as DKind from '../../kind';
+export type JsonPrimitive = (string | undefined | boolean | number | null);
+export type Json = MaybeArray<JsonPrimitive | {
     readonly [key: string]: Json;
 }>;
+type ObjectToJson<GenericValue extends object, GenericIgnore extends unknown, GenericClearValue = RemoveConstraint<DKind.Remove<GenericValue>>, GenericConstraint = (GenericValue extends (GenericClearValue & infer InferredConstraint) ? InferredConstraint : unknown), GenericEntity = (GenericValue extends DModeling.Entity<infer InferredName> ? DModeling.Entity<InferredName> : unknown), GenericObjectTag = (GenericValue extends DModeling.ObjectTag<infer InferredName> ? DModeling.ObjectTag<InferredName> : unknown)> = GenericClearValue extends [infer InferredFirst, ...infer InferredRest] ? [ToJson<InferredFirst, GenericIgnore>, ...ToJson<InferredRest, GenericIgnore>] & GenericConstraint : GenericClearValue extends [] ? [] & GenericConstraint : GenericClearValue extends (infer InferredElement)[] ? ToJson<InferredElement, GenericIgnore>[] & GenericConstraint : GenericClearValue extends readonly [infer InferredFirst, ...infer InferredRest] ? readonly [ToJson<InferredFirst, GenericIgnore>, ...ToJson<InferredRest, GenericIgnore>] : GenericClearValue extends readonly [] & GenericConstraint ? readonly [] & GenericConstraint : GenericClearValue extends readonly (infer InferredElement)[] ? readonly ToJson<InferredElement, GenericIgnore>[] & GenericConstraint : GenericClearValue extends object ? ({
+    [Prop in keyof GenericClearValue]: ToJson<GenericClearValue[Prop], GenericIgnore>;
+} & GenericConstraint & GenericEntity & GenericObjectTag) : never;
+export type ToJson<GenericValue extends unknown, GenericIgnore extends unknown = never> = GenericValue extends (JsonPrimitive | GenericIgnore) ? GenericValue : GenericValue extends {
+    toJSON(): unknown;
+} ? ToJson<ReturnType<GenericValue["toJSON"]>, GenericIgnore> : GenericValue extends object ? ObjectToJson<GenericValue, GenericIgnore> : GenericValue;
+export {};

package/dist/dataStructure/common/codec/base.cjs

@@ -9,8 +9,8 @@ function createCodec(fundamentalType, predicateEncode, encode, decode) {
 	const self = {
 		fundamentalType,
 		predicateEncode: (data) => predicateEncode(data),
-		encode: (data, errorHandler) => require_callThen.callThen(encode(data, self, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? require_resultSymbol.ErrorSymbol : encodedData)),
-		decode: (data, errorHandler) => require_callThen.callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? require_resultSymbol.ErrorSymbol : decode(data, self, errorHandler)),
+		encode: (data, errorHandler) => require_callThen.callThen(encode(data, self, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? errorHandler?.().addEncodeIssue(self, "encoding", data) ?? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, "predicate", encodedData) ?? require_resultSymbol.ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => require_callThen.callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, "predicate", data) ?? require_resultSymbol.ErrorSymbol : require_callThen.callThen(decode(data, self, errorHandler), (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? errorHandler?.().addDecodeIssue(self, "decoding", data) ?? require_resultSymbol.ErrorSymbol : decodedData)),
 		[codecKind.runTimeKey]: null
 	};
 	return self;

package/dist/dataStructure/common/codec/base.mjs

@@ -9,8 +9,8 @@ function createCodec(fundamentalType, predicateEncode, encode, decode) {
 	const self = {
 		fundamentalType,
 		predicateEncode: (data) => predicateEncode(data),
-		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? ErrorSymbol : encodedData)),
-		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? ErrorSymbol : decode(data, self, errorHandler)),
+		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? errorHandler?.().addEncodeIssue(self, "encoding", data) ?? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, "predicate", encodedData) ?? ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, "predicate", data) ?? ErrorSymbol : callThen(decode(data, self, errorHandler), (decodedData) => decodedData === ErrorSymbol ? errorHandler?.().addDecodeIssue(self, "decoding", data) ?? ErrorSymbol : decodedData)),
 		[codecKind.runTimeKey]: null
 	};
 	return self;

package/dist/dataStructure/common/codec/defaults/string.cjs

@@ -38,7 +38,7 @@ const codecsString = require_base.createCodecs({
 		}
 	}),
 	time: require_base.createCodec(require_time.TheTime, (data) => typeof data === "string", require_to.to, require_innerPipe.innerPipe((value) => require_createTime.createTime({ value }), require_whenHasInformationOtherwise.whenHasInformationOtherwise("time-created", require_forward.forward, require_justReturn.justReturn(require_resultSymbol.ErrorSymbol)))),
-	undefined: require_base.createCodec(require_undefined.TheUndefined, (data) => data === "undefined", require_to.to, require_justReturn.justReturn(void 0))
+	undefined: require_base.createCodec(require_undefined.TheUndefined, (data) => data === void 0 || data === "undefined", require_to.to, require_justReturn.justReturn(void 0))
 });
 //#endregion
 exports.codecsString = codecsString;

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

@@ -7,5 +7,5 @@ export declare const codecsString: import('../../..').Codecs<{
     null: import('../../..').Codec<FundamentalType.TheNull, "null">;
     number: import('../../..').Codec<FundamentalType.TheNumber, string & DString.Number>;
     time: import('../../..').Codec<FundamentalType.TheTime, string>;
-    undefined: import('../../..').Codec<FundamentalType.TheUndefined, "undefined">;
+    undefined: import('../../..').Codec<FundamentalType.TheUndefined, "undefined" | undefined>;
 }>;

package/dist/dataStructure/common/codec/defaults/string.mjs

@@ -38,7 +38,7 @@ const codecsString = createCodecs({
 		}
 	}),
 	time: createCodec(TheTime, (data) => typeof data === "string", to, innerPipe((value) => createTime({ value }), whenHasInformationOtherwise("time-created", forward, justReturn(ErrorSymbol)))),
-	undefined: createCodec(TheUndefined, (data) => data === "undefined", to, justReturn(void 0))
+	undefined: createCodec(TheUndefined, (data) => data === void 0 || data === "undefined", to, justReturn(void 0))
 });
 //#endregion
 export { codecsString };

package/dist/dataStructure/common/{error.cjs → error/base.cjs}

@@ -1,8 +1,21 @@
-const require_kind = require("../kind.cjs");
-//#region scripts/dataStructure/common/error.ts
+const require_parentClass = require("../../../kind/parentClass.cjs");
+const require_kind = require("../../kind.cjs");
+//#region scripts/dataStructure/common/error/base.ts
 const issueKind = require_kind.createKind("issue");
 const encodeIssueKind = require_kind.createKind("encode-issue");
 const decodeIssueKind = require_kind.createKind("decode-issue");
+var Error = class extends require_parentClass.parentClass(require_kind.createKind("error"), globalThis.Error) {
+	issues;
+	constructor(issues) {
+		super(null, "DataStructure Error.");
+		this.issues = issues;
+	}
+};
+var ErrorPromise = class extends require_parentClass.parentClass(require_kind.createKind("error-promise"), globalThis.Error) {
+	constructor() {
+		super(null, "DataStructure Error Promise.");
+	}
+};
 function createErrorHandler(defaultPath) {
 	const issues = [];
 	const currentPath = defaultPath ? [...defaultPath] : [];
@@ -34,8 +47,9 @@ function createErrorHandler(defaultPath) {
 				[issueKind.runTimeKey]: null
 			});
 		},
-		addEncodeIssue: (source, data, message) => {
+		addEncodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,
@@ -43,8 +57,9 @@ function createErrorHandler(defaultPath) {
 				[encodeIssueKind.runTimeKey]: null
 			});
 		},
-		addDecodeIssue: (source, data, message) => {
+		addDecodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,
@@ -52,7 +67,7 @@ function createErrorHandler(defaultPath) {
 				[decodeIssueKind.runTimeKey]: null
 			});
 		},
-		createError: () => ({ issues }),
+		createError: () => new Error(issues),
 		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues))
 	};
 }
@@ -64,6 +79,8 @@ function createGetErrorHandler(defaultPath) {
 	};
 }
 //#endregion
+exports.Error = Error;
+exports.ErrorPromise = ErrorPromise;
 exports.createErrorHandler = createErrorHandler;
 exports.createGetErrorHandler = createGetErrorHandler;
 exports.decodeIssueKind = decodeIssueKind;

package/dist/dataStructure/common/{error.d.ts → error/base.d.ts}

@@ -1,9 +1,9 @@
-import { Constraint } from '../constraint';
-import { Structure } from '../structure';
-import { Type } from '../type';
-import { Codec } from './codec';
-import type * as DCommon from '../../common';
-import type * as DKind from '../../kind';
+import { Constraint } from '../../constraint';
+import { Structure } from '../../structure';
+import { Type } from '../../type';
+import { Codec } from '../codec';
+import type * as DCommon from '../../../common';
+import * as DKind from '../../../kind';
 export declare const issueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/issue", unknown>>;
 export interface Issue extends DKind.Kind<typeof issueKind> {
     readonly path: string;
@@ -13,6 +13,7 @@ export interface Issue extends DKind.Kind<typeof issueKind> {
 }
 export declare const encodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/encode-issue", unknown>>;
 export interface EncodeIssue extends DKind.Kind<typeof encodeIssueKind> {
+    readonly from: "encoding" | "predicate" | "external";
     readonly path: string;
     readonly data: unknown;
     readonly message?: string;
@@ -20,6 +21,7 @@ export interface EncodeIssue extends DKind.Kind<typeof encodeIssueKind> {
 }
 export declare const decodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/decode-issue", unknown>>;
 export interface DecodeIssue extends DKind.Kind<typeof decodeIssueKind> {
+    readonly from: "decoding" | "predicate" | "external";
     readonly path: string;
     readonly data: unknown;
     readonly message?: string;
@@ -30,15 +32,21 @@ export interface PathStageErrorHandler {
     setCurrentPath(path: string): void;
     close(): void;
 }
-export interface Error {
+declare const Error_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/error", unknown>>, ErrorConstructor>;
+export declare class Error extends Error_base {
     readonly issues: readonly Issues[];
+    constructor(issues: readonly Issues[]);
+}
+declare const ErrorPromise_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/error-promise", unknown>>, ErrorConstructor>;
+export declare class ErrorPromise extends ErrorPromise_base {
+    constructor();
 }
 export interface ErrorHandler {
     readonly issues: readonly Issues[];
     readonly currentPath: string[];
     addIssue(source: ReturnType<Issue["getSource"]>, data: unknown, subSource?: ReturnType<Extract<Issue["getSubSource"], DCommon.AnyFunction>>): void;
-    addEncodeIssue(source: ReturnType<EncodeIssue["getSource"]>, data: unknown, message?: string): void;
-    addDecodeIssue(source: ReturnType<DecodeIssue["getSource"]>, data: unknown, message?: string): void;
+    addEncodeIssue(source: ReturnType<EncodeIssue["getSource"]>, from: EncodeIssue["from"], data: unknown, message?: string): void;
+    addDecodeIssue(source: ReturnType<DecodeIssue["getSource"]>, from: DecodeIssue["from"], data: unknown, message?: string): void;
     importIssues(errorHandler: (GetErrorHandler | ErrorHandler)[]): void;
     createPathStage(): PathStageErrorHandler;
     createError(): Error;
@@ -46,3 +54,4 @@ export interface ErrorHandler {
 export declare function createErrorHandler(defaultPath?: string[]): ErrorHandler;
 export type GetErrorHandler = () => ErrorHandler;
 export declare function createGetErrorHandler(defaultPath?: string[]): GetErrorHandler;
+export {};

package/dist/dataStructure/common/{error.mjs → error/base.mjs}

@@ -1,8 +1,21 @@
-import { createKind } from "../kind.mjs";
-//#region scripts/dataStructure/common/error.ts
+import { parentClass } from "../../../kind/parentClass.mjs";
+import { createKind } from "../../kind.mjs";
+//#region scripts/dataStructure/common/error/base.ts
 const issueKind = createKind("issue");
 const encodeIssueKind = createKind("encode-issue");
 const decodeIssueKind = createKind("decode-issue");
+var Error = class extends parentClass(createKind("error"), globalThis.Error) {
+	issues;
+	constructor(issues) {
+		super(null, "DataStructure Error.");
+		this.issues = issues;
+	}
+};
+var ErrorPromise = class extends parentClass(createKind("error-promise"), globalThis.Error) {
+	constructor() {
+		super(null, "DataStructure Error Promise.");
+	}
+};
 function createErrorHandler(defaultPath) {
 	const issues = [];
 	const currentPath = defaultPath ? [...defaultPath] : [];
@@ -34,8 +47,9 @@ function createErrorHandler(defaultPath) {
 				[issueKind.runTimeKey]: null
 			});
 		},
-		addEncodeIssue: (source, data, message) => {
+		addEncodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,
@@ -43,8 +57,9 @@ function createErrorHandler(defaultPath) {
 				[encodeIssueKind.runTimeKey]: null
 			});
 		},
-		addDecodeIssue: (source, data, message) => {
+		addDecodeIssue: (source, from, data, message) => {
 			issues.push({
+				from,
 				data,
 				path: currentPath.join("."),
 				message,
@@ -52,7 +67,7 @@ function createErrorHandler(defaultPath) {
 				[decodeIssueKind.runTimeKey]: null
 			});
 		},
-		createError: () => ({ issues }),
+		createError: () => new Error(issues),
 		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues))
 	};
 }
@@ -64,4 +79,4 @@ function createGetErrorHandler(defaultPath) {
 	};
 }
 //#endregion
-export { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind };
+export { Error, ErrorPromise, createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind };