@duplojs/utils 1.2.17 → 1.2.19

package/dist/array/chunk.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function chunk(...args) {
+    if (args.length === 1) {
+        const [size] = args;
+        return (input) => chunk(input, size);
+    }
+    const [input, size] = args;
+    const result = [];
+    for (let index = 0; index < input.length; index += size) {
+        result.push(input.slice(index, index + size));
+    }
+    return result;
+}
+
+exports.chunk = chunk;

package/dist/array/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare function chunk<GenericInput extends readonly unknown[]>(size: number): (input: GenericInput) => GenericInput[];
+export declare function chunk<GenericInput extends readonly unknown[]>(input: GenericInput, size: number): GenericInput[];

package/dist/array/chunk.mjs

@@ -0,0 +1,14 @@
+function chunk(...args) {
+    if (args.length === 1) {
+        const [size] = args;
+        return (input) => chunk(input, size);
+    }
+    const [input, size] = args;
+    const result = [];
+    for (let index = 0; index < input.length; index += size) {
+        result.push(input.slice(index, index + size));
+    }
+    return result;
+}
+
+export { chunk };

package/dist/array/every.cjs

@@ -3,10 +3,13 @@
 function every(...args) {
     if (args.length === 1) {
         const [predicate] = args;
-        return (array) => every(array, predicate);
+        return (input) => every(input, predicate);
     }
-    const [array, predicate] = args;
-    return array.every((element, index) => predicate(element, { index }));
+    const [input, predicate] = args;
+    return input.every((element, index) => predicate(element, {
+        index,
+        self: input,
+    }));
 }
 
 exports.every = every;

package/dist/array/every.d.ts

@@ -1,6 +1,7 @@
-interface ArrayEveryParams {
+interface ArrayEveryParams<GenericInputArray extends readonly unknown[]> {
     index: number;
+    self: GenericInputArray;
 }
-export declare function every<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArrayEveryParams) => boolean): (array: GenericArray) => boolean;
-export declare function every<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayEveryParams) => boolean): boolean;
+export declare function every<GenericInput extends readonly unknown[]>(predicate: (element: GenericInput[number], params: ArrayEveryParams<GenericInput>) => boolean): (input: GenericInput) => boolean;
+export declare function every<GenericInput extends readonly unknown[]>(input: GenericInput, predicate: (element: GenericInput[number], params: ArrayEveryParams<GenericInput>) => boolean): boolean;
 export {};

package/dist/array/every.mjs

@@ -1,10 +1,13 @@
 function every(...args) {
     if (args.length === 1) {
         const [predicate] = args;
-        return (array) => every(array, predicate);
+        return (input) => every(input, predicate);
     }
-    const [array, predicate] = args;
-    return array.every((element, index) => predicate(element, { index }));
+    const [input, predicate] = args;
+    return input.every((element, index) => predicate(element, {
+        index,
+        self: input,
+    }));
 }
 
 export { every };

package/dist/array/fill/all.d.ts

@@ -1,2 +1,2 @@
-export declare function fillAll<GenericElement extends unknown>(value: GenericElement): (array: readonly GenericElement[]) => GenericElement[];
-export declare function fillAll<GenericElement extends unknown>(array: readonly GenericElement[], value: GenericElement): GenericElement[];
+export declare function fillAll<GenericElement extends unknown>(element: GenericElement): (input: readonly unknown[]) => GenericElement[];
+export declare function fillAll<GenericElement extends unknown>(input: readonly unknown[], element: GenericElement): GenericElement[];

package/dist/array/filter.cjs

@@ -3,10 +3,13 @@
 function filter(...args) {
     if (args.length === 1) {
         const [predicate] = args;
-        return (array) => filter(array, predicate);
+        return (input) => filter(input, predicate);
     }
-    const [array, predicate] = args;
-    return array.filter((item, index) => predicate(item, { index }));
+    const [input, predicate] = args;
+    return input.filter((item, index) => predicate(item, {
+        index,
+        self: input,
+    }));
 }
 
 exports.filter = filter;

package/dist/array/filter.d.ts

@@ -1,8 +1,9 @@
-interface ArrayFilterParams {
+interface ArrayFilterParams<GenericInputArray extends readonly unknown[]> {
     index: number;
+    self: GenericInputArray;
 }
-export declare function filter<GenericArray extends readonly unknown[], GenericOutput extends GenericArray[number]>(predicate: (item: GenericArray[number], params: ArrayFilterParams) => item is GenericOutput): (array: GenericArray) => GenericOutput[];
-export declare function filter<GenericElement extends unknown, GenericOutput extends GenericElement>(array: readonly GenericElement[], predicate: (item: GenericElement, params: ArrayFilterParams) => item is GenericOutput): GenericOutput[];
-export declare function filter<GenericArray extends readonly unknown[]>(predicate: (item: GenericArray[number], params: ArrayFilterParams) => boolean): (array: GenericArray) => GenericArray[number][];
-export declare function filter<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (item: GenericElement, params: ArrayFilterParams) => boolean): GenericElement[];
+export declare function filter<GenericInput extends readonly unknown[], GenericOutput extends GenericInput[number]>(predicate: (item: GenericInput[number], params: ArrayFilterParams<GenericInput>) => item is GenericOutput): (input: GenericInput) => GenericOutput[];
+export declare function filter<GenericInput extends readonly unknown[], GenericOutput extends GenericInput[number]>(input: GenericInput, predicate: (item: GenericInput[number], params: ArrayFilterParams<GenericInput>) => item is GenericOutput): GenericOutput[];
+export declare function filter<GenericInput extends readonly unknown[]>(predicate: (item: GenericInput[number], params: ArrayFilterParams<GenericInput>) => boolean): (input: GenericInput) => GenericInput[number][];
+export declare function filter<GenericInput extends readonly unknown[]>(input: GenericInput, predicate: (item: GenericInput[number], params: ArrayFilterParams<GenericInput>) => boolean): GenericInput[number][];
 export {};

package/dist/array/filter.mjs

@@ -1,10 +1,13 @@
 function filter(...args) {
     if (args.length === 1) {
         const [predicate] = args;
-        return (array) => filter(array, predicate);
+        return (input) => filter(input, predicate);
     }
-    const [array, predicate] = args;
-    return array.filter((item, index) => predicate(item, { index }));
+    const [input, predicate] = args;
+    return input.filter((item, index) => predicate(item, {
+        index,
+        self: input,
+    }));
 }
 
 export { filter };

package/dist/array/flatMap.cjs

@@ -3,10 +3,13 @@
 function flatMap(...args) {
     if (args.length === 1) {
         const [theFunction] = args;
-        return (array) => flatMap(array, theFunction);
+        return (input) => flatMap(input, theFunction);
     }
-    const [array, theFunction] = args;
-    return array.flatMap((element, index) => theFunction(element, { index }));
+    const [input, theFunction] = args;
+    return input.flatMap((element, index) => theFunction(element, {
+        index,
+        self: input,
+    }));
 }
 
 exports.flatMap = flatMap;

package/dist/array/flatMap.d.ts

@@ -1,6 +1,7 @@
-interface ArrayMapParams {
+interface ArrayFlatMapParams<GenericInputArray extends readonly unknown[]> {
     index: number;
+    self: GenericInputArray;
 }
-export declare function flatMap<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => FlatArray<GenericOutput, 1>[];
-export declare function flatMap<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (element: GenericElement, params: ArrayMapParams) => GenericOutput): FlatArray<GenericOutput, 1>[];
+export declare function flatMap<GenericInput extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericInput[number], params: ArrayFlatMapParams<GenericInput>) => GenericOutput): (input: GenericInput) => FlatArray<GenericOutput, 1>[];
+export declare function flatMap<GenericInput extends readonly unknown[], GenericOutput extends unknown>(input: GenericInput, theFunction: (element: GenericInput[number], params: ArrayFlatMapParams<GenericInput>) => GenericOutput): FlatArray<GenericOutput, 1>[];
 export {};

package/dist/array/flatMap.mjs

@@ -1,10 +1,13 @@
 function flatMap(...args) {
     if (args.length === 1) {
         const [theFunction] = args;
-        return (array) => flatMap(array, theFunction);
+        return (input) => flatMap(input, theFunction);
     }
-    const [array, theFunction] = args;
-    return array.flatMap((element, index) => theFunction(element, { index }));
+    const [input, theFunction] = args;
+    return input.flatMap((element, index) => theFunction(element, {
+        index,
+        self: input,
+    }));
 }
 
 export { flatMap };

package/dist/array/index.cjs

@@ -13,6 +13,7 @@ var minOf = require('./minOf.cjs');
 var push = require('./push.cjs');
 var reduce = require('./reduce.cjs');
 var some = require('./some.cjs');
+var sort = require('./sort.cjs');
 var is = require('./is.cjs');
 var findIndex = require('./findIndex.cjs');
 var findLastIndex = require('./findLastIndex.cjs');
@@ -38,16 +39,16 @@ var length = require('./length.cjs');
 var coalescing = require('./coalescing.cjs');
 var toTuple = require('./toTuple.cjs');
 var notIncludes = require('./notIncludes.cjs');
-var _default = require('./sort/default.cjs');
-var number = require('./sort/number.cjs');
-var string = require('./sort/string.cjs');
+var chunk = require('./chunk.cjs');
+var insert$2 = require('./insert.cjs');
+var isLastIndex = require('./isLastIndex.cjs');
 var _delete = require('./splice/delete.cjs');
 var insert = require('./splice/insert.cjs');
 var replace = require('./splice/replace.cjs');
-var _default$1 = require('./at/default.cjs');
+var _default = require('./at/default.cjs');
 var first = require('./at/first.cjs');
 var last = require('./at/last.cjs');
-var _default$2 = require('./fill/default.cjs');
+var _default$1 = require('./fill/default.cjs');
 var all = require('./fill/all.cjs');
 var _delete$1 = require('./findAndSplice/delete.cjs');
 var insert$1 = require('./findAndSplice/insert.cjs');
@@ -69,7 +70,9 @@ exports.minOf = minOf.minOf;
 exports.push = push.push;
 exports.reduce = reduce.reduce;
 exports.reduceFrom = reduce.reduceFrom;
+exports.reduceTools = reduce.reduceTools;
 exports.some = some.some;
+exports.sort = sort.sort;
 exports.is = is.is;
 exports.findIndex = findIndex.findIndex;
 exports.findLastIndex = findLastIndex.findLastIndex;
@@ -95,16 +98,16 @@ exports.length = length.length;
 exports.coalescing = coalescing.coalescing;
 exports.toTuple = toTuple.toTuple;
 exports.notIncludes = notIncludes.notIncludes;
-exports.sort = _default.sort;
-exports.sortNumber = number.sortNumber;
-exports.sortString = string.sortString;
+exports.chunk = chunk.chunk;
+exports.insert = insert$2.insert;
+exports.isLastIndex = isLastIndex.isLastIndex;
 exports.spliceDelete = _delete.spliceDelete;
 exports.spliceInsert = insert.spliceInsert;
 exports.spliceReplace = replace.spliceReplace;
-exports.at = _default$1.at;
+exports.at = _default.at;
 exports.first = first.first;
 exports.last = last.last;
-exports.fill = _default$2.fill;
+exports.fill = _default$1.fill;
 exports.fillAll = all.fillAll;
 exports.findAndSpliceDelete = _delete$1.findAndSpliceDelete;
 exports.findAndSpliceInsert = insert$1.findAndSpliceInsert;

package/dist/array/index.d.ts

@@ -42,3 +42,6 @@ export * from "./length";
 export * from "./coalescing";
 export * from "./toTuple";
 export * from "./notIncludes";
+export * from "./chunk";
+export * from "./insert";
+export * from "./isLastIndex";

package/dist/array/index.mjs

@@ -9,8 +9,9 @@ export { maxOf } from './maxOf.mjs';
 export { minElements } from './minElements.mjs';
 export { minOf } from './minOf.mjs';
 export { push } from './push.mjs';
-export { reduce, reduceFrom } from './reduce.mjs';
+export { reduce, reduceFrom, reduceTools } from './reduce.mjs';
 export { some } from './some.mjs';
+export { sort } from './sort.mjs';
 export { is } from './is.mjs';
 export { findIndex } from './findIndex.mjs';
 export { findLastIndex } from './findLastIndex.mjs';
@@ -36,9 +37,9 @@ export { length } from './length.mjs';
 export { coalescing } from './coalescing.mjs';
 export { toTuple } from './toTuple.mjs';
 export { notIncludes } from './notIncludes.mjs';
-export { sort } from './sort/default.mjs';
-export { sortNumber } from './sort/number.mjs';
-export { sortString } from './sort/string.mjs';
+export { chunk } from './chunk.mjs';
+export { insert } from './insert.mjs';
+export { isLastIndex } from './isLastIndex.mjs';
 export { spliceDelete } from './splice/delete.mjs';
 export { spliceInsert } from './splice/insert.mjs';
 export { spliceReplace } from './splice/replace.mjs';

package/dist/array/insert.cjs

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

package/dist/array/insert.d.ts

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

package/dist/array/insert.mjs

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

package/dist/array/isLastIndex.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function isLastIndex(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => isLastIndex(input, index);
+    }
+    const [input, index] = args;
+    return (input.length - 1) === index;
+}
+
+exports.isLastIndex = isLastIndex;

package/dist/array/isLastIndex.d.ts

@@ -0,0 +1,2 @@
+export declare function isLastIndex<GenericInput extends readonly unknown[]>(index: number): (input: GenericInput) => boolean;
+export declare function isLastIndex<GenericInput extends readonly unknown[]>(input: GenericInput, index: number): boolean;

package/dist/array/isLastIndex.mjs

@@ -0,0 +1,10 @@
+function isLastIndex(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => isLastIndex(input, index);
+    }
+    const [input, index] = args;
+    return (input.length - 1) === index;
+}
+
+export { isLastIndex };

package/dist/array/map.cjs

@@ -3,10 +3,13 @@
 function map(...args) {
     if (args.length === 1) {
         const [theFunction] = args;
-        return (array) => map(array, theFunction);
+        return (input) => map(input, theFunction);
     }
-    const [array, theFunction] = args;
-    return array.map((element, index) => theFunction(element, { index }));
+    const [input, theFunction] = args;
+    return input.map((element, index) => theFunction(element, {
+        index,
+        self: input,
+    }));
 }
 
 exports.map = map;

package/dist/array/map.d.ts

@@ -1,6 +1,7 @@
-interface ArrayMapParams {
+interface ArrayMapParams<GenericInputArray extends readonly unknown[]> {
     index: number;
+    self: GenericInputArray;
 }
-export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => GenericOutput[];
-export declare function map<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (element: GenericElement, params: ArrayMapParams) => GenericOutput): GenericOutput[];
+export declare function map<GenericInput extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericInput[number], params: ArrayMapParams<GenericInput>) => GenericOutput): (input: GenericInput) => GenericOutput[];
+export declare function map<GenericInput extends readonly unknown[], GenericOutput extends unknown>(input: GenericInput, theFunction: (element: GenericInput[number], params: ArrayMapParams<GenericInput>) => GenericOutput): GenericOutput[];
 export {};

package/dist/array/map.mjs

@@ -1,10 +1,13 @@
 function map(...args) {
     if (args.length === 1) {
         const [theFunction] = args;
-        return (array) => map(array, theFunction);
+        return (input) => map(input, theFunction);
     }
-    const [array, theFunction] = args;
-    return array.map((element, index) => theFunction(element, { index }));
+    const [input, theFunction] = args;
+    return input.map((element, index) => theFunction(element, {
+        index,
+        self: input,
+    }));
 }
 
 export { map };

package/dist/array/push.cjs

@@ -3,10 +3,10 @@
 function push(...args) {
     if (args.length === 1) {
         const [item] = args;
-        return (array) => push(array, item);
+        return (input) => push(input, item);
     }
-    const [array, ...items] = args;
-    return [...array, ...items];
+    const [input, ...items] = args;
+    return [...input, ...items];
 }
 
 exports.push = push;

package/dist/array/push.d.ts

@@ -1,2 +1,2 @@
-export declare function push<GenericElement extends unknown>(item: NoInfer<GenericElement>): (array: readonly GenericElement[]) => GenericElement[];
-export declare function push<GenericElement extends unknown>(array: readonly GenericElement[], item: NoInfer<GenericElement>, ...items: NoInfer<GenericElement>[]): GenericElement[];
+export declare function push<GenericElement extends unknown>(item: NoInfer<GenericElement>): (input: readonly GenericElement[]) => GenericElement[];
+export declare function push<GenericElement extends unknown>(input: readonly GenericElement[], item: NoInfer<GenericElement>, ...items: NoInfer<GenericElement>[]): GenericElement[];

package/dist/array/push.mjs

@@ -1,10 +1,10 @@
 function push(...args) {
     if (args.length === 1) {
         const [item] = args;
-        return (array) => push(array, item);
+        return (input) => push(input, item);
     }
-    const [array, ...items] = args;
-    return [...array, ...items];
+    const [input, ...items] = args;
+    return [...input, ...items];
 }
 
 export { push };

package/dist/array/reduce.cjs

@@ -3,30 +3,42 @@
 var kind = require('../common/kind.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
 var unwrap = require('../common/unwrap.cjs');
+var push = require('./push.cjs');
 var override = require('../object/override.cjs');
 
 const arrayReduceFromKind = kind.createKind("array-reduce-from");
 function reduceFrom(value) {
     return arrayReduceFromKind.setTo(wrapValue.wrapValue(value));
 }
+const reduceTools = {
+    exit(output) {
+        return { "-exit": output };
+    },
+    next(output) {
+        return { "-next": output };
+    },
+    nextWithObject(object1, object2) {
+        return { "-next": override.override(object1, object2) };
+    },
+    nextPush(array, ...[value, ...values]) {
+        return { "-next": push.push(array, value, ...values) };
+    },
+};
 function reduce(...args) {
     if (args.length === 2) {
         const [fromValue, theFunction] = args;
-        return (array) => reduce(array, fromValue, theFunction);
+        return (input) => reduce(input, fromValue, theFunction);
     }
-    const [array, fromValue, theFunction] = args;
+    const [input, fromValue, theFunction] = args;
     let lastValue = unwrap.unwrap(fromValue);
-    for (let index = 0; index < array.length; index++) {
-        const element = array[index];
+    for (let index = 0; index < input.length; index++) {
+        const element = input[index];
         const result = theFunction({
             element,
             index,
             lastValue,
-            nextWithObject: ((object1, object2) => ({
-                "-next": override.override(object1, object2),
-            })),
-            exit: (output) => ({ "-exit": output }),
-            next: (output) => ({ "-next": output }),
+            self: input,
+            ...reduceTools,
         });
         if ("-exit" in result) {
             return result["-exit"];
@@ -38,3 +50,4 @@ function reduce(...args) {
 
 exports.reduce = reduce;
 exports.reduceFrom = reduceFrom;
+exports.reduceTools = reduceTools;

package/dist/array/reduce.d.ts

@@ -8,20 +8,23 @@ export interface ArrayReduceNext<GenericOutput extends unknown = unknown> {
 export interface ArrayReduceExit<GenericOutput extends unknown = unknown> {
     "-exit": GenericOutput;
 }
-export interface ArrayReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
-    element: GenericElement;
+export interface ArrayReduceFunctionParams<GenericInputArray extends readonly unknown[] = unknown[], GenericOutput extends unknown = unknown> {
+    element: GenericInputArray[number];
     index: number;
     lastValue: GenericOutput;
     nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => ArrayReduceNext<GenericOutput> : undefined;
     next(output: GenericOutput): ArrayReduceNext<GenericOutput>;
     exit<GenericExitValue extends unknown>(output: GenericExitValue): ArrayReduceExit<GenericExitValue>;
+    self: GenericInputArray;
+    nextPush: GenericOutput extends readonly any[] ? (array: GenericOutput, ...values: GenericOutput) => ArrayReduceNext<GenericOutput> : undefined;
 }
 declare const arrayReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"array-reduce-from", unknown>>;
 export interface ArrayReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof arrayReduceFromKind.definition>, WrappedValue<GenericValue> {
 }
 export declare function reduceFrom<GenericValue extends unknown>(value: GenericValue): ArrayReduceFromResult<GenericValue>;
+export declare const reduceTools: Pick<ArrayReduceFunctionParams<any, any>, "exit" | "next" | "nextWithObject" | "nextPush">;
 export type ArrayEligibleReduceFromValue = number | string | bigint | boolean | ArrayReduceFromResult;
 export type ArrayReduceFromValue<GenericValue extends ArrayEligibleReduceFromValue> = GenericValue extends ArrayReduceFromResult ? Unwrap<GenericValue> : ToLargeEnsemble<GenericValue>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayEligibleReduceFromValue, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduce<GenericInput extends readonly unknown[], GenericReduceFrom extends ArrayEligibleReduceFromValue, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericInput, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): (input: GenericInput) => ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduce<GenericInput extends readonly unknown[], GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(input: GenericInput, startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericInput, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
 export {};

package/dist/array/reduce.mjs

@@ -1,30 +1,42 @@
 import { createKind } from '../common/kind.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
 import { unwrap } from '../common/unwrap.mjs';
+import { push } from './push.mjs';
 import { override } from '../object/override.mjs';
 
 const arrayReduceFromKind = createKind("array-reduce-from");
 function reduceFrom(value) {
     return arrayReduceFromKind.setTo(wrapValue(value));
 }
+const reduceTools = {
+    exit(output) {
+        return { "-exit": output };
+    },
+    next(output) {
+        return { "-next": output };
+    },
+    nextWithObject(object1, object2) {
+        return { "-next": override(object1, object2) };
+    },
+    nextPush(array, ...[value, ...values]) {
+        return { "-next": push(array, value, ...values) };
+    },
+};
 function reduce(...args) {
     if (args.length === 2) {
         const [fromValue, theFunction] = args;
-        return (array) => reduce(array, fromValue, theFunction);
+        return (input) => reduce(input, fromValue, theFunction);
     }
-    const [array, fromValue, theFunction] = args;
+    const [input, fromValue, theFunction] = args;
     let lastValue = unwrap(fromValue);
-    for (let index = 0; index < array.length; index++) {
-        const element = array[index];
+    for (let index = 0; index < input.length; index++) {
+        const element = input[index];
         const result = theFunction({
             element,
             index,
             lastValue,
-            nextWithObject: ((object1, object2) => ({
-                "-next": override(object1, object2),
-            })),
-            exit: (output) => ({ "-exit": output }),
-            next: (output) => ({ "-next": output }),
+            self: input,
+            ...reduceTools,
         });
         if ("-exit" in result) {
             return result["-exit"];
@@ -34,4 +46,4 @@ function reduce(...args) {
     return lastValue;
 }
 
-export { reduce, reduceFrom };
+export { reduce, reduceFrom, reduceTools };

package/dist/array/reduceRight.cjs

@@ -1,26 +1,23 @@
 'use strict';
 
 var unwrap = require('../common/unwrap.cjs');
-var override = require('../object/override.cjs');
+var reduce = require('./reduce.cjs');
 
 function reduceRight(...args) {
     if (args.length === 2) {
         const [fromValue, theFunction] = args;
-        return (array) => reduceRight(array, fromValue, theFunction);
+        return (input) => reduceRight(input, fromValue, theFunction);
     }
-    const [array, fromValue, theFunction] = args;
+    const [input, fromValue, theFunction] = args;
     let lastValue = unwrap.unwrap(fromValue);
-    for (let index = array.length - 1; index >= 0; index--) {
-        const element = array[index];
+    for (let index = input.length - 1; index >= 0; index--) {
+        const element = input[index];
         const result = theFunction({
             element,
             index,
             lastValue,
-            nextWithObject: ((object1, object2) => ({
-                "-next": override.override(object1, object2),
-            })),
-            exit: (output) => ({ "-exit": output }),
-            next: (output) => ({ "-next": output }),
+            self: input,
+            ...reduce.reduceTools,
         });
         if ("-exit" in result) {
             return result["-exit"];

package/dist/array/reduceRight.d.ts

@@ -1,4 +1,4 @@
 import { type ArrayReduceFunctionParams, type ArrayReduceFromResult, type ArrayReduceFromValue, type ArrayReduceExit, type ArrayReduceNext } from "./reduce";
 import { type IsEqual } from "../common";
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduceRight<GenericInput extends readonly unknown[], GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericInput, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): (input: GenericInput) => ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduceRight<GenericInput extends readonly unknown[], GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(input: GenericInput, startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericInput, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);