@duplojs/lang 0.0.0

package/dist/common/formData.mjs

@@ -0,0 +1,63 @@
+import { escapeRegExp } from "./escapeRegExp.mjs";
+import { TheDate } from "../chrono/theDate.mjs";
+import { TheTime } from "../chrono/theTime.mjs";
+//#region scripts/common/formData.ts
+const separator = "/*\\";
+const firstElementInPathRegex = new RegExp(`^((?:(?!${escapeRegExp(separator)}).)*)(?:${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 TheTime || input instanceof 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
+export { TheFormData, createFormData };

package/dist/common/forward.cjs

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

package/dist/common/forward.d.ts

@@ -0,0 +1 @@
+export declare function forward<GenericValue extends unknown>(value: GenericValue): GenericValue;

package/dist/common/forward.mjs

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

package/dist/common/forwardAsserts.cjs

@@ -0,0 +1,13 @@
+const require_asserts = require("./asserts.cjs");
+//#region scripts/common/forwardAsserts.ts
+function forwardAsserts(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (input) => forwardAsserts(input, predicate);
+	}
+	const [input, predicate] = args;
+	if (!predicate(input)) throw new require_asserts.AssertsError(input);
+	return input;
+}
+//#endregion
+exports.forwardAsserts = forwardAsserts;

package/dist/common/forwardAsserts.d.ts

@@ -0,0 +1,4 @@
+export declare function forwardAsserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(predicate: (input: GenericInput) => input is GenericPredicate): (input: GenericInput) => GenericPredicate;
+export declare function forwardAsserts<GenericInput extends unknown>(predicate: (input: GenericInput) => boolean): (input: GenericInput) => GenericInput;
+export declare function forwardAsserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicate): GenericPredicate;
+export declare function forwardAsserts<GenericInput extends unknown>(input: GenericInput, predicate: (input: GenericInput) => boolean): GenericInput;

package/dist/common/forwardAsserts.mjs

@@ -0,0 +1,13 @@
+import { AssertsError } from "./asserts.mjs";
+//#region scripts/common/forwardAsserts.ts
+function forwardAsserts(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (input) => forwardAsserts(input, predicate);
+	}
+	const [input, predicate] = args;
+	if (!predicate(input)) throw new AssertsError(input);
+	return input;
+}
+//#endregion
+export { forwardAsserts };

package/dist/common/forwardLog.cjs

@@ -0,0 +1,7 @@
+//#region scripts/common/forwardLog.ts
+function forwardLog(input) {
+	console.log(input);
+	return input;
+}
+//#endregion
+exports.forwardLog = forwardLog;

package/dist/common/forwardLog.d.ts

@@ -0,0 +1 @@
+export declare function forwardLog<const GenericInput extends unknown>(input: GenericInput): GenericInput;

package/dist/common/forwardLog.mjs

@@ -0,0 +1,7 @@
+//#region scripts/common/forwardLog.ts
+function forwardLog(input) {
+	console.log(input);
+	return input;
+}
+//#endregion
+export { forwardLog };

package/dist/common/globalStore.cjs

@@ -0,0 +1,15 @@
+//#region scripts/common/globalStore.ts
+const store = {};
+function createGlobalStore(storeName, defaultValue) {
+	if (store[storeName] === void 0) store[storeName] = defaultValue;
+	return {
+		get value() {
+			return store[storeName];
+		},
+		set(value) {
+			store[storeName] = value;
+		}
+	};
+}
+//#endregion
+exports.createGlobalStore = createGlobalStore;

package/dist/common/globalStore.d.ts

@@ -0,0 +1,7 @@
+export interface GlobalStore {
+}
+export interface GlobalStoreHandler<GenericValue extends unknown> {
+    readonly value: GenericValue;
+    set(value: GenericValue): void;
+}
+export declare function createGlobalStore<GenericStoreName extends keyof GlobalStore>(storeName: GenericStoreName, defaultValue: GlobalStore[GenericStoreName]): GlobalStoreHandler<GlobalStore[GenericStoreName]>;

package/dist/common/globalStore.mjs

@@ -0,0 +1,15 @@
+//#region scripts/common/globalStore.ts
+const store = {};
+function createGlobalStore(storeName, defaultValue) {
+	if (store[storeName] === void 0) store[storeName] = defaultValue;
+	return {
+		get value() {
+			return store[storeName];
+		},
+		set(value) {
+			store[storeName] = value;
+		}
+	};
+}
+//#endregion
+export { createGlobalStore };

package/dist/common/index.cjs

@@ -0,0 +1,194 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_and = require("./and.cjs");
+const require_kind = require("./kind.cjs");
+const require_asserts = require("./asserts.cjs");
+const require_asyncInnerPipe = require("./asyncInnerPipe.cjs");
+const require_asyncLoop = require("./asyncLoop.cjs");
+const require_asyncPipe = require("./asyncPipe.cjs");
+const require_timeout = require("./timeout.cjs");
+const require_asyncRetry = require("./asyncRetry.cjs");
+const require_bindPrototypeMethods = require("./bindPrototypeMethods.cjs");
+const require_globalStore = require("./globalStore.cjs");
+const require_builder = require("./builder.cjs");
+const require_callThen = require("./callThen.cjs");
+const require_clone = require("./clone.cjs");
+const require_index = require("./constraint/cast/index.cjs");
+const require_detachObjectMethod = require("./detachObjectMethod.cjs");
+const require_enum = require("./enum.cjs");
+const require_equal = require("./equal.cjs");
+const require_escapeRegExp = require("./escapeRegExp.cjs");
+const require_externalPromise = require("./externalPromise.cjs");
+const require_falsy = require("./falsy.cjs");
+const require_formData = require("./formData.cjs");
+const require_forward = require("./forward.cjs");
+const require_forwardAsserts = require("./forwardAsserts.cjs");
+const require_forwardLog = require("./forwardLog.cjs");
+const require_innerPipe = require("./innerPipe.cjs");
+const require_instanceOf = require("./instanceOf.cjs");
+const require_interpolation = require("./interpolation.cjs");
+const require_isType = require("./isType.cjs");
+const require_justExec = require("./justExec.cjs");
+const require_justReturn = require("./justReturn.cjs");
+const require_loop = require("./loop.cjs");
+const require_memo = require("./memo.cjs");
+const require_memoObject = require("./memoObject.cjs");
+const require_memoPromise = require("./memoPromise.cjs");
+const require_mimeType = require("./mimeType.cjs");
+const require_or = require("./or.cjs");
+const require_pipe = require("./pipe.cjs");
+const require_pipeCall = require("./pipeCall.cjs");
+const require_prepareAsyncPipe = require("./prepareAsyncPipe.cjs");
+const require_preparePipe = require("./preparePipe.cjs");
+const require_promiseAll = require("./promiseAll.cjs");
+const require_promiseObject = require("./promiseObject.cjs");
+const require_queue = require("./queue.cjs");
+const require_simpleClone = require("./simpleClone.cjs");
+const require_stringToBytes = require("./stringToBytes.cjs");
+const require_stringToMillisecond = require("./stringToMillisecond.cjs");
+const require_toCurriedPredicate = require("./toCurriedPredicate.cjs");
+const require_toRegExp = require("./toRegExp.cjs");
+const require_transformer = require("./transformer.cjs");
+const require_truthy = require("./truthy.cjs");
+const require_when = require("./when.cjs");
+const require_whenElse = require("./whenElse.cjs");
+const require_whenNot = require("./whenNot.cjs");
+//#region scripts/common/index.ts
+var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	AssertsError: () => require_asserts.AssertsError,
+	InvalidBytesInStringError: () => require_stringToBytes.InvalidBytesInStringError,
+	InvalidMillisecondInStringError: () => require_stringToMillisecond.InvalidMillisecondInStringError,
+	MissingBuilderMethodsError: () => require_builder.MissingBuilderMethodsError,
+	TheFormData: () => require_formData.TheFormData,
+	and: () => require_and.and,
+	asserts: () => require_asserts.asserts,
+	asyncInnerPipe: () => require_asyncInnerPipe.asyncInnerPipe,
+	asyncLoop: () => require_asyncLoop.asyncLoop,
+	asyncPipe: () => require_asyncPipe.asyncPipe,
+	bindPrototypeMethods: () => require_bindPrototypeMethods.bindPrototypeMethods,
+	builderKind: () => require_builder.builderKind,
+	callThen: () => require_callThen.callThen,
+	cast: () => require_index.cast,
+	clone: () => require_clone.clone,
+	createAsyncRetry: () => require_asyncRetry.createAsyncRetry,
+	createBuilder: () => require_builder.createBuilder,
+	createEnum: () => require_enum.createEnum,
+	createExternalPromise: () => require_externalPromise.createExternalPromise,
+	createFormData: () => require_formData.createFormData,
+	createGlobalStore: () => require_globalStore.createGlobalStore,
+	createInterpolation: () => require_interpolation.createInterpolation,
+	createKind: () => require_kind.createKind,
+	createQueue: () => require_queue.createQueue,
+	createTransformer: () => require_transformer.createTransformer,
+	detachObjectMethod: () => require_detachObjectMethod.detachObjectMethod,
+	equal: () => require_equal.equal,
+	escapeRegExp: () => require_escapeRegExp.escapeRegExp,
+	falsy: () => require_falsy.falsy,
+	forward: () => require_forward.forward,
+	forwardAsserts: () => require_forwardAsserts.forwardAsserts,
+	forwardLog: () => require_forwardLog.forwardLog,
+	innerPipe: () => require_innerPipe.innerPipe,
+	instanceOf: () => require_instanceOf.instanceOf,
+	isType: () => require_isType.isType,
+	justExec: () => require_justExec.justExec,
+	justReturn: () => require_justReturn.justReturn,
+	loop: () => require_loop.loop,
+	memo: () => require_memo.memo,
+	memoObject: () => require_memoObject.memoObject,
+	memoPromise: () => require_memoPromise.memoPromise,
+	mimeType: () => require_mimeType.mimeType,
+	or: () => require_or.or,
+	pipe: () => require_pipe.pipe,
+	pipeCall: () => require_pipeCall.pipeCall,
+	prepareAsyncPipe: () => require_prepareAsyncPipe.prepareAsyncPipe,
+	preparePipe: () => require_preparePipe.preparePipe,
+	promiseAll: () => require_promiseAll.promiseAll,
+	promiseObject: () => require_promiseObject.promiseObject,
+	queueKind: () => require_queue.queueKind,
+	shameOnYou: () => require_index.shameOnYou,
+	simpleClone: () => require_simpleClone.simpleClone,
+	stringToBytes: () => require_stringToBytes.stringToBytes,
+	stringToMillisecond: () => require_stringToMillisecond.stringToMillisecond,
+	timeout: () => require_timeout.timeout,
+	toCurriedPredicate: () => require_toCurriedPredicate.toCurriedPredicate,
+	toJSON: () => require_transformer.toJSON,
+	toNative: () => require_transformer.toNative,
+	toRegExp: () => require_toRegExp.toRegExp,
+	transformer: () => require_transformer.transformer,
+	truthy: () => require_truthy.truthy,
+	useAsyncRetry: () => require_asyncRetry.useAsyncRetry,
+	when: () => require_when.when,
+	whenElse: () => require_whenElse.whenElse,
+	whenNot: () => require_whenNot.whenNot
+});
+//#endregion
+exports.AssertsError = require_asserts.AssertsError;
+exports.InvalidBytesInStringError = require_stringToBytes.InvalidBytesInStringError;
+exports.InvalidMillisecondInStringError = require_stringToMillisecond.InvalidMillisecondInStringError;
+exports.MissingBuilderMethodsError = require_builder.MissingBuilderMethodsError;
+exports.TheFormData = require_formData.TheFormData;
+exports.and = require_and.and;
+exports.asserts = require_asserts.asserts;
+exports.asyncInnerPipe = require_asyncInnerPipe.asyncInnerPipe;
+exports.asyncLoop = require_asyncLoop.asyncLoop;
+exports.asyncPipe = require_asyncPipe.asyncPipe;
+exports.bindPrototypeMethods = require_bindPrototypeMethods.bindPrototypeMethods;
+exports.builderKind = require_builder.builderKind;
+exports.callThen = require_callThen.callThen;
+exports.cast = require_index.cast;
+exports.clone = require_clone.clone;
+Object.defineProperty(exports, "common_exports", {
+	enumerable: true,
+	get: function() {
+		return common_exports;
+	}
+});
+exports.createAsyncRetry = require_asyncRetry.createAsyncRetry;
+exports.createBuilder = require_builder.createBuilder;
+exports.createEnum = require_enum.createEnum;
+exports.createExternalPromise = require_externalPromise.createExternalPromise;
+exports.createFormData = require_formData.createFormData;
+exports.createGlobalStore = require_globalStore.createGlobalStore;
+exports.createInterpolation = require_interpolation.createInterpolation;
+exports.createKind = require_kind.createKind;
+exports.createQueue = require_queue.createQueue;
+exports.createTransformer = require_transformer.createTransformer;
+exports.detachObjectMethod = require_detachObjectMethod.detachObjectMethod;
+exports.equal = require_equal.equal;
+exports.escapeRegExp = require_escapeRegExp.escapeRegExp;
+exports.falsy = require_falsy.falsy;
+exports.forward = require_forward.forward;
+exports.forwardAsserts = require_forwardAsserts.forwardAsserts;
+exports.forwardLog = require_forwardLog.forwardLog;
+exports.innerPipe = require_innerPipe.innerPipe;
+exports.instanceOf = require_instanceOf.instanceOf;
+exports.isType = require_isType.isType;
+exports.justExec = require_justExec.justExec;
+exports.justReturn = require_justReturn.justReturn;
+exports.loop = require_loop.loop;
+exports.memo = require_memo.memo;
+exports.memoObject = require_memoObject.memoObject;
+exports.memoPromise = require_memoPromise.memoPromise;
+exports.mimeType = require_mimeType.mimeType;
+exports.or = require_or.or;
+exports.pipe = require_pipe.pipe;
+exports.pipeCall = require_pipeCall.pipeCall;
+exports.prepareAsyncPipe = require_prepareAsyncPipe.prepareAsyncPipe;
+exports.preparePipe = require_preparePipe.preparePipe;
+exports.promiseAll = require_promiseAll.promiseAll;
+exports.promiseObject = require_promiseObject.promiseObject;
+exports.queueKind = require_queue.queueKind;
+exports.shameOnYou = require_index.shameOnYou;
+exports.simpleClone = require_simpleClone.simpleClone;
+exports.stringToBytes = require_stringToBytes.stringToBytes;
+exports.stringToMillisecond = require_stringToMillisecond.stringToMillisecond;
+exports.timeout = require_timeout.timeout;
+exports.toCurriedPredicate = require_toCurriedPredicate.toCurriedPredicate;
+exports.toJSON = require_transformer.toJSON;
+exports.toNative = require_transformer.toNative;
+exports.toRegExp = require_toRegExp.toRegExp;
+exports.transformer = require_transformer.transformer;
+exports.truthy = require_truthy.truthy;
+exports.useAsyncRetry = require_asyncRetry.useAsyncRetry;
+exports.when = require_when.when;
+exports.whenElse = require_whenElse.whenElse;
+exports.whenNot = require_whenNot.whenNot;

package/dist/common/index.d.ts

@@ -0,0 +1,54 @@
+export * from './and';
+export * from './asserts';
+export * from './asyncInnerPipe';
+export * from './asyncLoop';
+export * from './asyncPipe';
+export * from './asyncRetry';
+export * from './bindPrototypeMethods';
+export * from './builder';
+export * from './callThen';
+export * from './clone';
+export * from './constraint';
+export * from './detachObjectMethod';
+export * from './enum';
+export * from './equal';
+export * from './escapeRegExp';
+export * from './externalPromise';
+export * from './falsy';
+export * from './formData';
+export * from './forward';
+export * from './forwardAsserts';
+export * from './forwardLog';
+export * from './globalStore';
+export * from './innerPipe';
+export * from './instanceOf';
+export * from './interpolation';
+export * from './isType';
+export * from './justExec';
+export * from './justReturn';
+export * from './kind';
+export * from './loop';
+export * from './memo';
+export * from './memoObject';
+export * from './memoPromise';
+export * from './mimeType';
+export * from './or';
+export * from './pipe';
+export * from './pipeCall';
+export * from './prepareAsyncPipe';
+export * from './preparePipe';
+export * from './promiseAll';
+export * from './promiseObject';
+export * from './queue';
+export * from './simpleClone';
+export * from './stringToBytes';
+export * from './stringToMillisecond';
+export * from './timeout';
+export * from './toCurriedPredicate';
+export * from './toRegExp';
+export * from './transformer';
+export * from './truthy';
+export type * from './types';
+export * from './when';
+export * from './whenElse';
+export * from './whenNot';

package/dist/common/index.mjs

@@ -0,0 +1,124 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { and } from "./and.mjs";
+import { createKind } from "./kind.mjs";
+import { AssertsError, asserts } from "./asserts.mjs";
+import { asyncInnerPipe } from "./asyncInnerPipe.mjs";
+import { asyncLoop } from "./asyncLoop.mjs";
+import { asyncPipe } from "./asyncPipe.mjs";
+import { timeout } from "./timeout.mjs";
+import { createAsyncRetry, useAsyncRetry } from "./asyncRetry.mjs";
+import { bindPrototypeMethods } from "./bindPrototypeMethods.mjs";
+import { createGlobalStore } from "./globalStore.mjs";
+import { MissingBuilderMethodsError, builderKind, createBuilder } from "./builder.mjs";
+import { callThen } from "./callThen.mjs";
+import { clone } from "./clone.mjs";
+import { cast, shameOnYou } from "./constraint/cast/index.mjs";
+import { detachObjectMethod } from "./detachObjectMethod.mjs";
+import { createEnum } from "./enum.mjs";
+import { equal } from "./equal.mjs";
+import { escapeRegExp } from "./escapeRegExp.mjs";
+import { createExternalPromise } from "./externalPromise.mjs";
+import { falsy } from "./falsy.mjs";
+import { TheFormData, createFormData } from "./formData.mjs";
+import { forward } from "./forward.mjs";
+import { forwardAsserts } from "./forwardAsserts.mjs";
+import { forwardLog } from "./forwardLog.mjs";
+import { innerPipe } from "./innerPipe.mjs";
+import { instanceOf } from "./instanceOf.mjs";
+import { createInterpolation } from "./interpolation.mjs";
+import { isType } from "./isType.mjs";
+import { justExec } from "./justExec.mjs";
+import { justReturn } from "./justReturn.mjs";
+import { loop } from "./loop.mjs";
+import { memo } from "./memo.mjs";
+import { memoObject } from "./memoObject.mjs";
+import { memoPromise } from "./memoPromise.mjs";
+import { mimeType } from "./mimeType.mjs";
+import { or } from "./or.mjs";
+import { pipe } from "./pipe.mjs";
+import { pipeCall } from "./pipeCall.mjs";
+import { prepareAsyncPipe } from "./prepareAsyncPipe.mjs";
+import { preparePipe } from "./preparePipe.mjs";
+import { promiseAll } from "./promiseAll.mjs";
+import { promiseObject } from "./promiseObject.mjs";
+import { createQueue, queueKind } from "./queue.mjs";
+import { simpleClone } from "./simpleClone.mjs";
+import { InvalidBytesInStringError, stringToBytes } from "./stringToBytes.mjs";
+import { InvalidMillisecondInStringError, stringToMillisecond } from "./stringToMillisecond.mjs";
+import { toCurriedPredicate } from "./toCurriedPredicate.mjs";
+import { toRegExp } from "./toRegExp.mjs";
+import { createTransformer, toJSON, toNative, transformer } from "./transformer.mjs";
+import { truthy } from "./truthy.mjs";
+import { when } from "./when.mjs";
+import { whenElse } from "./whenElse.mjs";
+import { whenNot } from "./whenNot.mjs";
+//#region scripts/common/index.ts
+var common_exports = /* @__PURE__ */ __exportAll({
+	AssertsError: () => AssertsError,
+	InvalidBytesInStringError: () => InvalidBytesInStringError,
+	InvalidMillisecondInStringError: () => InvalidMillisecondInStringError,
+	MissingBuilderMethodsError: () => MissingBuilderMethodsError,
+	TheFormData: () => TheFormData,
+	and: () => and,
+	asserts: () => asserts,
+	asyncInnerPipe: () => asyncInnerPipe,
+	asyncLoop: () => asyncLoop,
+	asyncPipe: () => asyncPipe,
+	bindPrototypeMethods: () => bindPrototypeMethods,
+	builderKind: () => builderKind,
+	callThen: () => callThen,
+	cast: () => cast,
+	clone: () => clone,
+	createAsyncRetry: () => createAsyncRetry,
+	createBuilder: () => createBuilder,
+	createEnum: () => createEnum,
+	createExternalPromise: () => createExternalPromise,
+	createFormData: () => createFormData,
+	createGlobalStore: () => createGlobalStore,
+	createInterpolation: () => createInterpolation,
+	createKind: () => createKind,
+	createQueue: () => createQueue,
+	createTransformer: () => createTransformer,
+	detachObjectMethod: () => detachObjectMethod,
+	equal: () => equal,
+	escapeRegExp: () => escapeRegExp,
+	falsy: () => falsy,
+	forward: () => forward,
+	forwardAsserts: () => forwardAsserts,
+	forwardLog: () => forwardLog,
+	innerPipe: () => innerPipe,
+	instanceOf: () => instanceOf,
+	isType: () => isType,
+	justExec: () => justExec,
+	justReturn: () => justReturn,
+	loop: () => loop,
+	memo: () => memo,
+	memoObject: () => memoObject,
+	memoPromise: () => memoPromise,
+	mimeType: () => mimeType,
+	or: () => or,
+	pipe: () => pipe,
+	pipeCall: () => pipeCall,
+	prepareAsyncPipe: () => prepareAsyncPipe,
+	preparePipe: () => preparePipe,
+	promiseAll: () => promiseAll,
+	promiseObject: () => promiseObject,
+	queueKind: () => queueKind,
+	shameOnYou: () => shameOnYou,
+	simpleClone: () => simpleClone,
+	stringToBytes: () => stringToBytes,
+	stringToMillisecond: () => stringToMillisecond,
+	timeout: () => timeout,
+	toCurriedPredicate: () => toCurriedPredicate,
+	toJSON: () => toJSON,
+	toNative: () => toNative,
+	toRegExp: () => toRegExp,
+	transformer: () => transformer,
+	truthy: () => truthy,
+	useAsyncRetry: () => useAsyncRetry,
+	when: () => when,
+	whenElse: () => whenElse,
+	whenNot: () => whenNot
+});
+//#endregion
+export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/common/innerPipe.cjs

@@ -0,0 +1,10 @@
+//#region scripts/common/innerPipe.ts
+function innerPipe(...pipes) {
+	return (input) => {
+		let acc = input;
+		for (const pipe of pipes) acc = pipe(acc);
+		return acc;
+	};
+}
+//#endregion
+exports.innerPipe = innerPipe;

package/dist/common/innerPipe.d.ts

@@ -0,0 +1,16 @@
+import { BreakGenericLink } from './types';
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1): (input: GenericInput) => BreakGenericLink<GenericOutputPipe1>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2): (input: GenericInput) => BreakGenericLink<GenericOutputPipe2>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3): (input: GenericInput) => BreakGenericLink<GenericOutputPipe3>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4): (input: GenericInput) => BreakGenericLink<GenericOutputPipe4>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5): (input: GenericInput) => BreakGenericLink<GenericOutputPipe5>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6): (input: GenericInput) => BreakGenericLink<GenericOutputPipe6>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7): (input: GenericInput) => BreakGenericLink<GenericOutputPipe7>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8): (input: GenericInput) => BreakGenericLink<GenericOutputPipe8>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9): (input: GenericInput) => BreakGenericLink<GenericOutputPipe9>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown, const GenericOutputPipe10 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9, pipe10: (input: GenericOutputPipe9) => GenericOutputPipe10): (input: GenericInput) => BreakGenericLink<GenericOutputPipe10>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown, const GenericOutputPipe10 extends unknown, const GenericOutputPipe11 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9, pipe10: (input: GenericOutputPipe9) => GenericOutputPipe10, pipe11: (input: GenericOutputPipe10) => GenericOutputPipe11): (input: GenericInput) => BreakGenericLink<GenericOutputPipe11>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown, const GenericOutputPipe10 extends unknown, const GenericOutputPipe11 extends unknown, const GenericOutputPipe12 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9, pipe10: (input: GenericOutputPipe9) => GenericOutputPipe10, pipe11: (input: GenericOutputPipe10) => GenericOutputPipe11, pipe12: (input: GenericOutputPipe11) => GenericOutputPipe12): (input: GenericInput) => BreakGenericLink<GenericOutputPipe12>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown, const GenericOutputPipe10 extends unknown, const GenericOutputPipe11 extends unknown, const GenericOutputPipe12 extends unknown, const GenericOutputPipe13 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9, pipe10: (input: GenericOutputPipe9) => GenericOutputPipe10, pipe11: (input: GenericOutputPipe10) => GenericOutputPipe11, pipe12: (input: GenericOutputPipe11) => GenericOutputPipe12, pipe13: (input: GenericOutputPipe12) => GenericOutputPipe13): (input: GenericInput) => BreakGenericLink<GenericOutputPipe13>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown, const GenericOutputPipe10 extends unknown, const GenericOutputPipe11 extends unknown, const GenericOutputPipe12 extends unknown, const GenericOutputPipe13 extends unknown, const GenericOutputPipe14 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9, pipe10: (input: GenericOutputPipe9) => GenericOutputPipe10, pipe11: (input: GenericOutputPipe10) => GenericOutputPipe11, pipe12: (input: GenericOutputPipe11) => GenericOutputPipe12, pipe13: (input: GenericOutputPipe12) => GenericOutputPipe13, pipe14: (input: GenericOutputPipe13) => GenericOutputPipe14): (input: GenericInput) => BreakGenericLink<GenericOutputPipe14>;
+export declare function innerPipe<const GenericInput extends unknown, const GenericOutputPipe1 extends unknown, const GenericOutputPipe2 extends unknown, const GenericOutputPipe3 extends unknown, const GenericOutputPipe4 extends unknown, const GenericOutputPipe5 extends unknown, const GenericOutputPipe6 extends unknown, const GenericOutputPipe7 extends unknown, const GenericOutputPipe8 extends unknown, const GenericOutputPipe9 extends unknown, const GenericOutputPipe10 extends unknown, const GenericOutputPipe11 extends unknown, const GenericOutputPipe12 extends unknown, const GenericOutputPipe13 extends unknown, const GenericOutputPipe14 extends unknown, const GenericOutputPipe15 extends unknown>(pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3, pipe4: (input: GenericOutputPipe3) => GenericOutputPipe4, pipe5: (input: GenericOutputPipe4) => GenericOutputPipe5, pipe6: (input: GenericOutputPipe5) => GenericOutputPipe6, pipe7: (input: GenericOutputPipe6) => GenericOutputPipe7, pipe8: (input: GenericOutputPipe7) => GenericOutputPipe8, pipe9: (input: GenericOutputPipe8) => GenericOutputPipe9, pipe10: (input: GenericOutputPipe9) => GenericOutputPipe10, pipe11: (input: GenericOutputPipe10) => GenericOutputPipe11, pipe12: (input: GenericOutputPipe11) => GenericOutputPipe12, pipe13: (input: GenericOutputPipe12) => GenericOutputPipe13, pipe14: (input: GenericOutputPipe13) => GenericOutputPipe14, pipe15: (input: GenericOutputPipe14) => GenericOutputPipe15): (input: GenericInput) => BreakGenericLink<GenericOutputPipe15>;

package/dist/common/innerPipe.mjs

@@ -0,0 +1,10 @@
+//#region scripts/common/innerPipe.ts
+function innerPipe(...pipes) {
+	return (input) => {
+		let acc = input;
+		for (const pipe of pipes) acc = pipe(acc);
+		return acc;
+	};
+}
+//#endregion
+export { innerPipe };

package/dist/common/instanceOf.cjs

@@ -0,0 +1,14 @@
+const require_coalescing = require("../array/coalescing.cjs");
+//#region scripts/common/instanceOf.ts
+function instanceOf(...args) {
+	if (args.length === 1) {
+		const [valueConstructor] = args;
+		return (input) => instanceOf(input, valueConstructor);
+	}
+	const [input, valueConstructor] = args;
+	const valueConstructors = require_coalescing.coalescing(valueConstructor);
+	for (const currentConstructor of valueConstructors) if (input instanceof currentConstructor) return true;
+	return false;
+}
+//#endregion
+exports.instanceOf = instanceOf;

package/dist/common/instanceOf.d.ts

@@ -0,0 +1,3 @@
+import { AnyConstructor } from './types';
+export declare function instanceOf<GenericInput extends unknown, GenericConstructor extends AnyConstructor>(valueConstructor: GenericConstructor | GenericConstructor[]): (input: GenericInput) => input is Extract<GenericInput, InstanceType<GenericConstructor>>;
+export declare function instanceOf<GenericInput extends unknown, GenericConstructor extends AnyConstructor>(input: GenericInput, valueConstructor: GenericConstructor | GenericConstructor[]): input is Extract<GenericInput, InstanceType<GenericConstructor>>;