@duplojs/utils 0.3.1 → 1.0.0

package/dist/array/splice/delete.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function spliceDelete(...args) {
+    if (args.length === 2) {
+        const [indexTo, deleteCount] = args;
+        return (array) => spliceDelete(array, indexTo, deleteCount);
+    }
+    const [array, indexTo, deleteCount] = args;
+    const copy = [...array];
+    copy.splice(indexTo, deleteCount);
+    return copy;
+}
+
+exports.spliceDelete = spliceDelete;

package/dist/array/splice/delete.d.ts

@@ -0,0 +1,2 @@
+export declare function spliceDelete<GenericElement extends unknown>(indexTo: number, deleteCount: number): (array: readonly GenericElement[]) => GenericElement[];
+export declare function spliceDelete<GenericElement extends unknown>(array: readonly GenericElement[], indexTo: number, deleteCount: number): GenericElement[];

package/dist/array/splice/delete.mjs

@@ -0,0 +1,12 @@
+function spliceDelete(...args) {
+    if (args.length === 2) {
+        const [indexTo, deleteCount] = args;
+        return (array) => spliceDelete(array, indexTo, deleteCount);
+    }
+    const [array, indexTo, deleteCount] = args;
+    const copy = [...array];
+    copy.splice(indexTo, deleteCount);
+    return copy;
+}
+
+export { spliceDelete };

package/dist/array/splice/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./delete";
+export * from "./insert";
+export * from "./replace";

package/dist/array/splice/insert.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function spliceInsert(...args) {
+    if (args.length === 2) {
+        const [indexFrom, elements] = args;
+        return (array) => spliceInsert(array, indexFrom, elements);
+    }
+    const [array, indexFrom, elements] = args;
+    const copy = [...array];
+    copy.splice(indexFrom, 0, ...elements);
+    return copy;
+}
+
+exports.spliceInsert = spliceInsert;

package/dist/array/splice/insert.d.ts

@@ -0,0 +1,2 @@
+export declare function spliceInsert<GenericElement extends unknown>(indexFrom: number, elements: GenericElement[]): (array: readonly GenericElement[]) => GenericElement[];
+export declare function spliceInsert<GenericElement extends unknown>(array: readonly GenericElement[], indexFrom: number, elements: GenericElement[]): GenericElement[];

package/dist/array/splice/insert.mjs

@@ -0,0 +1,12 @@
+function spliceInsert(...args) {
+    if (args.length === 2) {
+        const [indexFrom, elements] = args;
+        return (array) => spliceInsert(array, indexFrom, elements);
+    }
+    const [array, indexFrom, elements] = args;
+    const copy = [...array];
+    copy.splice(indexFrom, 0, ...elements);
+    return copy;
+}
+
+export { spliceInsert };

package/dist/array/splice/replace.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function spliceReplace(...args) {
+    if (args.length === 2) {
+        const [indexFrom, elements] = args;
+        return (array) => spliceReplace(array, indexFrom, elements);
+    }
+    const [array, indexFrom, elements] = args;
+    const copy = [...array];
+    copy.splice(indexFrom, elements.length, ...elements);
+    return copy;
+}
+
+exports.spliceReplace = spliceReplace;

package/dist/array/splice/replace.d.ts

@@ -0,0 +1,2 @@
+export declare function spliceReplace<GenericElement extends unknown>(indexFrom: number, elements: GenericElement[]): (array: readonly GenericElement[]) => GenericElement[];
+export declare function spliceReplace<GenericElement extends unknown>(array: readonly GenericElement[], indexFrom: number, elements: GenericElement[]): GenericElement[];

package/dist/array/splice/replace.mjs

@@ -0,0 +1,12 @@
+function spliceReplace(...args) {
+    if (args.length === 2) {
+        const [indexFrom, elements] = args;
+        return (array) => spliceReplace(array, indexFrom, elements);
+    }
+    const [array, indexFrom, elements] = args;
+    const copy = [...array];
+    copy.splice(indexFrom, elements.length, ...elements);
+    return copy;
+}
+
+export { spliceReplace };

package/dist/array/sum.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+function sum(array) {
+    let result = 0;
+    for (const number of array) {
+        result += number;
+    }
+    return result;
+}
+
+exports.sum = sum;

package/dist/array/sum.d.ts

@@ -0,0 +1 @@
+export declare function sum<GenericArray extends readonly number[]>(array: GenericArray): number;

package/dist/array/sum.mjs

@@ -0,0 +1,9 @@
+function sum(array) {
+    let result = 0;
+    for (const number of array) {
+        result += number;
+    }
+    return result;
+}
+
+export { sum };

package/dist/array/types/atTuple.d.ts

@@ -0,0 +1 @@
+export type AtTuple<GenericTuple extends readonly unknown[], GenericIndex extends number> = GenericIndex extends keyof GenericTuple ? GenericTuple[GenericIndex] : undefined;

package/dist/array/types/excludeTuple.d.ts

@@ -0,0 +1,29 @@
+import { type LastUnionElement, type AnyTuple, type IsEqual, type IsUnion, type Or } from "../../common";
+export type ExcludeTuple<GenericValue extends unknown, GenericArray extends readonly any[]> = Or<[
+    IsEqual<GenericValue, never>,
+    IsEqual<GenericArray, never>
+]> extends true ? GenericValue : IsUnion<GenericArray> extends true ? LastUnionElement<GenericArray> extends infer InferredArray extends readonly any[] ? ExcludeTuple<GenericValue, InferredArray> extends infer InferredResult ? IsEqual<InferredResult, never> extends true ? never : ExcludeTuple<InferredResult, Exclude<GenericArray, InferredArray>> : never : never : GenericValue extends readonly any[] ? (([
+    Extract<GenericValue, readonly any[]>,
+    Exclude<Extract<GenericArray, readonly any[]>, AnyTuple>
+] extends [
+    infer InferredValue extends readonly any[],
+    infer InferredArray extends readonly any[]
+] ? Or<[
+    IsEqual<InferredValue, never>,
+    IsEqual<InferredArray, never>
+]> extends true ? never : InferredValue[number] extends InferredArray[number] ? never : InferredValue : never) | ([
+    Extract<GenericValue, AnyTuple>,
+    Extract<GenericArray, AnyTuple>
+] extends [
+    infer InferredValue extends readonly any[],
+    infer InferredArray extends readonly any[]
+] ? Or<[
+    IsEqual<InferredValue, never>,
+    IsEqual<InferredArray, never>
+]> extends true ? never : [
+    InferredValue,
+    InferredArray
+] extends [
+    readonly [infer InferredValueFirst, ...infer InferredValueRest],
+    readonly [infer InferredArrayFirst, ...infer InferredArrayRest]
+] ? InferredValueFirst extends InferredArrayFirst ? InferredArrayRest extends readonly [] ? never : InferredValueRest extends readonly [] ? InferredValue : ExcludeTuple<InferredValueRest, InferredArrayRest> extends infer InferredRestResult ? IsEqual<InferredRestResult, never> extends true ? never : InferredValue : never : InferredValue : never : never)) : GenericValue;

package/dist/array/types/extractTuple.d.ts

@@ -0,0 +1,38 @@
+import { type IsUnion, type Or, type AnyTuple, type IsEqual } from "../../common";
+export type ExtractTuple<GenericValue extends unknown, GenericArray extends readonly any[]> = GenericValue extends readonly any[] ? Or<[
+    IsEqual<GenericValue, never>,
+    IsEqual<GenericArray, never>
+]> extends true ? never : IsUnion<GenericArray> extends true ? GenericArray extends any ? ExtractTuple<GenericValue, GenericArray> : never : (([
+    Extract<GenericValue, readonly any[]>,
+    Exclude<Extract<GenericArray, readonly any[]>, AnyTuple>
+] extends [
+    infer InferredValue extends readonly any[],
+    infer InferredArray extends readonly any[]
+] ? Or<[
+    IsEqual<InferredValue, never>,
+    IsEqual<InferredArray, never>
+]> extends true ? never : InferredValue[number] extends InferredArray[number] ? InferredValue : never : never) | ([
+    Extract<GenericValue, AnyTuple>,
+    Extract<GenericArray, AnyTuple>
+] extends [
+    infer InferredValue extends readonly any[],
+    infer InferredArray extends readonly any[]
+] ? Or<[
+    IsEqual<InferredValue, never>,
+    IsEqual<InferredArray, never>
+]> extends true ? never : [
+    InferredValue,
+    InferredArray
+] extends [
+    readonly [infer InferredValueFirst, ...infer InferredValueRest],
+    readonly [infer InferredArrayFirst, ...infer InferredArrayRest]
+] ? InferredValueFirst extends InferredArrayFirst ? InferredArrayRest extends readonly [] ? InferredValue : ExtractTuple<InferredValueRest, InferredArrayRest> extends infer InferredRestResult ? IsEqual<InferredRestResult, never> extends true ? never : InferredValue : never : never : never : never) | ([
+    Extract<GenericValue, readonly any[]>,
+    Extract<GenericArray, readonly []>
+] extends [
+    infer InferredValue extends readonly any[],
+    infer InferredArray extends readonly any[]
+] ? Or<[
+    IsEqual<InferredValue, never>,
+    IsEqual<InferredArray, never>
+]> extends true ? never : InferredValue : never)) : never;

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

@@ -0,0 +1,7 @@
+export * from "./atTuple";
+export * from "./popTuple";
+export * from "./reverseTuple";
+export * from "./shiftTuple";
+export * from "./tupleHasSpread";
+export * from "./mergeUnionTuple";
+export * from "./extractTuple";

package/dist/array/types/mergeUnionTuple.d.ts

@@ -0,0 +1,7 @@
+import { type IsUnion, type AnyTuple, type IsEqual } from "../../common";
+type CreateTupleFromArray<GenericInput extends readonly any[]> = GenericInput extends AnyTuple ? GenericInput : [GenericInput[number], ...GenericInput];
+export type MergeUnionTuple<GenericTuple extends AnyTuple> = IsUnion<GenericTuple> extends true ? [
+    GenericTuple[0],
+    ...(Extract<GenericTuple, any> extends [any, ...infer InferredRest] ? IsEqual<Extract<InferredRest, AnyTuple | []>, never> extends true ? InferredRest[number][] : (Exclude<InferredRest, readonly []> extends infer InferredValue extends readonly any[] ? IsEqual<InferredValue, never> extends true ? [] : Extract<MergeUnionTuple<CreateTupleFromArray<InferredValue>>, any> : never) : [])
+] : GenericTuple;
+export {};

package/dist/array/types/popTuple.d.ts

@@ -0,0 +1,2 @@
+import { type AnyTuple } from "../../common/types/anyTuple";
+export type PopTuple<GenericArray extends AnyTuple> = GenericArray extends readonly [...infer InferredRest, any] ? InferredRest : never;

package/dist/array/types/reverseTuple.d.ts

@@ -0,0 +1,2 @@
+import { type AnyTuple } from "../../common/types/anyTuple";
+export type ReverseTuple<GenericTuple extends AnyTuple> = GenericTuple extends readonly [infer InferredValue, ...infer InferredRest extends AnyTuple] ? [...ReverseTuple<InferredRest>, InferredValue] : GenericTuple;

package/dist/array/types/shiftTuple.d.ts

@@ -0,0 +1,2 @@
+import { type AnyTuple } from "../../common/types/anyTuple";
+export type ShiftTuple<GenericArray extends AnyTuple> = GenericArray extends readonly [any, ...infer InferredRest] ? InferredRest : never;

package/dist/array/types/tupleHasSpread.d.ts

@@ -0,0 +1,2 @@
+import { type AnyTuple, type IsEqual } from "../../common";
+export type TupleHasSpread<GenericTuple extends AnyTuple> = IsEqual<GenericTuple["length"], number>;

package/dist/array/unshift.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function unshift(...args) {
+    if (args.length === 1) {
+        const [element] = args;
+        return (array) => unshift(array, element);
+    }
+    const [array, ...elements] = args;
+    return [...elements, ...array];
+}
+
+exports.unshift = unshift;

package/dist/array/unshift.d.ts

@@ -0,0 +1,2 @@
+export declare function unshift<GenericElement extends unknown>(element: NoInfer<GenericElement>): (array: readonly GenericElement[]) => GenericElement[];
+export declare function unshift<GenericElement extends unknown>(array: readonly GenericElement[], element: NoInfer<GenericElement>, ...elements: NoInfer<GenericElement>[]): GenericElement[];

package/dist/array/unshift.mjs

@@ -0,0 +1,10 @@
+function unshift(...args) {
+    if (args.length === 1) {
+        const [element] = args;
+        return (array) => unshift(array, element);
+    }
+    const [array, ...elements] = args;
+    return [...elements, ...array];
+}
+
+export { unshift };

package/dist/common/addWrappedProperties.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function addWrappedProperties(wrappedValue, getProperties) {
+    const properties = getProperties({
+        wrappedValue,
+    });
+    return {
+        ...wrappedValue,
+        ...properties,
+    };
+}
+
+exports.addWrappedProperties = addWrappedProperties;

package/dist/common/addWrappedProperties.d.ts

@@ -0,0 +1,4 @@
+export type GetWrappedProperties<GenericWrappedValue extends object = object, GenericProperties extends object = object> = (params: {
+    wrappedValue: GenericWrappedValue;
+}) => GenericProperties;
+export declare function addWrappedProperties<GenericWrappedValue extends object, GenericGetWrappedProperties extends GetWrappedProperties<GenericWrappedValue>>(wrappedValue: GenericWrappedValue, getProperties: GenericGetWrappedProperties): GenericWrappedValue & ReturnType<GenericGetWrappedProperties>;

package/dist/common/addWrappedProperties.mjs

@@ -0,0 +1,11 @@
+function addWrappedProperties(wrappedValue, getProperties) {
+    const properties = getProperties({
+        wrappedValue,
+    });
+    return {
+        ...wrappedValue,
+        ...properties,
+    };
+}
+
+export { addWrappedProperties };

package/dist/common/asyncInnerPipe.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+/* eslint-disable @typescript-eslint/max-params */
+function asyncInnerPipe(...pipes) {
+    return async (input) => {
+        let acc = input;
+        for (const pipe of pipes) {
+            acc = await pipe(acc);
+        }
+        return acc;
+    };
+}
+
+exports.asyncInnerPipe = asyncInnerPipe;

package/dist/common/asyncInnerPipe.d.ts

@@ -0,0 +1,15 @@
+import { type MaybeFutureEither } from "../either/future/MaybeFutureEither";
+import { type MaybePromise, type EscapeVoid, type BreakGenericLink } from "./types";
+import { type AnyValue } from "./types/anyValue";
+type MaybePromiseLike<GenericValue extends unknown> = MaybePromise<GenericValue> | MaybeFutureEither<GenericValue>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe1>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe2>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe3>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe4>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => MaybePromiseLike<GenericOutputPipe5>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe5>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => MaybePromiseLike<GenericOutputPipe5>, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => MaybePromiseLike<GenericOutputPipe6>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe6>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => MaybePromiseLike<GenericOutputPipe5>, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => MaybePromiseLike<GenericOutputPipe6>, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => MaybePromiseLike<GenericOutputPipe7>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe7>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => MaybePromiseLike<GenericOutputPipe5>, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => MaybePromiseLike<GenericOutputPipe6>, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => MaybePromiseLike<GenericOutputPipe7>, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => MaybePromiseLike<GenericOutputPipe8>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe8>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid, GenericOutputPipe9 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => MaybePromiseLike<GenericOutputPipe5>, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => MaybePromiseLike<GenericOutputPipe6>, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => MaybePromiseLike<GenericOutputPipe7>, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => MaybePromiseLike<GenericOutputPipe8>, pipe9: (input: BreakGenericLink<GenericOutputPipe8>) => MaybePromiseLike<GenericOutputPipe9>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe9>>;
+export declare function asyncInnerPipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid, GenericOutputPipe4 extends AnyValue | EscapeVoid, GenericOutputPipe5 extends AnyValue | EscapeVoid, GenericOutputPipe6 extends AnyValue | EscapeVoid, GenericOutputPipe7 extends AnyValue | EscapeVoid, GenericOutputPipe8 extends AnyValue | EscapeVoid, GenericOutputPipe9 extends AnyValue | EscapeVoid, GenericOutputPipe10 extends AnyValue | EscapeVoid>(pipe1: (input: BreakGenericLink<GenericInput>) => MaybePromiseLike<GenericOutputPipe1>, pipe2: (input: BreakGenericLink<GenericOutputPipe1>) => MaybePromiseLike<GenericOutputPipe2>, pipe3: (input: BreakGenericLink<GenericOutputPipe2>) => MaybePromiseLike<GenericOutputPipe3>, pipe4: (input: BreakGenericLink<GenericOutputPipe3>) => MaybePromiseLike<GenericOutputPipe4>, pipe5: (input: BreakGenericLink<GenericOutputPipe4>) => MaybePromiseLike<GenericOutputPipe5>, pipe6: (input: BreakGenericLink<GenericOutputPipe5>) => MaybePromiseLike<GenericOutputPipe6>, pipe7: (input: BreakGenericLink<GenericOutputPipe6>) => MaybePromiseLike<GenericOutputPipe7>, pipe8: (input: BreakGenericLink<GenericOutputPipe7>) => MaybePromiseLike<GenericOutputPipe8>, pipe9: (input: BreakGenericLink<GenericOutputPipe8>) => MaybePromiseLike<GenericOutputPipe9>, pipe10: (input: BreakGenericLink<GenericOutputPipe9>) => MaybePromiseLike<GenericOutputPipe10>): (input: MaybePromiseLike<GenericInput>) => Promise<Awaited<GenericOutputPipe10>>;
+export {};

package/dist/common/asyncInnerPipe.mjs

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/max-params */
+function asyncInnerPipe(...pipes) {
+    return async (input) => {
+        let acc = input;
+        for (const pipe of pipes) {
+            acc = await pipe(acc);
+        }
+        return acc;
+    };
+}
+
+export { asyncInnerPipe };

package/dist/common/asyncLoop.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+async function asyncLoop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = await loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            return result["-exitData"];
+        }
+        previousOutput = result["-nextData"];
+    }
+}
+
+exports.asyncLoop = asyncLoop;

package/dist/common/asyncLoop.d.ts

@@ -0,0 +1,10 @@
+import { type LoopParams } from "./loop";
+import { type AnyValue } from "./types/anyValue";
+interface LoopOutputExistResult<GenericOutput extends any> {
+    "-exitData": GenericOutput;
+}
+interface LoopOutputNextResult<GenericOutput extends any> {
+    "-nextData": GenericOutput;
+}
+export declare function asyncLoop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: LoopParams<GenericRawNextOutput>) => Promise<LoopOutputNextResult<GenericRawNextOutput | undefined> | LoopOutputExistResult<GenericRawExitOutput>>): Promise<GenericRawExitOutput>;
+export {};

package/dist/common/asyncLoop.mjs

@@ -0,0 +1,17 @@
+async function asyncLoop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = await loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            return result["-exitData"];
+        }
+        previousOutput = result["-nextData"];
+    }
+}
+
+export { asyncLoop };

package/dist/common/asyncPipe.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+async function asyncPipe(input, ...pipes) {
+    let acc = await input;
+    for (const pipe of pipes) {
+        acc = await pipe(acc);
+    }
+    return acc;
+}
+
+exports.asyncPipe = asyncPipe;

package/dist/common/asyncPipe.d.ts

@@ -0,0 +1,16 @@
+import { type MaybeFutureEither } from "../either/future/MaybeFutureEither";
+import { type BreakGenericLink, type EscapeVoid } from "./types";
+import { type AnyValue } from "./types/anyValue";
+import { type MaybePromise } from "./types/maybePromise";
+type MaybePromiseLike<GenericValue extends unknown> = MaybePromise<GenericValue> | MaybeFutureEither<GenericValue>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1): Promise<Awaited<GenericOutputPipe1>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2): Promise<Awaited<GenericOutputPipe2>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3): Promise<Awaited<GenericOutputPipe3>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4): Promise<Awaited<GenericOutputPipe4>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe5 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4, pipe5: (input: Awaited<BreakGenericLink<GenericOutputPipe4>>) => GenericOutputPipe5): Promise<Awaited<GenericOutputPipe5>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe5 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe6 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4, pipe5: (input: Awaited<BreakGenericLink<GenericOutputPipe4>>) => GenericOutputPipe5, pipe6: (input: Awaited<BreakGenericLink<GenericOutputPipe5>>) => GenericOutputPipe6): Promise<Awaited<GenericOutputPipe6>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe5 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe6 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe7 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4, pipe5: (input: Awaited<BreakGenericLink<GenericOutputPipe4>>) => GenericOutputPipe5, pipe6: (input: Awaited<BreakGenericLink<GenericOutputPipe5>>) => GenericOutputPipe6, pipe7: (input: Awaited<BreakGenericLink<GenericOutputPipe6>>) => GenericOutputPipe7): Promise<Awaited<GenericOutputPipe7>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe5 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe6 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe7 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe8 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4, pipe5: (input: Awaited<BreakGenericLink<GenericOutputPipe4>>) => GenericOutputPipe5, pipe6: (input: Awaited<BreakGenericLink<GenericOutputPipe5>>) => GenericOutputPipe6, pipe7: (input: Awaited<BreakGenericLink<GenericOutputPipe6>>) => GenericOutputPipe7, pipe8: (input: Awaited<BreakGenericLink<GenericOutputPipe7>>) => GenericOutputPipe8): Promise<Awaited<GenericOutputPipe8>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe5 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe6 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe7 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe8 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe9 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4, pipe5: (input: Awaited<BreakGenericLink<GenericOutputPipe4>>) => GenericOutputPipe5, pipe6: (input: Awaited<BreakGenericLink<GenericOutputPipe5>>) => GenericOutputPipe6, pipe7: (input: Awaited<BreakGenericLink<GenericOutputPipe6>>) => GenericOutputPipe7, pipe8: (input: Awaited<BreakGenericLink<GenericOutputPipe7>>) => GenericOutputPipe8, pipe9: (input: Awaited<BreakGenericLink<GenericOutputPipe8>>) => GenericOutputPipe9): Promise<Awaited<GenericOutputPipe9>>;
+export declare function asyncPipe<GenericInput extends MaybePromiseLike<AnyValue>, GenericOutputPipe1 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe2 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe3 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe4 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe5 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe6 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe7 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe8 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe9 extends MaybePromiseLike<AnyValue | EscapeVoid>, GenericOutputPipe10 extends MaybePromiseLike<AnyValue | EscapeVoid>>(input: GenericInput, pipe1: (input: Awaited<BreakGenericLink<GenericInput>>) => GenericOutputPipe1, pipe2: (input: Awaited<BreakGenericLink<GenericOutputPipe1>>) => GenericOutputPipe2, pipe3: (input: Awaited<BreakGenericLink<GenericOutputPipe2>>) => GenericOutputPipe3, pipe4: (input: Awaited<BreakGenericLink<GenericOutputPipe3>>) => GenericOutputPipe4, pipe5: (input: Awaited<BreakGenericLink<GenericOutputPipe4>>) => GenericOutputPipe5, pipe6: (input: Awaited<BreakGenericLink<GenericOutputPipe5>>) => GenericOutputPipe6, pipe7: (input: Awaited<BreakGenericLink<GenericOutputPipe6>>) => GenericOutputPipe7, pipe8: (input: Awaited<BreakGenericLink<GenericOutputPipe7>>) => GenericOutputPipe8, pipe9: (input: Awaited<BreakGenericLink<GenericOutputPipe8>>) => GenericOutputPipe9, pipe10: (input: Awaited<BreakGenericLink<GenericOutputPipe9>>) => GenericOutputPipe10): Promise<Awaited<GenericOutputPipe10>>;
+export {};

package/dist/common/asyncPipe.mjs

@@ -0,0 +1,9 @@
+async function asyncPipe(input, ...pipes) {
+    let acc = await input;
+    for (const pipe of pipes) {
+        acc = await pipe(acc);
+    }
+    return acc;
+}
+
+export { asyncPipe };

package/dist/common/asyncRetry.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var sleep = require('./sleep.cjs');
+
+async function useAsyncRetry(retryFunction, shouldRetry, options) {
+    for (let currentTry = 1; true; currentTry++) {
+        const result = await retryFunction();
+        if (currentTry >= options.maxRetry
+            || !shouldRetry(result)) {
+            return result;
+        }
+        if (options.log) {
+            console.log(`useAsyncRetry: attempt ${currentTry} failed, starting new attempt.`);
+        }
+        if (options.timeToSleep) {
+            await sleep.sleep(options.timeToSleep);
+        }
+    }
+}
+function createAsyncRetry(retryFunction, checkFunction, options) {
+    return ((...args) => useAsyncRetry(() => retryFunction(...args), checkFunction, options));
+}
+
+exports.createAsyncRetry = createAsyncRetry;
+exports.useAsyncRetry = useAsyncRetry;

package/dist/common/asyncRetry.d.ts

@@ -0,0 +1,8 @@
+interface CreateAsyncRetryOptions {
+    maxRetry: number;
+    timeToSleep?: number;
+    log?: boolean;
+}
+export declare function useAsyncRetry<GenericOutput extends unknown>(retryFunction: () => Promise<GenericOutput>, shouldRetry: (result: GenericOutput) => boolean, options: CreateAsyncRetryOptions): Promise<GenericOutput>;
+export declare function createAsyncRetry<GenericAnyFunction extends ((...args: any[]) => Promise<any>)>(retryFunction: GenericAnyFunction, checkFunction: (result: Awaited<ReturnType<GenericAnyFunction>>) => boolean, options: CreateAsyncRetryOptions): GenericAnyFunction;
+export {};

package/dist/common/asyncRetry.mjs

@@ -0,0 +1,22 @@
+import { sleep } from './sleep.mjs';
+
+async function useAsyncRetry(retryFunction, shouldRetry, options) {
+    for (let currentTry = 1; true; currentTry++) {
+        const result = await retryFunction();
+        if (currentTry >= options.maxRetry
+            || !shouldRetry(result)) {
+            return result;
+        }
+        if (options.log) {
+            console.log(`useAsyncRetry: attempt ${currentTry} failed, starting new attempt.`);
+        }
+        if (options.timeToSleep) {
+            await sleep(options.timeToSleep);
+        }
+    }
+}
+function createAsyncRetry(retryFunction, checkFunction, options) {
+    return ((...args) => useAsyncRetry(() => retryFunction(...args), checkFunction, options));
+}
+
+export { createAsyncRetry, useAsyncRetry };

package/dist/common/clone.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var entries = require('../object/entries.cjs');
+
+function clone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue instanceof Array) {
+        return unknownValue.map(clone);
+    }
+    else {
+        return entries.entries(unknownValue)
+            .reduce((pv, [key, value]) => {
+            pv[key] = clone(value);
+            return pv;
+        }, {});
+    }
+}
+
+exports.clone = clone;

package/dist/{clone.d.ts → common/clone.d.ts}

@@ -1,2 +1,2 @@
-import { type SimplifyTypeForce } from "./simplifyType";
+import { type SimplifyTypeForce } from "../common/types/simplifyTypeForce";
 export declare function clone<T extends unknown = unknown>(unknownValue: T): SimplifyTypeForce<T>;

package/dist/common/clone.mjs

@@ -0,0 +1,22 @@
+import { entries } from '../object/entries.mjs';
+
+function clone(unknownValue) {
+    if (!unknownValue) {
+        return unknownValue;
+    }
+    else if (typeof unknownValue !== "object") {
+        return unknownValue;
+    }
+    else if (unknownValue instanceof Array) {
+        return unknownValue.map(clone);
+    }
+    else {
+        return entries(unknownValue)
+            .reduce((pv, [key, value]) => {
+            pv[key] = clone(value);
+            return pv;
+        }, {});
+    }
+}
+
+export { clone };

package/dist/common/enum.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+function createEnum(values) {
+    return Object.fromEntries([
+        ...values.map((value) => [value, value]),
+        ["toTuple", () => values],
+        ["has", (value) => values.includes(value)],
+    ]);
+}
+
+exports.createEnum = createEnum;

package/dist/common/enum.d.ts

@@ -0,0 +1,9 @@
+import { type SimplifyTopLevel } from "./types/simplifyTopLevel";
+export type Enum<GenericValues extends [string, ...string[]] = [string, ...string[]]> = SimplifyTopLevel<{
+    [Prop in GenericValues[number]]: Prop;
+} & {
+    toTuple(): GenericValues;
+    has(value: string): value is GenericValues[number];
+}>;
+export declare function createEnum<GenericValue extends string, GenericValues extends [GenericValue, ...GenericValue[]]>(values: GenericValues): Enum<GenericValues>;
+export type GetEnumValue<GenericEnum extends Enum<any>> = ReturnType<GenericEnum["toTuple"]>[number];

package/dist/common/enum.mjs

@@ -0,0 +1,9 @@
+function createEnum(values) {
+    return Object.fromEntries([
+        ...values.map((value) => [value, value]),
+        ["toTuple", () => values],
+        ["has", (value) => values.includes(value)],
+    ]);
+}
+
+export { createEnum };