@ts-fns/stdlib 0.1.0

package/dist/array/index.mjs

@@ -0,0 +1,498 @@
+import { t as orThrow } from "../orThrow-V91Jw2lF.mjs";
+import { t as purry } from "../purry-BOWmqwDB.mjs";
+import { i as NotFoundError, t as EmptyArrayError } from "../errors-Dw1kitu_.mjs";
+import "../function-DnI2v0p3.mjs";
+//#region src/array/_globalAliases.ts
+const { from, fromAsync, isArray, of } = Array;
+const arrayConstructor = Array;
+//#endregion
+//#region src/array/at.ts
+/**
+* Internal method that wraps `arr.at()` but throws the same `RangeError` that `arr.with()` does
+* @throws {RangeError}
+*/
+function atImplementation(arr, index) {
+	if (arr.length === 0 || index >= arr.length || index < -arr.length) return /* @__PURE__ */ new RangeError(`Arr.at() :: Invalid index : ${index}`);
+	return arr.at(index);
+}
+function at(...args) {
+	return purry(atImplementation, args);
+}
+function atAssert(...args) {
+	return purry(orThrow(atImplementation), args);
+}
+at.assert = atAssert;
+//#endregion
+//#region src/array/chunk.ts
+function chunkImplementation(arr, size) {
+	if (size < 1) throw new RangeError(`Arr.chunk() :: ${size} must be a positive integer`);
+	if (arr.length === 0) return [];
+	if (size >= arr.length) return [[...arr]];
+	const chunks = Math.ceil(arr.length / size);
+	if (size === 1) return arr.map((v) => [v]);
+	return Array(chunks).fill(void 0).map((_, index) => {
+		const start = index * size;
+		return arr.slice(start, start + size);
+	});
+}
+function chunk(...args) {
+	return purry(chunkImplementation, args);
+}
+function chunkAssert(...args) {
+	return purry(orThrow(chunkImplementation), args);
+}
+chunk.assert = chunkAssert;
+//#endregion
+//#region src/array/concat.ts
+function concatImplementation(arr, other) {
+	return [...arr, ...other];
+}
+function concat(...args) {
+	return purry(concatImplementation, args);
+}
+//#endregion
+//#region src/array/drop.ts
+function dropImplementation(arr, n) {
+	return arr.slice(n);
+}
+function drop(...args) {
+	return purry(dropImplementation, args);
+}
+//#endregion
+//#region src/array/every.ts
+function everyImplementation(arr, predicate) {
+	return arr.every(predicate);
+}
+function every(...args) {
+	return purry(everyImplementation, args);
+}
+//#endregion
+//#region src/array/find.ts
+function findImplementation(arr, predicate) {
+	const foundIndex = arr.findIndex(predicate);
+	if (foundIndex === -1) return new NotFoundError("Arr.find :: predicate found no match.");
+	return arr[foundIndex];
+}
+function find(...args) {
+	return purry(findImplementation, args);
+}
+function findAssert(...args) {
+	return purry(orThrow(findImplementation), args);
+}
+find.assert = findAssert;
+//#endregion
+//#region src/array/findIndex.ts
+function findIndexImplementation(arr, predicate) {
+	const result = arr.findIndex(predicate);
+	if (result === -1) return new NotFoundError("Arr.findIndex.orError() :: predicate found no match.");
+	return result;
+}
+function findIndex(...args) {
+	return purry(findIndexImplementation, args);
+}
+function findIndexAssert(...args) {
+	return purry(orThrow(findIndexImplementation), args);
+}
+findIndex.assert = findIndexAssert;
+//#endregion
+//#region src/array/findLast.ts
+function findLastImplementation(arr, predicate) {
+	const foundIndex = arr.findLastIndex(predicate);
+	if (foundIndex === -1) return new NotFoundError("Arr.findLast() :: predicate found no match.");
+	return arr[foundIndex];
+}
+function findLast(...args) {
+	return purry(findLastImplementation, args);
+}
+function findLastAssert(...args) {
+	return purry(orThrow(findLastImplementation), args);
+}
+findLast.assert = findLastAssert;
+//#endregion
+//#region src/array/findLastIndex.ts
+function findLastIndexImplementation(arr, predicate) {
+	const result = arr.findLastIndex(predicate);
+	if (result === -1) return new NotFoundError("Arr.findLastIndex() :: predicate found no match.");
+	return result;
+}
+function findLastIndex(...args) {
+	return purry(findLastIndexImplementation, args);
+}
+function findLastIndexAssert(...args) {
+	return purry(orThrow(findLastIndexImplementation), args);
+}
+findLastIndex.assert = findLastIndexAssert;
+//#endregion
+//#region src/array/first.ts
+function first(arr) {
+	if (arr.length === 0) return new EmptyArrayError("Arr.first() :: array is empty");
+	return arr[0];
+}
+function firstAssert(arr) {
+	return orThrow(first)(arr);
+}
+first.assert = firstAssert;
+//#endregion
+//#region src/array/flatMap.ts
+function flatMapImplementation(arr, callbackfn) {
+	return arr.flatMap(callbackfn);
+}
+function flatMap(...args) {
+	return purry(flatMapImplementation, args);
+}
+//#endregion
+//#region src/array/forEach.ts
+function forEachImplementation(arr, callbackfn) {
+	arr.forEach(callbackfn);
+	return arr;
+}
+function forEach(...args) {
+	return purry(forEachImplementation, args);
+}
+//#endregion
+//#region src/array/init.ts
+/**
+*
+*/
+function init(arr) {
+	return arr.slice(0, arr.length - 1);
+}
+function initAssert(arr) {
+	return orThrow(init)(arr);
+}
+init.assert = initAssert;
+//#endregion
+//#region src/array/insert.ts
+function insertImplementation(arr, index, value) {
+	try {
+		return arr.with(index, value);
+	} catch (_e) {
+		return /* @__PURE__ */ new RangeError(`Arr.insert() - Invalid index : ${index}`);
+	}
+}
+function insert(...args) {
+	return purry(insertImplementation, args);
+}
+function insertAssert(...args) {
+	return purry(orThrow(insertImplementation), args);
+}
+insert.assert = insertAssert;
+//#endregion
+//#region src/array/isEmpty.ts
+function isNotEmpty(arr) {
+	return arr.length > 0;
+}
+function isEmpty(arr) {
+	return arr.length === 0;
+}
+//#endregion
+//#region src/array/join.ts
+function joinImplementation(arr, separator) {
+	return arr.join(separator);
+}
+function join(...args) {
+	return purry(joinImplementation, args);
+}
+//#endregion
+//#region src/array/last.ts
+function last(arr) {
+	if (arr.length === 0) return new EmptyArrayError("Arr.last() :: array is empty");
+	return arr[arr.length - 1];
+}
+function lastAssert(arr) {
+	return orThrow(last)(arr);
+}
+last.assert = lastAssert;
+//#endregion
+//#region src/array/length.ts
+/**
+* Returns length of array
+* @param arr
+* @returns
+*/
+function length(arr) {
+	return arr.length;
+}
+//#endregion
+//#region src/array/map.ts
+function mapImplementation(arr, callbackfn) {
+	return arr.map(callbackfn);
+}
+function map(...args) {
+	return purry(mapImplementation, args);
+}
+//#endregion
+//#region src/array/ofLength.ts
+/**
+* Arr.ofLength
+*
+* @throws {RangeError}
+*/
+function ofLength(arrayLength) {
+	return Array(arrayLength);
+}
+//#endregion
+//#region src/array/partition.ts
+function partitionImplementation(arr, predicate) {
+	const len = arr.length;
+	const left = [];
+	const right = [];
+	for (let i = 0; i < len; i += 1) {
+		const value = arr[i];
+		if (predicate(value, i, arr)) left.push(value);
+		else right.push(value);
+	}
+	return [left, right];
+}
+function partition(...args) {
+	return purry(partitionImplementation, args);
+}
+//#endregion
+//#region src/array/pop.ts
+function pop(arr) {
+	if (arr.length === 0) return new EmptyArrayError("Arr.pop() :: array is empty");
+	const lastIndex = arr.length - 1;
+	return [arr[lastIndex], arr.slice(0, lastIndex)];
+}
+function popAssert(arr) {
+	return orThrow(pop)(arr);
+}
+pop.assert = popAssert;
+//#endregion
+//#region src/array/prepend.ts
+function prependImplementation(arr, other) {
+	return [...other, ...arr];
+}
+function prepend(...args) {
+	return purry(prependImplementation, args);
+}
+//#endregion
+//#region src/array/push.ts
+function pushImplementation(arr, value) {
+	return [...arr, value];
+}
+function push(...args) {
+	return purry(pushImplementation, args);
+}
+//#endregion
+//#region src/array/reduce.ts
+function reduceImplementation(arr, callbackFn, initialValue) {
+	return arr.reduce(callbackFn, initialValue);
+}
+function reduce(...args) {
+	return purry(reduceImplementation, args);
+}
+//#endregion
+//#region src/array/reduce1.ts
+function reduce1Implementation(arr, callbackFn) {
+	return arr.reduce(callbackFn);
+}
+function reduce1(...args) {
+	return purry(reduce1Implementation, args);
+}
+//#endregion
+//#region src/array/reduceRight.ts
+function reduceRightImplementation(arr, callbackFn, initialValue) {
+	return arr.reduceRight(callbackFn, initialValue);
+}
+function reduceRight(...args) {
+	return purry(reduceRightImplementation, args);
+}
+//#endregion
+//#region src/array/reduceRight1.ts
+function reduceRight1Implementation(arr, callbackFn) {
+	return arr.reduceRight(callbackFn);
+}
+function reduceRight1(...args) {
+	return purry(reduceRight1Implementation, args);
+}
+//#endregion
+//#region src/array/rest.ts
+/**
+* Returns an array excluding the first entry
+* @param arr
+* @returns
+*/
+function rest(arr) {
+	const [, ...tail] = arr;
+	return tail;
+}
+//#endregion
+//#region src/array/reverse.ts
+function reverseImplementation(arr) {
+	return arr.toReversed();
+}
+function reverse(...args) {
+	return purry(reverseImplementation, args);
+}
+//#endregion
+//#region src/array/scan.ts
+function scanImplementation(arr, callbackFn, initialValue) {
+	const len = arr.length;
+	const result = Array(len + 1);
+	let acc = initialValue;
+	result[0] = acc;
+	for (let index = 0; index < len; index += 1) {
+		acc = callbackFn(acc, arr[index], index, arr);
+		result[index + 1] = acc;
+	}
+	return result;
+}
+function scan(...args) {
+	return purry(scanImplementation, args);
+}
+//#endregion
+//#region src/array/shift.ts
+function shift(arr) {
+	if (arr.length === 0) return new EmptyArrayError("Arr.shift() :: array is empty");
+	const [head, ...tail] = arr;
+	return [head, tail];
+}
+function shiftAssert(arr) {
+	return orThrow(shift)(arr);
+}
+shift.assert = shiftAssert;
+//#endregion
+//#region src/array/shuffle.ts
+function shuffle(arr) {
+	const result = [...arr];
+	const len = result.length;
+	for (let i = 0; i < len; i += 1) {
+		const rand = i + Math.floor(Math.random() * (len - i));
+		const value = result[rand];
+		result[rand] = result[i];
+		result[i] = value;
+	}
+	return result;
+}
+//#endregion
+//#region src/array/some.ts
+function someImplementation(arr, predicate) {
+	return arr.some(predicate);
+}
+function some(...args) {
+	return purry(someImplementation, args);
+}
+//#endregion
+//#region src/array/sort.ts
+function sortImplementation(arr, compareFn) {
+	return arr.toSorted(compareFn);
+}
+function sort(...args) {
+	return purry(sortImplementation, args);
+}
+//#endregion
+//#region src/array/sortBy.ts
+function sortByImplementation(arr, mapFn) {
+	return arr.toSorted((left, right) => {
+		const l = mapFn(left);
+		const r = mapFn(right);
+		if (l < r) return -1;
+		if (l > r) return 0;
+		return 0;
+	});
+}
+function sortBy(...args) {
+	return purry(sortByImplementation, args);
+}
+//#endregion
+//#region src/array/take.ts
+function takeImplementation(arr, limit) {
+	if (limit < 1) throw new RangeError(`Arr.take() :: ${limit} must be a positive integer`);
+	return arr.slice(0, limit);
+}
+function take(...args) {
+	return purry(takeImplementation, args);
+}
+//#endregion
+//#region src/array/transpose.ts
+function transpose(arr) {
+	const maxLen = arr.reduce((acc, inner) => Math.max(acc, inner.length), 0);
+	return Array(maxLen).fill(void 0).map((_, index) => arr.map((inner) => inner[index]));
+}
+//#endregion
+//#region src/array/unique.ts
+function unique(arr) {
+	if (arr.length === 0) return [];
+	return Array.from(new Set(arr));
+}
+//#endregion
+//#region src/array/uniqueBy.ts
+function uniqueByImplementation(arr, mapFn) {
+	if (arr.length === 0) return [];
+	const map = /* @__PURE__ */ new Map();
+	arr.forEach((_, index) => {
+		const value = arr[index];
+		const key = mapFn(value);
+		if (!map.has(key)) map.set(key, value);
+	});
+	return Array.from(map.values());
+}
+function uniqueBy(...args) {
+	return purry(uniqueByImplementation, args);
+}
+//#endregion
+//#region src/array/uniqueWith.ts
+function uniqueWith(arr, isEqual) {
+	if (arr.length === 0) return [];
+	return arr.filter((value, index) => {
+		return index === (arr.find((otherValue, otherIndex) => index === otherIndex || isEqual(value, otherValue)) ?? -1);
+	});
+}
+//#endregion
+//#region src/array/unshift.ts
+function unshiftImplementation(arr, value) {
+	return [value, ...arr];
+}
+function unshift(...args) {
+	return purry(unshiftImplementation, args);
+}
+//#endregion
+//#region src/array/update.ts
+function updateImplementation(arr, index, fn) {
+	if (index >= arr.length || index < -arr.length) return /* @__PURE__ */ new RangeError(`Arr.update() :: Invalid index : ${index}`);
+	const updatedValue = fn(arr.at(index));
+	return arr.with(index, updatedValue);
+}
+function update(...args) {
+	return purry(updateImplementation, args);
+}
+function updateAssert(...args) {
+	return purry(orThrow(updateImplementation), args);
+}
+update.assert = updateAssert;
+//#endregion
+//#region src/array/window.ts
+function windowImplementation(arr, size) {
+	if (size < 1) throw new RangeError(`Arr.window() :: ${size} must be a positive integer`);
+	const limit = arr.length - (size - 1);
+	if (limit < 0) return [];
+	return Array(limit).fill(void 0).map((_, index) => arr.slice(index, index + size));
+}
+function window(...args) {
+	return purry(windowImplementation, args);
+}
+function windowAssert(...args) {
+	return purry(orThrow(windowImplementation), args);
+}
+window.assert = windowAssert;
+//#endregion
+//#region src/array/zip.ts
+function zipImplementation(arr, other) {
+	return Array(Math.min(arr.length, other.length)).fill(void 0).map((_, index) => [arr[index], other[index]]);
+}
+function zip(...args) {
+	return purry(zipImplementation, args);
+}
+//#endregion
+//#region src/array/zipWith.ts
+function zipWithImplementation(arr, other, fn) {
+	return Array(Math.min(arr.length, other.length)).fill(void 0).map((_, index) => fn(arr[index], other[index]));
+}
+function zipWith(...args) {
+	return purry(zipWithImplementation, args);
+}
+//#endregion
+export { arrayConstructor as Array, at, atAssert, chunk, concat, drop, every, find, findIndex, findLast, findLastIndex, first, flatMap, forEach, from, fromAsync, init, insert, isArray, isEmpty, isNotEmpty, join, last, length, map, of, ofLength, partition, pop, prepend, push, reduce, reduce1, reduceRight, reduceRight1, rest, reverse, scan, shift, shuffle, some, sort, sortBy, take, transpose, unique, uniqueBy, uniqueWith, unshift, update, window, zip, zipWith };
+
+//# sourceMappingURL=index.mjs.map

package/dist/array/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/array/_globalAliases.ts","../../src/array/at.ts","../../src/array/chunk.ts","../../src/array/concat.ts","../../src/array/drop.ts","../../src/array/every.ts","../../src/array/find.ts","../../src/array/findIndex.ts","../../src/array/findLast.ts","../../src/array/findLastIndex.ts","../../src/array/first.ts","../../src/array/flatMap.ts","../../src/array/forEach.ts","../../src/array/init.ts","../../src/array/insert.ts","../../src/array/isEmpty.ts","../../src/array/join.ts","../../src/array/last.ts","../../src/array/length.ts","../../src/array/map.ts","../../src/array/ofLength.ts","../../src/array/partition.ts","../../src/array/pop.ts","../../src/array/prepend.ts","../../src/array/push.ts","../../src/array/reduce.ts","../../src/array/reduce1.ts","../../src/array/reduceRight.ts","../../src/array/reduceRight1.ts","../../src/array/rest.ts","../../src/array/reverse.ts","../../src/array/scan.ts","../../src/array/shift.ts","../../src/array/shuffle.ts","../../src/array/some.ts","../../src/array/sort.ts","../../src/array/sortBy.ts","../../src/array/take.ts","../../src/array/transpose.ts","../../src/array/unique.ts","../../src/array/uniqueBy.ts","../../src/array/uniqueWith.ts","../../src/array/unshift.ts","../../src/array/update.ts","../../src/array/window.ts","../../src/array/zip.ts","../../src/array/zipWith.ts"],"sourcesContent":["export const { from, fromAsync, isArray, of } = Array;\n\nconst arrayConstructor = Array;\n\nexport { arrayConstructor as Array };\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\n/**\n * Internal method that wraps `arr.at()` but throws the same `RangeError` that `arr.with()` does\n * @throws {RangeError}\n */\nfunction atImplementation<T>(arr: readonly T[], index: number): RangeError | T {\n  if (arr.length === 0 || index >= arr.length || index < -arr.length) {\n    return new RangeError(`Arr.at() :: Invalid index : ${index}`);\n  }\n\n  return arr.at(index) as T;\n}\n\n/**\n * Get an element from an array by index.\n *\n * @category Array\n * @param arr - The array to get the element from.\n * @param index - The index of the element to get.\n *\n * @example\n * ```ts\n * at([1, 2, 3], 1); // 2\n * ```\n */\nexport function at<T>(index: number): (arr: readonly T[]) => RangeError | T;\nexport function at<T>(arr: readonly T[], index: number): RangeError | T;\nexport function at(...args: readonly unknown[]): unknown {\n  return purry(atImplementation, args);\n}\n\nexport function atAssert<T>(index: number): (arr: readonly T[]) => T;\nexport function atAssert<T>(arr: readonly T[], index: number): T;\nexport function atAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(atImplementation), args);\n}\n\nat.assert = atAssert;\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction chunkImplementation<T>(arr: readonly T[], size: number): T[][] {\n  if (size < 1) {\n    throw new RangeError(`Arr.chunk() :: ${size} must be a positive integer`);\n  }\n\n  if (arr.length === 0) {\n    return [];\n  }\n\n  if (size >= arr.length) {\n    // Optimized for when there is only one chunk.\n    return [[...arr]];\n  }\n\n  const chunks = Math.ceil(arr.length / size);\n\n  if (size === 1) {\n    return arr.map(v => [v]);\n  }\n\n  const result = Array(chunks)\n    .fill(undefined)\n    .map((_, index) => {\n      const start = index * size;\n      return arr.slice(start, start + size);\n    });\n\n  return result;\n}\n\n/**\n *\n * @throws {RangeError}\n */\nexport function chunk(size: number): <T>(arr: readonly T[]) => T[][];\nexport function chunk<T>(arr: readonly T[], size: number): T[][];\nexport function chunk(...args: unknown[]): unknown {\n  return purry(chunkImplementation, args);\n}\n\nfunction chunkAssert<T>(size: number): (arr: readonly T[]) => T[][];\nfunction chunkAssert<T>(arr: readonly T[], size: number): T[][];\nfunction chunkAssert(...args: unknown[]): unknown {\n  return purry(orThrow(chunkImplementation), args);\n}\n\nchunk.assert = chunkAssert;\n","import { purry } from '../function/purry';\n\nfunction concatImplementation<T>(arr: readonly T[], other: readonly T[]): T[] {\n  return [...arr, ...other];\n}\n\nexport function concat<T>(other: readonly T[]): (arr: readonly T[]) => T;\nexport function concat<T>(arr: readonly T[], other: readonly T[]): T;\nexport function concat(...args: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction dropImplementation<T>(arr: readonly T[], n: number): T[] {\n  return arr.slice(n);\n}\n\nexport function drop<T>(n: number): (arr: readonly T[]) => T[];\nexport function drop<T>(arr: readonly T[], n: number): T[];\nexport function drop(...args: readonly unknown[]): unknown {\n  return purry(dropImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction everyImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): boolean {\n  return arr.every(predicate);\n}\n\nexport function every<T, S extends T>(\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): (arr: readonly T[]) => arr is S[];\nexport function every<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => T[];\nexport function every<T, S extends T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): arr is S[];\nexport function every<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];\nexport function every(...args: readonly unknown[]): unknown {\n  return purry(everyImplementation, args);\n}\n","import { NotFoundError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction findImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | T {\n  // -1 unequivocally tells us \"not found\", where vale check on `null | undefined` doesn't because that could be a valid value\n  const foundIndex = arr.findIndex(predicate);\n\n  if (foundIndex === -1) {\n    return new NotFoundError('Arr.find :: predicate found no match.');\n  }\n\n  return arr[foundIndex]!;\n}\n\nexport function find<T, S extends T>(\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): (arr: readonly T[]) => NotFoundError | S;\nexport function find<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => NotFoundError | T;\nexport function find<T, S extends T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): NotFoundError | S;\nexport function find<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | T;\nexport function find(...args: readonly unknown[]): unknown {\n  return purry(findImplementation, args);\n}\n\nfunction findAssert<T, S extends T>(\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): (arr: readonly T[]) => S;\nfunction findAssert<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T;\nfunction findAssert<T, S extends T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): S;\nfunction findAssert<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T;\nfunction findAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(findImplementation), args);\n}\n\nfind.assert = findAssert;\n","import { NotFoundError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction findIndexImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | number {\n  const result = arr.findIndex(predicate);\n  if (result === -1) {\n    return new NotFoundError('Arr.findIndex.orError() :: predicate found no match.');\n  }\n  return result;\n}\n\nexport function findIndex<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => NotFoundError | number;\nexport function findIndex<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | number;\nexport function findIndex(...args: readonly unknown[]): unknown {\n  return purry(findIndexImplementation, args);\n}\n\nfunction findIndexAssert<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => number;\nfunction findIndexAssert<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): number;\nfunction findIndexAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(findIndexImplementation), args);\n}\n\nfindIndex.assert = findIndexAssert;\n","import { NotFoundError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction findLastImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | T {\n  // -1 unequivocally tells us \"not found\", where vale check on `null | undefined` doesn't because that could be a valid value\n  const foundIndex = arr.findLastIndex(predicate);\n\n  if (foundIndex === -1) {\n    return new NotFoundError('Arr.findLast() :: predicate found no match.');\n  }\n\n  return arr[foundIndex]!;\n}\n\nexport function findLast<T, S extends T>(\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): (arr: readonly T[]) => NotFoundError | S;\nexport function findLast<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => NotFoundError | T;\nexport function findLast<T, S extends T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): NotFoundError | S;\nexport function findLast<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | T;\nexport function findLast(...args: readonly unknown[]): unknown {\n  return purry(findLastImplementation, args);\n}\n\nfunction findLastAssert<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => T;\nfunction findLastAssert<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T;\nfunction findLastAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(findLastImplementation), args);\n}\n\nfindLast.assert = findLastAssert;\n","import { NotFoundError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction findLastIndexImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | number {\n  const result = arr.findLastIndex(predicate);\n  if (result === -1) {\n    return new NotFoundError('Arr.findLastIndex() :: predicate found no match.');\n  }\n  return result;\n}\n\nexport function findLastIndex<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => NotFoundError | number;\nexport function findLastIndex<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): NotFoundError | number;\nexport function findLastIndex(...args: readonly unknown[]): unknown {\n  return purry(findLastIndexImplementation, args);\n}\n\nfunction findLastIndexAssert<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => number;\nfunction findLastIndexAssert<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): number;\nfunction findLastIndexAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(findLastIndexImplementation), args);\n}\n\nfindLastIndex.assert = findLastIndexAssert;\n","import { EmptyArrayError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport type { ReadonlyNonEmptyArray } from '../types';\n\n/**\n *\n */\nexport function first<T>(arr: ReadonlyNonEmptyArray<T>): T[];\nexport function first<T>(arr: readonly T[]): EmptyArrayError | T;\nexport function first<T>(arr: readonly T[]): EmptyArrayError | T {\n  if (arr.length === 0) {\n    return new EmptyArrayError('Arr.first() :: array is empty');\n  }\n  return arr[0]!;\n}\n\nfunction firstAssert<T>(arr: readonly T[]): T {\n  // @ts-expect-error\n  return orThrow(first)(arr);\n}\n\nfirst.assert = firstAssert;\n","import { purry } from '../function/purry';\n\nfunction flatMapImplementation<T, U>(\n  arr: readonly T[],\n  callbackfn: (value: T, index: number, array: readonly T[]) => U | readonly U[],\n): U[] {\n  return arr.flatMap(callbackfn);\n}\n\nexport function flatMap<T, U>(\n  callbackfn: (value: T, index: number, array: readonly T[]) => U | readonly U[],\n): (arr: T[]) => U[];\nexport function flatMap<T, U>(arr: T[], callbackfn: (value: T, index: number, array: readonly U[]) => U[]): U[];\nexport function flatMap(...args: readonly unknown[]): unknown {\n  return purry(flatMapImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction forEachImplementation<T>(arr: T[], callbackfn: (value: T, index: number, array: T[]) => void): T[] {\n  arr.forEach(callbackfn);\n  return arr;\n}\n\nexport function forEach<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): (arr: T[]) => T[];\nexport function forEach<T>(arr: T[], callbackfn: (value: T, index: number, array: readonly T[]) => void): T[];\nexport function forEach(...args: readonly unknown[]): unknown {\n  return purry(forEachImplementation, args);\n}\n","import { orThrow } from '../function/orThrow';\n\n/**\n *\n */\nexport function init<T>(arr: readonly T[]): T[] {\n  return arr.slice(0, arr.length - 1);\n}\n\nfunction initAssert<T>(arr: readonly T[]): T[] {\n  // @ts-expect-error\n  return orThrow(init)(arr);\n}\n\ninit.assert = initAssert;\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction insertImplementation<T>(arr: readonly T[], index: number, value: T): RangeError | T[] {\n  try {\n    return arr.with(index, value);\n  } catch (_e) {\n    return new RangeError(`Arr.insert() - Invalid index : ${index}`);\n  }\n}\n\n/**\n * `with` is reserved word. So this function is uses `insert`\n * @throws RangeError\n */\nexport function insert<T>(index: number, value: T): (arr: readonly T[]) => T[];\nexport function insert<T>(arr: readonly T[], index: number, value: T): T[];\nexport function insert(...args: readonly unknown[]): unknown {\n  return purry(insertImplementation, args);\n}\n\nfunction insertAssert<T>(index: number, value: T): (arr: readonly T[]) => T[];\nfunction insertAssert<T>(arr: readonly T[], index: number, value: T): T[];\nfunction insertAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(insertImplementation), args);\n}\n\ninsert.assert = insertAssert;\n","import type { NonEmptyArray, ReadonlyNonEmptyArray } from '../types';\n\nexport function isNotEmpty<T>(value: T[]): value is NonEmptyArray<T>;\nexport function isNotEmpty<T>(value: readonly T[]): value is ReadonlyNonEmptyArray<T>;\nexport function isNotEmpty(arr: readonly unknown[]): boolean {\n  return arr.length > 0;\n}\n\n// TODO: is narrowing to [] really want I want here?\nexport function isEmpty<T>(value: T[]): value is [];\nexport function isEmpty<T>(value: readonly T[]): value is readonly [];\nexport function isEmpty(arr: readonly unknown[]): boolean {\n  return arr.length === 0;\n}\n","import { purry } from '../function/purry';\n\nfunction joinImplementation(arr: string[], separator: string): string {\n  return arr.join(separator);\n}\n\nexport function join(separator: string): (arr: string[]) => string;\nexport function join(arr: string[], separator: string): string;\nexport function join(...args: readonly unknown[]): unknown {\n  return purry(joinImplementation, args);\n}\n","import { EmptyArrayError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport type { ReadonlyNonEmptyArray } from '../types';\n\n/**\n *\n */\nexport function last<T>(arr: ReadonlyNonEmptyArray<T>): T;\nexport function last<T>(arr: readonly T[]): EmptyArrayError | T;\nexport function last<T>(arr: readonly T[]): EmptyArrayError | T {\n  if (arr.length === 0) {\n    return new EmptyArrayError('Arr.last() :: array is empty');\n  }\n  return arr[arr.length - 1]!;\n}\n\nfunction lastAssert<T>(arr: readonly T[]): T {\n  // @ts-expect-error\n  return orThrow(last)(arr);\n}\n\nlast.assert = lastAssert;\n","/**\n * Returns length of array\n * @param arr\n * @returns\n */\nexport function length(arr: readonly unknown[]): number {\n  return arr.length;\n}\n","import { purry } from '../function/purry';\n\nfunction mapImplementation<T, U>(\n  arr: readonly T[],\n  callbackfn: (value: T, index: number, array: readonly T[]) => U,\n): U[] {\n  return arr.map(callbackfn);\n}\n\nexport function map<T, U>(callbackfn: (value: T, index: number, array: readonly T[]) => U): (arr: T[]) => U[];\nexport function map<T, U>(data: T[], callbackfn: (value: T, index: number, array: readonly T[]) => U): U[];\nexport function map(...args: readonly unknown[]): unknown {\n  return purry(mapImplementation, args);\n}\n","/**\n * Arr.ofLength\n *\n * @throws {RangeError}\n */\nexport function ofLength<T = unknown>(arrayLength: number): T[] {\n  return Array(arrayLength) as T[];\n}\n","import { purry } from '../function/purry';\n\nfunction partitionImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): [T[], T[]] {\n  const len = arr.length;\n  const left: T[] = [];\n  const right: T[] = [];\n  for (let i = 0; i < len; i += 1) {\n    const value = arr[i]!;\n    if (predicate(value, i, arr)) {\n      left.push(value);\n    } else {\n      right.push(value);\n    }\n  }\n  return [left, right];\n}\n\nexport function partition<T, S extends T>(\n  predicate: (value: T, index: number, arr: readonly T[]) => value is S,\n): (data: readonly T[]) => [S[], T[]];\nexport function partition<T>(\n  predicate: (value: T, index: number, arr: readonly T[]) => boolean,\n): (data: readonly T[]) => [T[], T[]];\nexport function partition<T, S extends T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, arr: readonly T[]) => value is S,\n): [S[], T[]];\nexport function partition<T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, arr: readonly T[]) => boolean,\n): [T[], T[]];\nexport function partition(...args: readonly unknown[]): unknown {\n  return purry(partitionImplementation, args);\n}\n","import { EmptyArrayError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport type { ReadonlyNonEmptyArray } from '../types';\n\n/**\n * Array.pop\n */\nexport function pop<T>(arr: ReadonlyNonEmptyArray<T>): [T, T[]];\nexport function pop<T>(arr: readonly T[]): EmptyArrayError | [T, T[]];\nexport function pop<T>(arr: readonly T[]): EmptyArrayError | [T, T[]] {\n  if (arr.length === 0) {\n    return new EmptyArrayError('Arr.pop() :: array is empty');\n  }\n  const lastIndex = arr.length - 1;\n  const last = arr[lastIndex]!;\n  const tail = arr.slice(0, lastIndex);\n  return [last, tail];\n}\n\nfunction popAssert<T>(arr: readonly T[]): [T, T[]] {\n  // @ts-expect-error\n  return orThrow(pop)(arr);\n}\n\npop.assert = popAssert;\n","import { purry } from '../function/purry';\n\nfunction prependImplementation<T>(arr: readonly T[], other: readonly T[]): T[] {\n  return [...other, ...arr];\n}\n\nexport function prepend<T>(other: readonly T[]): (arr: readonly T[]) => T[];\nexport function prepend<T>(arr: readonly T[], other: readonly T[]): T[];\nexport function prepend(...args: readonly unknown[]): unknown {\n  return purry(prependImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction pushImplementation<T>(arr: readonly T[], value: T): T[] {\n  return [...arr, value];\n}\n\nexport function push<T>(value: T): (arr: readonly T[]) => T[];\nexport function push<T>(arr: readonly T[], value: T): T[];\nexport function push(...args: readonly unknown[]): unknown {\n  return purry(pushImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction reduceImplementation<T, U>(\n  arr: readonly T[],\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): U {\n  return arr.reduce(callbackFn, initialValue);\n}\n\nexport function reduce<T, U>(\n  arr: readonly T[],\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): U;\nexport function reduce<T, U>(\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): (arr: readonly T[]) => U;\nexport function reduce(...args: readonly unknown[]): unknown {\n  return purry(reduceImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction reduce1Implementation<T>(\n  arr: readonly T[],\n  callbackFn: (acc: T, value: T, index: number, array: readonly T[]) => T,\n): T {\n  return arr.reduce(callbackFn);\n}\n\nexport function reduce1<T>(\n  arr: readonly T[],\n  callbackFn: (acc: T, value: T, index: number, array: readonly T[]) => T,\n): T;\nexport function reduce1<T>(\n  callbackFn: (acc: T, value: T, index: number, array: readonly T[]) => T,\n): (arr: readonly T[]) => T;\nexport function reduce1(...args: readonly unknown[]): unknown {\n  return purry(reduce1Implementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction reduceRightImplementation<T, U>(\n  arr: readonly T[],\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): U {\n  return arr.reduceRight(callbackFn, initialValue);\n}\n\nexport function reduceRight<T, U>(\n  arr: readonly T[],\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): U;\nexport function reduceRight<T, U>(\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): (arr: readonly T[]) => U;\nexport function reduceRight(...args: readonly unknown[]): unknown {\n  return purry(reduceRightImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction reduceRight1Implementation<T>(\n  arr: readonly T[],\n  callbackFn: (acc: T, value: T, index: number, array: readonly T[]) => T,\n): T {\n  return arr.reduceRight(callbackFn);\n}\n\nexport function reduceRight1<T>(\n  arr: readonly T[],\n  callbackFn: (acc: T, value: T, index: number, array: readonly T[]) => T,\n): T;\nexport function reduceRight1<T>(\n  callbackFn: (acc: T, value: T, index: number, array: readonly T[]) => T,\n): (arr: readonly T[]) => T;\nexport function reduceRight1(...args: readonly unknown[]): unknown {\n  return purry(reduceRight1Implementation, args);\n}\n","/**\n * Returns an array excluding the first entry\n * @param arr\n * @returns\n */\nexport function rest<T>(arr: readonly T[]): T[] {\n  const [, ...tail] = arr;\n  return tail;\n}\n","import { purry } from '../function/purry';\n\nfunction reverseImplementation<T>(arr: readonly T[]): T[] {\n  return arr.toReversed();\n}\n\nexport function reverse(index: number): <T>(arr: readonly T[]) => T[];\nexport function reverse<T>(arr: readonly T[], index: number): T[];\nexport function reverse(...args: readonly unknown[]): unknown {\n  return purry(reverseImplementation, args);\n}\n","import { purry } from '../function';\n\nfunction scanImplementation<T, U>(\n  arr: T[],\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): U[] {\n  const len = arr.length;\n  const result = Array(len + 1) as U[];\n  let acc = initialValue;\n  result[0] = acc;\n  for (let index = 0; index < len; index += 1) {\n    acc = callbackFn(acc, arr[index]!, index, arr);\n    result[index + 1] = acc;\n  }\n  return result;\n}\n\nexport function scan<T, U>(\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): (arr: T[]) => U[];\nexport function scan<T, U>(\n  arr: T[],\n  callbackFn: (acc: U, value: T, index: number, array: readonly T[]) => U,\n  initialValue: U,\n): U[];\nexport function scan(...args: unknown[]): unknown {\n  return purry(scanImplementation, args);\n}\n","import { EmptyArrayError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport type { ReadonlyNonEmptyArray } from '../types';\n\n/**\n *\n */\nexport function shift<T>(arr: ReadonlyNonEmptyArray<T>): [T, T[]];\nexport function shift<T>(arr: readonly T[]): EmptyArrayError | [T, T[]] {\n  if (arr.length === 0) {\n    return new EmptyArrayError('Arr.shift() :: array is empty');\n  }\n  const [head, ...tail] = arr;\n  return [head!, tail];\n}\n\nfunction shiftAssert<T>(arr: readonly T[]): [T, T[]] {\n  // @ts-expect-error\n  return orThrow(shift)(arr);\n}\n\nshift.assert = shiftAssert;\n","export function shuffle<T>(arr: T[]): T[] {\n  const result = [...arr];\n  const len = result.length;\n  for (let i = 0; i < len; i += 1) {\n    const rand = i + Math.floor(Math.random() * (len - i));\n    const value = result[rand]!;\n    result[rand] = result[i]!;\n    result[i] = value;\n  }\n  return result;\n}\n","import { purry } from '../function/purry';\n\nfunction someImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): boolean {\n  return arr.some(predicate);\n}\n\nexport function some<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => T[];\nexport function some<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];\nexport function some(...args: readonly unknown[]): unknown {\n  return purry(someImplementation, args);\n}\n","import { purry } from '../function/purry';\nimport type { Order } from '../order/order.constants';\n\nfunction sortImplementation<T>(arr: T[], compareFn: (left: T, right: T) => Order): T[] {\n  return arr.toSorted(compareFn);\n}\n\nexport function sort<T>(compareFn: (left: T, right: T) => Order): (arr: T[]) => T[];\nexport function sort<T>(arr: T[], compareFn: (left: T, right: T) => Order): T[];\nexport function sort(...args: readonly unknown[]): unknown {\n  return purry(sortImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction sortByImplementation<T>(arr: T[], mapFn: (value: T) => Date | boolean | number | string): T[] {\n  return arr.toSorted((left, right) => {\n    const l = mapFn(left);\n    const r = mapFn(right);\n    if (l < r) return -1;\n    if (l > r) return 0;\n    return 0;\n  });\n}\n\nexport function sortBy<T>(mapFn: (value: T) => Date | boolean | number | string): (arr: T[]) => T[];\nexport function sortBy<T>(arr: T[], mapFn: (value: T) => Date | boolean | number | string): T[];\nexport function sortBy(...args: readonly unknown[]): unknown {\n  return purry(sortByImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction takeImplementation<T>(arr: readonly T[], limit: number): T[] {\n  if (limit < 1) {\n    throw new RangeError(`Arr.take() :: ${limit} must be a positive integer`);\n  }\n\n  return arr.slice(0, limit);\n}\n\n/**\n *\n * @throws {RangeError}\n */\nexport function take<T>(limit: number): (arr: readonly T[]) => T[];\nexport function take<T>(arr: readonly T[], limit: number): T[];\nexport function take(...args: readonly unknown[]): unknown {\n  return purry(takeImplementation, args);\n}\n","export function transpose<T>(arr: T[][]): T[][] {\n  // pre-populate result with empty arrays of max length of inners\n  const maxLen = arr.reduce((acc, inner) => Math.max(acc, inner.length), 0);\n  return Array(maxLen)\n    .fill(undefined)\n    .map((_, index) => arr.map(inner => inner[index]!));\n}\n","export function unique<T>(arr: readonly T[]): T[] {\n  if (arr.length === 0) {\n    return [];\n  }\n  return Array.from(new Set(arr));\n}\n","import { purry } from '../function/purry';\n\nfunction uniqueByImplementation<T>(arr: readonly T[], mapFn: (value: T) => unknown): T[] {\n  if (arr.length === 0) {\n    return [];\n  }\n  const map = new Map<unknown, T>();\n  arr.forEach((_, index) => {\n    const value = arr[index]!;\n    const key = mapFn(value);\n    if (!map.has(key)) {\n      map.set(key, value);\n    }\n  });\n  return Array.from(map.values());\n}\n\nexport function uniqueBy<T>(mapFn: (value: T) => unknown): (arr: T[]) => T[];\nexport function uniqueBy<T>(arr: T[], mapFn: (value: T) => unknown): T[];\nexport function uniqueBy(...args: unknown[]): unknown {\n  return purry(uniqueByImplementation, args);\n}\n","export function uniqueWith<T>(arr: readonly T[], isEqual: (left: T, right: T) => boolean): T[] {\n  if (arr.length === 0) {\n    return [];\n  }\n  return arr.filter((value, index) => {\n    const foundIndex = arr.find((otherValue, otherIndex) => index === otherIndex || isEqual(value, otherValue)) ?? -1; // logically this should never happen, but handle it to prevent runtime errors\n    // only keep if foundIndex is same as current index.\n    // Else it means that another entry was found to be isEqual further along in the iteration\n    return index === foundIndex;\n  });\n}\n","import { purry } from '../function/purry';\n\nfunction unshiftImplementation<T>(arr: readonly T[], value: T): T[] {\n  return [value, ...arr];\n}\n\n/**\n * Immutably inserts new elements at the start of an array. Returns the new array.\n */\nexport function unshift<T>(value: T): (arr: readonly T[]) => T[];\nexport function unshift<T>(arr: readonly T[], value: T): T[];\nexport function unshift(...args: readonly unknown[]): unknown {\n  return purry(unshiftImplementation, args);\n}\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction updateImplementation<T>(arr: readonly T[], index: number, fn: (valueR: T) => T): RangeError | T[] {\n  if (index >= arr.length || index < -arr.length) {\n    return new RangeError(`Arr.update() :: Invalid index : ${index}`);\n  }\n  const value = arr.at(index) as T;\n\n  const updatedValue = fn(value);\n\n  return arr.with(index, updatedValue);\n}\n\n/**\n *\n */\nexport function update<T>(index: number, fn: (value: T) => T): (arr: readonly T[]) => RangeError | T[];\nexport function update<T>(arr: readonly T[], index: number, fn: (value: T) => T): RangeError | T[];\nexport function update(...args: readonly unknown[]): unknown {\n  return purry(updateImplementation, args);\n}\n\nfunction updateAssert<T>(index: number, fn: (value: T) => T): (arr: readonly T[]) => T[];\nfunction updateAssert<T>(arr: readonly T[], index: number, fn: (value: T) => T): T[];\nfunction updateAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(updateImplementation), args);\n}\n\nupdate.assert = updateAssert;\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\n\nfunction windowImplementation<T>(arr: readonly T[], size: number): T[][] {\n  if (size < 1) {\n    throw new RangeError(`Arr.window() :: ${size} must be a positive integer`);\n  }\n\n  const limit = arr.length - (size - 1);\n\n  if (limit < 0) return [];\n\n  return Array(limit)\n    .fill(undefined)\n    .map((_, index) => arr.slice(index, index + size));\n}\n\n/**\n *\n * @throws {RangeError}\n */\nexport function window(size: number): <T>(arr: readonly T[]) => T[][];\nexport function window<T>(arr: readonly T[], size: number): T[][];\nexport function window(...args: unknown[]): unknown {\n  return purry(windowImplementation, args);\n}\n\nfunction windowAssert<T>(size: number): (arr: readonly T[]) => T[][];\nfunction windowAssert<T>(arr: readonly T[], size: number): T[][];\nfunction windowAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(windowImplementation), args);\n}\n\nwindow.assert = windowAssert;\n","import { purry } from '../function/purry';\n\nfunction zipImplementation<L, R>(arr: readonly L[], other: readonly R[]): [L, R][] {\n  return Array(Math.min(arr.length, other.length))\n    .fill(undefined)\n    .map<[L, R]>((_, index) => [arr[index]!, other[index]!] as const);\n}\n\nexport function zip<L, R>(other: readonly R[]): (arr: readonly L[]) => [L, R][];\nexport function zip<L, R>(arr: readonly L[], other: readonly R[]): [L, R][];\nexport function zip(...args: unknown[]): unknown {\n  return purry(zipImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction zipWithImplementation<L, R, U>(arr: readonly L[], other: readonly R[], fn: (l: L, R: R) => U): U[] {\n  return Array(Math.min(arr.length, other.length))\n    .fill(undefined)\n    .map<U>((_, index) => fn(arr[index]!, other[index]!));\n}\n\nexport function zipWith<L, R, U>(other: readonly R[], fn: (l: L, R: R) => U): (arr: readonly L[]) => U[];\nexport function zipWith<L, R, U>(arr: readonly L[], other: readonly R[], fn: (l: L, R: R) => U): U[];\nexport function zipWith(...args: unknown[]): unknown {\n  return purry(zipWithImplementation, args);\n}\n"],"mappings":"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"}

package/dist/errors-CJsLpYo9.d.cts

@@ -0,0 +1,25 @@
+//#region src/errors.d.ts
+declare class AppError extends Error {
+  constructor(...args: Parameters<ErrorConstructor>);
+}
+/**
+ * Indicates that null or undefined was passed to a function that does not support it
+ */
+/**
+ * Indicates that a calculation or operation resulted in Not-A-Number (NaN)
+ * where a valid number was required.
+ */
+declare class NaNError extends AppError {}
+/**
+ * Indicates that a requested element, item, or match was not found.
+ * Commonly used as a normalized, type-safe replacement for returning `-1`, `undefined`, or `null`.
+ */
+declare class NotFoundError extends AppError {}
+/**
+ * Indicates that an array operation was attempted on an empty array,
+ * but requires the array to contain at least one element.
+ */
+declare class EmptyArrayError extends AppError {}
+//#endregion
+export { NaNError as n, NotFoundError as r, EmptyArrayError as t };
+//# sourceMappingURL=errors-CJsLpYo9.d.cts.map

package/dist/errors-CJsLpYo9.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CJsLpYo9.d.cts","names":[],"sources":["../src/errors.ts"],"mappings":";cAAM,QAAA,SAAiB,KAAA;iBACN,IAAA,EAAM,UAAA,CAAW,gBAAA;AAAA;;;;;;;;cAerB,QAAA,SAAiB,QAAQ;;AAfY;AAelD;;cAMa,aAAA,SAAsB,QAAQ;AANL;AAMtC;;;AANsC,cAYzB,eAAA,SAAwB,QAAQ"}

package/dist/errors-CJsLpYo9.d.mts

@@ -0,0 +1,25 @@
+//#region src/errors.d.ts
+declare class AppError extends Error {
+  constructor(...args: Parameters<ErrorConstructor>);
+}
+/**
+ * Indicates that null or undefined was passed to a function that does not support it
+ */
+/**
+ * Indicates that a calculation or operation resulted in Not-A-Number (NaN)
+ * where a valid number was required.
+ */
+declare class NaNError extends AppError {}
+/**
+ * Indicates that a requested element, item, or match was not found.
+ * Commonly used as a normalized, type-safe replacement for returning `-1`, `undefined`, or `null`.
+ */
+declare class NotFoundError extends AppError {}
+/**
+ * Indicates that an array operation was attempted on an empty array,
+ * but requires the array to contain at least one element.
+ */
+declare class EmptyArrayError extends AppError {}
+//#endregion
+export { NaNError as n, NotFoundError as r, EmptyArrayError as t };
+//# sourceMappingURL=errors-CJsLpYo9.d.mts.map

package/dist/errors-CJsLpYo9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CJsLpYo9.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";cAAM,QAAA,SAAiB,KAAA;iBACN,IAAA,EAAM,UAAA,CAAW,gBAAA;AAAA;;;;;;;;cAerB,QAAA,SAAiB,QAAQ;;AAfY;AAelD;;cAMa,aAAA,SAAsB,QAAQ;AANL;AAMtC;;;AANsC,cAYzB,eAAA,SAAwB,QAAQ"}