@duplojs/lang 0.0.0

package/dist/common/builder.d.ts

@@ -0,0 +1,32 @@
+import { IsEqual, AnyFunction, ObjectKey } from './types';
+import * as DKind from '../kind';
+import type * as DObject from '../object';
+declare const BuilderStoreSymbol: unique symbol;
+type BuilderStoreSymbol = typeof BuilderStoreSymbol;
+declare module "./globalStore" {
+    interface GlobalStore {
+        [BuilderStoreSymbol]: Record<string, Record<string, Parameters<BuilderHandler["set"]>[1]>>;
+    }
+}
+export declare const builderKind: DKind.Handler<DKind.Definition<"@DuplojsLangCommon/builder-base", object>>;
+export interface Builder<GenericAccumulator extends object = object, GenericIdentifier extends ObjectKey = never> extends DKind.Kind<typeof builderKind, GenericAccumulator> {
+}
+declare const builderNextKind: DKind.Handler<DKind.Definition<"@DuplojsLangCommon/builder-next", unknown>>;
+interface BuilderNext<GenericValue extends object = object> extends DKind.Kind<typeof builderNextKind, GenericValue> {
+}
+export interface BuilderHandlerSetFunctionParams<GenericArgs extends unknown[], GenericValue extends object> {
+    args: GenericArgs;
+    accumulator: GenericValue;
+    next(newAccumulator: GenericValue): BuilderNext<GenericValue>;
+}
+export interface BuilderHandler<GenericBuilder extends Builder = Builder> {
+    set<GenericMethodName extends DObject.GetPropsWithValueExtends<GenericBuilder, AnyFunction>, GenericMethod extends Extract<GenericBuilder[GenericMethodName], AnyFunction>>(method: GenericMethodName, theFunction: (params: BuilderHandlerSetFunctionParams<Parameters<GenericMethod>, DKind.GetValue<typeof builderKind, GenericBuilder>>) => IsEqual<keyof ReturnType<GenericMethod>, keyof GenericBuilder> extends true ? BuilderNext<DKind.GetValue<typeof builderKind, GenericBuilder>> : ReturnType<GenericMethod>): BuilderHandler<GenericBuilder>;
+    use<GenericCurrentBuilder extends GenericBuilder>(accumulator: DKind.GetValue<typeof builderKind, GenericBuilder>): GenericCurrentBuilder;
+}
+declare const MissingBuilderMethodsError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangCommon/missing-builder-methods-error", unknown>>, ErrorConstructor>;
+export declare class MissingBuilderMethodsError extends MissingBuilderMethodsError_base {
+    method: string;
+    constructor(method: string);
+}
+export declare function createBuilder<GenericBuilder extends Builder>(builderName: string): BuilderHandler<GenericBuilder>;
+export {};

package/dist/common/builder.mjs

@@ -0,0 +1,46 @@
+import { parentClass } from "../kind/parentClass.mjs";
+import { createKind } from "./kind.mjs";
+import { createGlobalStore } from "./globalStore.mjs";
+//#region scripts/common/builder.ts
+const builderStore = createGlobalStore(Symbol("BuilderStoreSymbol"), {});
+const builderKind = createKind("builder-base");
+const builderNextKind = createKind("builder-next");
+var MissingBuilderMethodsError = class extends parentClass(createKind("missing-builder-methods-error"), Error) {
+	method;
+	constructor(method) {
+		super(`Missing builder method: ${method}`);
+		this.method = method;
+	}
+};
+function createBuilder(builderName) {
+	const store = builderStore.value[builderName] ?? {};
+	builderStore.set({
+		...builderStore.value,
+		[builderName]: store
+	});
+	const builderHandler = {
+		set(method, theFunction) {
+			store[method] = theFunction;
+			return builderHandler;
+		},
+		use(accumulator) {
+			return new Proxy(builderKind.addTo(store, accumulator), { get(target, prop) {
+				if (prop === builderKind.runTimeKey) return target[prop];
+				if (!target[prop]) throw new MissingBuilderMethodsError(prop);
+				const theFunction = target[prop];
+				return (...args) => {
+					const result = theFunction({
+						args,
+						accumulator,
+						next: (newAccumulator) => builderNextKind.addTo({}, newAccumulator)
+					});
+					if (builderNextKind.has(result)) return builderHandler.use(builderNextKind.getValue(result));
+					return result;
+				};
+			} });
+		}
+	};
+	return builderHandler;
+}
+//#endregion
+export { MissingBuilderMethodsError, builderKind, createBuilder };

package/dist/common/callThen.cjs

@@ -0,0 +1,13 @@
+//#region scripts/common/callThen.ts
+function callThen(input, theFunction, catchFunction) {
+	if (catchFunction) try {
+		if (input instanceof Promise) return input.then(theFunction).catch(catchFunction);
+		return theFunction(input);
+	} catch (error) {
+		return catchFunction(error);
+	}
+	if (input instanceof Promise) return input.then(theFunction);
+	return theFunction(input);
+}
+//#endregion
+exports.callThen = callThen;

package/dist/common/callThen.d.ts

@@ -0,0 +1 @@
+export declare function callThen<GenericInput extends unknown, GenericOutput extends unknown, GenericOutputCatch extends unknown = never>(input: GenericInput, theFunction: (result: Awaited<GenericInput>) => GenericOutput, catchFunction?: (error: unknown) => GenericOutputCatch): (GenericInput extends Promise<unknown> ? Promise<Awaited<GenericOutput | GenericOutputCatch>> : GenericOutput | GenericOutputCatch);

package/dist/common/callThen.mjs

@@ -0,0 +1,13 @@
+//#region scripts/common/callThen.ts
+function callThen(input, theFunction, catchFunction) {
+	if (catchFunction) try {
+		if (input instanceof Promise) return input.then(theFunction).catch(catchFunction);
+		return theFunction(input);
+	} catch (error) {
+		return catchFunction(error);
+	}
+	if (input instanceof Promise) return input.then(theFunction);
+	return theFunction(input);
+}
+//#endregion
+export { callThen };

package/dist/common/clone.cjs

@@ -0,0 +1,16 @@
+const require_entries = require("../object/entries.cjs");
+//#region scripts/common/clone.ts
+function clone(input) {
+	return cloneUnknown(input);
+}
+function cloneUnknown(input) {
+	if (!input) return input;
+	else if (typeof input !== "object") return input;
+	else if (input instanceof Array) return input.map(cloneUnknown);
+	else return require_entries.entries(input).reduce((output, [key, value]) => {
+		output[key] = cloneUnknown(value);
+		return output;
+	}, {});
+}
+//#endregion
+exports.clone = clone;

package/dist/common/clone.d.ts

@@ -0,0 +1,2 @@
+import { SimplifyTypeForce } from './types';
+export declare function clone<GenericValue extends unknown = unknown>(input: GenericValue): SimplifyTypeForce<GenericValue>;

package/dist/common/clone.mjs

@@ -0,0 +1,16 @@
+import { entries } from "../object/entries.mjs";
+//#region scripts/common/clone.ts
+function clone(input) {
+	return cloneUnknown(input);
+}
+function cloneUnknown(input) {
+	if (!input) return input;
+	else if (typeof input !== "object") return input;
+	else if (input instanceof Array) return input.map(cloneUnknown);
+	else return entries(input).reduce((output, [key, value]) => {
+		output[key] = cloneUnknown(value);
+		return output;
+	}, {});
+}
+//#endregion
+export { clone };

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

@@ -0,0 +1,9 @@
+import { CastError } from './error';
+import { CompatibilityConstraintResult, BaseConstraint } from '../types';
+import type * as DArray from '../../../array';
+import type * as DCommon from '../..';
+export interface ComputeCastConstraintArrayRule<GenericValue extends readonly unknown[], GenericExpectedConstraint extends BaseConstraint> {
+    minElements: GenericExpectedConstraint extends DArray.MinElements<number> ? DCommon.NeverCoalescing<(DArray.ComputeMinElementsCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DArray.ExtractLengthEqual<GenericValue>> extends true ? CastError<`Impossible to cast on MinElements<${InferredResult["to"]}> because constraint MinElements<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on MinElements<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on MinElements because value does not have MinElements constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    maxElements: GenericExpectedConstraint extends DArray.MaxElements<number> ? DCommon.NeverCoalescing<(DArray.ComputeMaxElementsCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DArray.ExtractLengthEqual<GenericValue>> extends true ? CastError<`Impossible to cast on MaxElements<${InferredResult["to"]}> because constraint MaxElements<${InferredResult["from"]}> from the value is more than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on MaxElements<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is more than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on MaxElements because value does not have MaxElements constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    lengthEqual: GenericExpectedConstraint extends DArray.LengthEqual<number> ? DCommon.NeverCoalescing<(DArray.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;
+}

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

@@ -0,0 +1,9 @@
+import { ComputedTypeError } from '../../types';
+declare const CastErrorValueSymbol: unique symbol;
+declare const CastErrorExpectedValueSymbol: unique symbol;
+export type RemoveCastError<GenericValue extends unknown> = GenericValue extends CastError<infer InferredMessage, infer InferredValue, infer InferredExpectedValue> ? GenericValue extends (infer InferredValue & CastError<InferredMessage, InferredValue, InferredExpectedValue>) ? InferredValue : GenericValue : GenericValue;
+export interface CastError<GenericReason extends string, GenericValue extends unknown, GenericExpectedValue extends unknown> extends ComputedTypeError<GenericReason> {
+    [CastErrorValueSymbol]: RemoveCastError<GenericValue>;
+    [CastErrorExpectedValueSymbol]: GenericExpectedValue;
+}
+export {};

package/dist/common/constraint/cast/index.cjs

@@ -0,0 +1,10 @@
+//#region scripts/common/constraint/cast/index.ts
+function cast(input) {
+	return input;
+}
+function shameOnYou(value) {
+	return value;
+}
+//#endregion
+exports.cast = cast;
+exports.shameOnYou = shameOnYou;

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

@@ -0,0 +1,37 @@
+import { ComputeCastConstraintArrayRule } from './array';
+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 type * as DArray from '../../../array';
+import type * as DTuple from '../../../tuple';
+import type * as DObject from '../../../object';
+export type * from './array';
+export type * from './error';
+export type * from './number';
+export type * from './string';
+export interface ComputeCastConstraintRule<GenericValue extends unknown, GenericConstraint extends BaseConstraint> {
+    string: GenericValue extends string ? DObject.Values<ComputeCastConstraintStringRule<GenericValue, GenericConstraint>> : never;
+    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>>
+] : never, [
+    CastError<any, any, any>
+]>, [
+    unknown
+]> : 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;
+export type ComputeCastValue<GenericValue extends unknown, GenericExpectedValue extends unknown> = [
+    ComputeTransformCastValue<GenericValue>,
+    ComputeTransformCastValue<GenericExpectedValue>
+] extends [
+    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 shameOnYou<GenericOutput extends unknown>(value: NoInfer<RemoveConstraint<GenericOutput>>): GenericOutput;

package/dist/common/constraint/cast/index.mjs

@@ -0,0 +1,9 @@
+//#region scripts/common/constraint/cast/index.ts
+function cast(input) {
+	return input;
+}
+function shameOnYou(value) {
+	return value;
+}
+//#endregion
+export { cast, shameOnYou };

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

@@ -0,0 +1,10 @@
+import { CastError } from './error';
+import { CompatibilityConstraintResult, BaseConstraint } from '../types';
+import type * as DNumber from '../../../number';
+import type * as DCommon from '../..';
+export interface ComputeCastConstraintNumberRule<GenericValue extends number, GenericExpectedConstraint extends BaseConstraint> {
+    greaterThan: GenericExpectedConstraint extends DNumber.GreaterThan<number> ? DCommon.NeverCoalescing<(DNumber.ComputeGreaterThanCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractGreaterThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on GreaterThan<${InferredResult["to"]}> because constraint GreaterThan<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on GreaterThan<${InferredResult["to"]}> because constraint GreaterThanOrEqual<${InferredResult["from"]}> from the value is less than or equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on GreaterThan because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    greaterThanOrEqual: GenericExpectedConstraint extends DNumber.GreaterThanOrEqual<number> ? DCommon.NeverCoalescing<(DNumber.ComputeGreaterThanOrEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractGreaterThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on GreaterThanOrEqual<${InferredResult["to"]}> because constraint GreaterThan<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on GreaterThanOrEqual<${InferredResult["to"]}> because constraint GreaterThanOrEqual<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on GreaterThanOrEqual because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    lessThan: GenericExpectedConstraint extends DNumber.LessThan<number> ? DCommon.NeverCoalescing<(DNumber.ComputeLessThanCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractLessThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on LessThan<${InferredResult["to"]}> because constraint LessThan<${InferredResult["from"]}> from the value is greater than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on LessThan<${InferredResult["to"]}> because constraint LessThanOrEqual<${InferredResult["from"]}> from the value is greater than or equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LessThan because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    lessThanOrEqual: GenericExpectedConstraint extends DNumber.LessThanOrEqual<number> ? DCommon.NeverCoalescing<(DNumber.ComputeLessThanOrEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractLessThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on LessThanOrEqual<${InferredResult["to"]}> because constraint LessThan<${InferredResult["from"]}> from the value is greater than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on LessThanOrEqual<${InferredResult["to"]}> because constraint LessThanOrEqual<${InferredResult["from"]}> from the value is greater than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LessThanOrEqual because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
+}

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

@@ -0,0 +1,9 @@
+import { CastError } from './error';
+import { CompatibilityConstraintResult, BaseConstraint } from '../types';
+import type * as DString from '../../../string';
+import type * as DCommon from '../..';
+export interface ComputeCastConstraintStringRule<GenericValue extends string, GenericExpectedConstraint extends BaseConstraint> {
+    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;
+}

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

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

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

@@ -0,0 +1,7 @@
+export declare const ConstraintSymbol: unique symbol;
+export type ConstraintSymbol = typeof ConstraintSymbol;
+export interface BaseConstraint<GenericValue extends Record<string, unknown> = Record<string, unknown>> {
+    [ConstraintSymbol]: GenericValue;
+}
+export interface Constraint<GenericName extends string = string, GenericValue extends unknown = unknown> extends BaseConstraint<Record<GenericName, GenericValue>> {
+}

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

@@ -0,0 +1,5 @@
+export interface CompatibilityConstraintResult<GenericResult extends boolean = boolean, GenericFrom extends unknown = unknown, GenericTo extends unknown = unknown> {
+    result: GenericResult;
+    from: GenericFrom;
+    to: GenericTo;
+}

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

@@ -0,0 +1,3 @@
+import { Constraint } from './base';
+export interface DynamicConstraint<GenericName extends string = string, GenericValue extends string | number = never> extends Constraint<GenericName, Record<GenericValue, unknown>> {
+}

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

@@ -0,0 +1,3 @@
+import { BaseConstraint } from './base';
+import { RemoveConstraint } from './remove';
+export type GetConstraint<GenericValue extends unknown> = GenericValue extends ((infer InferredValue extends BaseConstraint) & RemoveConstraint<GenericValue>) ? InferredValue : never;

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

@@ -0,0 +1,6 @@
+export * from './base';
+export type * from './compatibilityResult';
+export type * from './dynamic';
+export type * from './get';
+export type * from './remove';
+export type * from './unbundles';

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

@@ -0,0 +1,7 @@
+import { BaseConstraint } from './base';
+import type * as DObject from '../../../object';
+import type * as DCommon from '../..';
+type Remove<GenericValue extends unknown, GenericShape extends object, GenericLast extends object> = GenericValue extends (infer InferredValue & GenericShape) ? RemoveConstraintByShape<InferredValue, DCommon.ExcludeEqual<GenericShape, GenericLast>> : GenericValue;
+type RemoveConstraintByShape<GenericValue extends unknown, GenericShape extends object> = DCommon.IsNever<GenericShape> extends true ? GenericValue : Remove<GenericValue, GenericShape, DCommon.LastUnionElement<GenericShape>>;
+export type RemoveConstraint<GenericValue extends unknown> = (GenericValue extends BaseConstraint ? RemoveConstraintByShape<GenericValue, DObject.Split<Pick<GenericValue, DCommon.ConstraintSymbol>>> : GenericValue) extends infer InferredResult ? (InferredResult extends BaseConstraint ? RemoveConstraintByShape<InferredResult, Pick<InferredResult, DCommon.ConstraintSymbol>> : InferredResult) extends infer InferredResult ? (InferredResult extends BaseConstraint ? RemoveConstraintByShape<InferredResult, DObject.Split<Pick<InferredResult, DCommon.ConstraintSymbol>, 2>> : InferredResult) extends infer InferredResult ? (InferredResult extends BaseConstraint ? RemoveConstraintByShape<InferredResult, DObject.EveryCombination<Pick<InferredResult, DCommon.ConstraintSymbol>>> : InferredResult) : never : never : never;
+export {};

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

@@ -0,0 +1,17 @@
+import { BaseConstraint } from './base';
+import type * as DObject from '../../../object';
+import type * as DArray from '../../../array';
+import type * as DNumber from '../../../number';
+import type * as DString from '../../../string';
+import type * as DCommon from '../..';
+declare const RestSymbol: unique symbol;
+type RestSymbol = typeof RestSymbol;
+type Rest<GenericConstraint extends BaseConstraint = BaseConstraint> = [
+    GenericConstraint,
+    RestSymbol
+];
+type UnwrapRest<GenericValue extends unknown> = GenericValue extends Rest ? GenericValue[0] : GenericValue;
+type Separate<GenericValue extends unknown, GenericShape extends object, GenericLast extends object> = GenericValue extends (infer InferredRest & GenericLast) ? GenericValue extends (infer InferredConstraint & InferredRest) ? (Extract<InferredConstraint, BaseConstraint> | SeparateByShape<InferredRest, DCommon.ExcludeEqual<GenericShape, GenericLast>>) : never : never;
+type SeparateByShape<GenericValue extends unknown, GenericShape extends object> = DCommon.IsNever<GenericShape> extends true ? GenericValue extends BaseConstraint ? Rest<GenericValue> : never : Separate<GenericValue, GenericShape, DCommon.LastUnionElement<GenericShape>>;
+export type UnbundlesConstraint<GenericValue extends unknown> = ((GenericValue extends BaseConstraint ? SeparateByShape<GenericValue, DObject.Split<Pick<GenericValue, DCommon.ConstraintSymbol>>> : never) | (GenericValue extends DCommon.AnyTuple ? (DArray.ExtractMinElements<GenericValue> | DArray.ExtractMaxElements<GenericValue> | DArray.ExtractLengthEqual<GenericValue>) : GenericValue extends number ? (DNumber.ExtractGreaterThanOrEqual<GenericValue> | DNumber.ExtractLessThanOrEqual<GenericValue>) : GenericValue extends string ? (DString.ExtractLengthEqual<GenericValue> | DString.ExtractMinCharacters<GenericValue> | DString.ExtractMaxCharacters<GenericValue>) : never)) extends infer InferredResult ? (InferredResult extends Rest ? UnwrapRest<SeparateByShape<InferredResult[0], Pick<InferredResult[0], DCommon.ConstraintSymbol>>> : InferredResult) extends infer InferredResult ? (InferredResult extends Rest ? UnwrapRest<SeparateByShape<InferredResult[0], DObject.Split<Pick<InferredResult[0], DCommon.ConstraintSymbol>, 2>>> : InferredResult) extends infer InferredResult ? (InferredResult extends Rest ? UnwrapRest<SeparateByShape<InferredResult[0], DObject.EveryCombination<Pick<InferredResult[0], DCommon.ConstraintSymbol>, 2>>> : InferredResult) : never : never : never;
+export {};

package/dist/common/detachObjectMethod.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/detachObjectMethod.ts
+function detachObjectMethod(object, method) {
+	return object[method].bind(object);
+}
+//#endregion
+exports.detachObjectMethod = detachObjectMethod;

package/dist/common/detachObjectMethod.d.ts

@@ -0,0 +1,3 @@
+import { AnyFunction } from './types';
+import type * as DObject from '../object';
+export declare function detachObjectMethod<GenericObject extends object, GenericMethod extends keyof GenericObject>(object: GenericObject, method: GenericMethod & DObject.GetPropsWithValueExtends<GenericObject, AnyFunction>): GenericObject[GenericMethod];

package/dist/common/detachObjectMethod.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/detachObjectMethod.ts
+function detachObjectMethod(object, method) {
+	return object[method].bind(object);
+}
+//#endregion
+export { detachObjectMethod };

package/dist/common/enum.cjs

@@ -0,0 +1,11 @@
+//#region scripts/common/enum.ts
+function createEnum(values) {
+	return Object.fromEntries([
+		...values.map((value) => [value, value]),
+		["toTuple", () => values],
+		["has", (value) => values.includes(value)],
+		["contract", () => createEnum(values)]
+	]);
+}
+//#endregion
+exports.createEnum = createEnum;

package/dist/common/enum.d.ts

@@ -0,0 +1,17 @@
+import { AnyTuple, ComputedTypeError, IsEqual, IsNever, SimplifyTopLevel, UnionToTuple } from './types';
+type RequireEnumContractMissingValue<GenericValues extends AnyTuple<string>, GenericContractValue extends string> = Exclude<GenericValues[number], GenericContractValue> extends infer InferredMissingValue extends string ? IsNever<InferredMissingValue> extends true ? unknown : ComputedTypeError<`Enum contract is missing value "${InferredMissingValue}".`> : never;
+type RequireEnumContractUnknownValue<GenericValues extends AnyTuple<string>, GenericContractValue extends string> = Exclude<GenericContractValue, GenericValues[number]> extends infer InferredUnknownValue extends string ? IsNever<InferredUnknownValue> extends true ? unknown : ComputedTypeError<`Enum contract contains unknown value "${InferredUnknownValue}".`> : never;
+type RequireEnumContractUniqueValues<GenericValues extends AnyTuple<string>> = IsEqual<GenericValues["length"], UnionToTuple<GenericValues[number]>["length"]> extends true ? unknown : ComputedTypeError<"Enum values must not contain duplicates.">;
+type RequireEnumContract<GenericValues extends AnyTuple<string>, GenericContractValue extends string> = RequireEnumContractMissingValue<GenericValues, GenericContractValue> & RequireEnumContractUnknownValue<GenericValues, GenericContractValue> & RequireEnumContractUniqueValues<GenericValues>;
+export type Enum<GenericValues extends AnyTuple<string>> = SimplifyTopLevel<{
+    [Prop in GenericValues[number]]: Prop;
+} & {
+    toTuple(): GenericValues;
+    has(value: string): value is GenericValues[number];
+    contract<GenericContractValue extends string = GenericValues[number]>(...args: RequireEnumContract<GenericValues, GenericContractValue> extends infer InferredRequirement ? IsEqual<InferredRequirement, unknown> extends true ? [] : [] & InferredRequirement : never): Enum<GenericValues>;
+}>;
+export declare function createEnum<const GenericValues extends AnyTuple<string>>(values: GenericValues): Enum<GenericValues>;
+export type GetEnumValue<GenericEnum extends {
+    toTuple(): AnyTuple<string>;
+}> = ReturnType<GenericEnum["toTuple"]>[number];
+export {};

package/dist/common/enum.mjs

@@ -0,0 +1,11 @@
+//#region scripts/common/enum.ts
+function createEnum(values) {
+	return Object.fromEntries([
+		...values.map((value) => [value, value]),
+		["toTuple", () => values],
+		["has", (value) => values.includes(value)],
+		["contract", () => createEnum(values)]
+	]);
+}
+//#endregion
+export { createEnum };

package/dist/common/equal.cjs

@@ -0,0 +1,11 @@
+//#region scripts/common/equal.ts
+function equal(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => equal(input, value);
+	}
+	const [input, value] = args;
+	return value instanceof Array ? value.includes(input) : input === value;
+}
+//#endregion
+exports.equal = equal;

package/dist/common/equal.d.ts

@@ -0,0 +1,14 @@
+import { Or, UnionContain } from './types';
+export type EligibleEqual = string | null | number | undefined | bigint | boolean | symbol;
+type ExpectLiteral<GenericValue extends EligibleEqual> = Or<[
+    UnionContain<GenericValue, string>,
+    UnionContain<GenericValue, number>,
+    UnionContain<GenericValue, boolean>,
+    UnionContain<GenericValue, bigint>,
+    UnionContain<GenericValue, symbol>
+]> extends true ? never : GenericValue;
+export declare function equal<GenericInput extends EligibleEqual | object, GenericValue extends Exclude<GenericInput, object>>(value: ExpectLiteral<GenericValue> | ExpectLiteral<GenericValue>[]): (input: GenericInput) => input is NoInfer<GenericValue>;
+export declare function equal<GenericInput extends EligibleEqual | object, GenericValue extends Exclude<GenericInput, object>>(value: GenericValue | GenericValue[]): (input: GenericInput) => boolean;
+export declare function equal<GenericInput extends EligibleEqual | object, GenericValue extends Exclude<GenericInput, object>>(input: GenericInput, value: ExpectLiteral<GenericValue> | ExpectLiteral<GenericValue>[]): input is GenericValue;
+export declare function equal<GenericInput extends EligibleEqual | object, GenericValue extends Exclude<GenericInput, object>>(input: GenericInput, value: GenericValue | GenericValue[]): boolean;
+export {};

package/dist/common/equal.mjs

@@ -0,0 +1,11 @@
+//#region scripts/common/equal.ts
+function equal(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => equal(input, value);
+	}
+	const [input, value] = args;
+	return value instanceof Array ? value.includes(input) : input === value;
+}
+//#endregion
+export { equal };

package/dist/common/escapeRegExp.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/escapeRegExp.ts
+function escapeRegExp(input) {
+	return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+//#endregion
+exports.escapeRegExp = escapeRegExp;

package/dist/common/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp<GenericInput extends string>(input: GenericInput): string;

package/dist/common/escapeRegExp.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/escapeRegExp.ts
+function escapeRegExp(input) {
+	return input.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+//#endregion
+export { escapeRegExp };

package/dist/common/externalPromise.cjs

@@ -0,0 +1,16 @@
+//#region scripts/common/externalPromise.ts
+function createExternalPromise() {
+	let resolve = void 0;
+	let reject = void 0;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		resolve,
+		reject,
+		promise
+	};
+}
+//#endregion
+exports.createExternalPromise = createExternalPromise;

package/dist/common/externalPromise.d.ts

@@ -0,0 +1,6 @@
+export interface ExternalPromise<GenericValue extends unknown> {
+    resolve(value: (Awaited<GenericValue> | GenericValue | Promise<GenericValue>)): void;
+    reject(value: unknown): void;
+    promise: Promise<Awaited<GenericValue>>;
+}
+export declare function createExternalPromise<GenericPromiseValue extends unknown>(): ExternalPromise<GenericPromiseValue>;

package/dist/common/externalPromise.mjs

@@ -0,0 +1,16 @@
+//#region scripts/common/externalPromise.ts
+function createExternalPromise() {
+	let resolve = void 0;
+	let reject = void 0;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		resolve,
+		reject,
+		promise
+	};
+}
+//#endregion
+export { createExternalPromise };

package/dist/common/falsy.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/falsy.ts
+function falsy(input) {
+	return !input;
+}
+//#endregion
+exports.falsy = falsy;

package/dist/common/falsy.d.ts

@@ -0,0 +1,4 @@
+import { FalsyValue, ForcePredicate, UnionContain } from './types';
+type Falsy<GenericInput extends unknown> = Extract<GenericInput, FalsyValue> | (UnionContain<GenericInput, string> extends true ? "" : never) | (UnionContain<GenericInput, number> extends true ? 0 : never) | (UnionContain<GenericInput, bigint> extends true ? 0n : never);
+export declare function falsy<GenericInput extends unknown>(input: GenericInput): input is ForcePredicate<GenericInput, Falsy<GenericInput>>;
+export {};

package/dist/common/falsy.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/falsy.ts
+function falsy(input) {
+	return !input;
+}
+//#endregion
+export { falsy };

package/dist/common/formData.cjs

@@ -0,0 +1,64 @@
+const require_escapeRegExp = require("./escapeRegExp.cjs");
+const require_theDate = require("../chrono/theDate.cjs");
+const require_theTime = require("../chrono/theTime.cjs");
+//#region scripts/common/formData.ts
+const separator = "/*\\";
+const firstElementInPathRegex = new RegExp(`^((?:(?!${require_escapeRegExp.escapeRegExp(separator)}).)*)(?:${require_escapeRegExp.escapeRegExp(separator)})?`);
+const getIndexRegex = /^\[(\d+)\]$/;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
+var TheFormData = class TheFormData extends FormData {
+	inputValues;
+	constructor(inputValues) {
+		super();
+		this.inputValues = inputValues;
+		for (const entry of TheFormData.toFlatEntries(inputValues)) this.append(entry[0], entry[1]);
+	}
+	static *toFlatEntries(input, path) {
+		if (typeof input === "string" || input instanceof require_theTime.TheTime || input instanceof require_theDate.TheDate || typeof input === "number" || typeof input === "boolean") yield [path ?? "", input.toString()];
+		else if (input instanceof File) yield [path ?? "", input];
+		else if (input === null) yield [path ?? "", "null"];
+		else if (input === void 0) return;
+		else if (input instanceof Array) for (let index = 0; index < input.length; index++) {
+			const entriesIterator = this.toFlatEntries(input[index], path === void 0 ? `[${index}]` : `${path}${separator}[${index}]`);
+			for (const entry of entriesIterator) yield entry;
+		}
+		else for (const key in input) {
+			const entriesIterator = this.toFlatEntries(input[key], path === void 0 ? key : `${path}${separator}${key}`);
+			for (const entry of entriesIterator) yield entry;
+		}
+	}
+	static fromEntries(iterable, arrayMaxIndex) {
+		const constructObject = (input, path, value) => {
+			const firstElement = path.match(firstElementInPathRegex)[1];
+			const index = firstElement.match(getIndexRegex)?.[1];
+			if (index && Number(index) > arrayMaxIndex) return input;
+			let output = input;
+			if (output === void 0) if (index !== void 0) output = [];
+			else output = {};
+			if (firstElement === path) {
+				output[index ?? firstElement] = value;
+				return output;
+			}
+			output[index ?? firstElement] = constructObject(output[index ?? firstElement], path.replace(firstElementInPathRegex, ""), value);
+			return output;
+		};
+		let result = void 0;
+		for (const entry of iterable) {
+			if (invalidEntryRegex.test(entry[0])) continue;
+			result = constructObject(result, entry[0], entry[1]);
+		}
+		return result ?? {};
+	}
+	/**
+	* @internal
+	*/
+	static "new"(inputValues) {
+		return new TheFormData(inputValues);
+	}
+};
+function createFormData(inputValues) {
+	return TheFormData.new(inputValues);
+}
+//#endregion
+exports.TheFormData = TheFormData;
+exports.createFormData = createFormData;

package/dist/common/formData.d.ts

@@ -0,0 +1,11 @@
+import * as DChrono from '../chrono';
+export type EligibleFormDataValue = (boolean | number | null | string | File | undefined | DChrono.TheDate | DChrono.TheTime | {
+    [key: string]: EligibleFormDataValue;
+} | EligibleFormDataValue[]);
+export declare class TheFormData<GenericValues extends Record<string, EligibleFormDataValue>> extends FormData {
+    readonly inputValues: GenericValues;
+    private constructor();
+    static toFlatEntries(input: EligibleFormDataValue, path?: string): Iterable<[string, string | File], void>;
+    static fromEntries(iterable: Iterable<[string, unknown]>, arrayMaxIndex: number): object;
+}
+export declare function createFormData<GenericValues extends Record<string, EligibleFormDataValue>>(inputValues: GenericValues): TheFormData<GenericValues>;