@ts-fns/stdlib 0.2.1 → 0.3.0

package/dist/array/index.d.mts

@@ -86,8 +86,8 @@ declare function chunkAssert<T>(arr: readonly T[], size: number): T[][];
  * concat([3, 4])([1, 2]); // [1, 2, 3, 4]
  * ```
  */
-declare function concat<T>(other: readonly T[]): (arr: readonly T[]) => T;
-declare function concat<T>(arr: readonly T[], other: readonly T[]): T;
+declare function concat<T>(other: readonly T[]): (arr: readonly T[]) => T[];
+declare function concat<T>(arr: readonly T[], other: readonly T[]): T[];
 //#endregion
 //#region src/array/drop.d.ts
 /**
@@ -117,6 +117,21 @@ declare function every<T>(predicate: (value: T, index: number, array: readonly T
 declare function every<T, S extends T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => value is S): arr is S[];
 declare function every<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];
 //#endregion
+//#region src/array/filter.d.ts
+/**
+ * Keeps the elements that satisfy a predicate.
+ *
+ * @example
+ * ```ts
+ * filter([1, 2, 3, 4], n => n % 2 === 0); // [2, 4]
+ * filter(n => n > 2)([1, 2, 3, 4]); // [3, 4]
+ * ```
+ */
+declare function filter<T, S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S[];
+declare function filter<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+declare function filter<T, S extends T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => value is S): S[];
+declare function filter<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];
+//#endregion
 //#region src/array/find.d.ts
 /**
  * Returns the first element that satisfies a predicate.
@@ -135,11 +150,18 @@ declare function find<T, S extends T>(arr: readonly T[], predicate: (value: T, i
 declare function find<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): NotFoundError | T;
 declare namespace find {
   var assert: typeof findAssert;
+  var toNull: FindToNull;
 }
 declare function findAssert<T, S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S;
 declare function findAssert<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T;
 declare function findAssert<T, S extends T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => value is S): S;
 declare function findAssert<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T;
+type FindToNull = {
+  <T, S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S | null;
+  <T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T | null;
+  <T, S extends T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => value is S): S | null;
+  <T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T | null;
+};
 //#endregion
 //#region src/array/findIndex.d.ts
 /**
@@ -283,6 +305,25 @@ declare namespace insert {
 declare function insertAssert<T>(index: number, value: T): (arr: readonly T[]) => T[];
 declare function insertAssert<T>(arr: readonly T[], index: number, value: T): T[];
 //#endregion
+//#region src/array/includes.d.ts
+/**
+ * Returns whether an array contains a search element.
+ *
+ * @example
+ * ```ts
+ * includes([1, 2, 3], 2); // true
+ * includes(2)([1, 2, 3]); // true
+ * includes([1, 2, 3], 4); // false
+ * ```
+ */
+declare function includes<T>(searchElement: T): (arr: readonly T[]) => boolean;
+declare function includes<T>(arr: readonly T[], searchElement: T): boolean;
+declare namespace includes {
+  var fromIndex: typeof includesFromIndex;
+}
+declare function includesFromIndex<T>(searchElement: T, fromIndex: number): (arr: readonly T[]) => boolean;
+declare function includesFromIndex<T>(arr: readonly T[], searchElement: T, fromIndex: number): boolean;
+//#endregion
 //#region src/array/isEmpty.d.ts
 /**
  * Checks whether an array contains at least one element.
@@ -562,8 +603,8 @@ declare function shuffle<T>(arr: readonly T[]): T[];
  * some(n => n > 2)([1, 2, 3]); // true
  * ```
  */
-declare function some<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
-declare function some<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];
+declare function some<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => boolean;
+declare function some<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): boolean;
 //#endregion
 //#region src/array/sort.d.ts
 /**
@@ -731,5 +772,5 @@ declare function zip<L, R>(arr: readonly L[], other: readonly R[]): [L, R][];
 declare function zipWith<L, R, U>(other: readonly R[], fn: (l: L, R: R) => U): (arr: readonly L[]) => U[];
 declare function zipWith<L, R, U>(arr: readonly L[], other: readonly R[], fn: (l: L, R: R) => U): U[];
 //#endregion
-export { Ctor, at, 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 };
+export { Ctor, at, chunk, concat, drop, every, filter, find, findIndex, findLast, findLastIndex, first, flatMap, forEach, from, fromAsync, includes, 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.d.mts.map

package/dist/array/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","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"],"mappings":";;;;;;;;;cAMa,IAAA;EAAA;;;;;;;;;cAMA,SAAA;EAAA;;;;;;;cAMA,OAAA,GAAO,GAAA,UAAA,GAAA;;;;;cAMP,EAAA,SAAE,KAAA,EAAA,CAAA,OAAA,CAAA;;;;;cAMF,IAAA,EAAI,gBAAQ;;;;;;;;AAxBzB;;;;;;iBCgBgB,EAAA,IAAM,KAAA,YAAiB,GAAA,WAAc,CAAA,OAAQ,UAAA,GAAa,CAAA;AAAA,iBAC1D,EAAA,IAAM,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,UAAA,GAAa,CAAA;AAAA,kBAAtD,EAAA;EAAA,mBAAE,QAAA;AAAA;AAAA,iBAKT,QAAA,IAAY,KAAA,YAAiB,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBACpD,QAAA,IAAY,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,CAAC;;;;;;;;ADvBzD;;;;;iBEqCgB,KAAA,CAAM,IAAA,eAAmB,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBAChD,KAAA,IAAS,GAAA,WAAc,CAAA,IAAK,IAAA,WAAe,CAAC;AAAA,kBAA5C,KAAA;EAAA,mBAAK,WAAA;AAAA;AAAA,iBAKZ,WAAA,IAAe,IAAA,YAAgB,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBACtD,WAAA,IAAe,GAAA,WAAc,CAAA,IAAK,IAAA,WAAe,CAAC;;;;;;;;AF5C3D;;;;iBGSgB,MAAA,IAAU,KAAA,WAAgB,CAAA,MAAO,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACvD,MAAA,IAAU,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,CAAA,KAAM,CAAA;;;;;;;;AHVnE;;;;iBISgB,IAAA,IAAQ,CAAA,YAAa,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBAC5C,IAAA,IAAQ,GAAA,WAAc,CAAA,IAAK,CAAA,WAAY,CAAC;;;;;;;;AJVxD;;;;iBKYgB,KAAA,cAAmB,CAAA,EACjC,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,IACpE,GAAA,WAAc,CAAA,OAAQ,GAAA,IAAO,CAAA;AAAA,iBACjB,KAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACV,KAAA,cAAmB,CAAA,EACjC,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,GACrE,GAAA,IAAO,CAAA;AAAA,iBACM,KAAA,IAAS,GAAA,WAAc,CAAA,IAAK,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBAAkB,CAAA;;;;;;;ALtBnH;;;;;;;iBMuBgB,IAAA,cAAkB,CAAA,EAChC,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,IACpE,GAAA,WAAc,CAAA,OAAQ,aAAA,GAAgB,CAAA;AAAA,iBAC1B,IAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,aAAA,GAAgB,CAAA;AAAA,iBAC1B,IAAA,cAAkB,CAAA,EAChC,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,GACrE,aAAA,GAAgB,CAAA;AAAA,iBACH,IAAA,IACd,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBACpD,aAAA,GAAgB,CAAA;AAAA,kBAHH,IAAA;EAAA,mBAAI,UAAA;AAAA;AAAA,iBAQX,UAAA,cAAwB,CAAA,EAC/B,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,IACpE,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACjB,UAAA,IAAc,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBAAmB,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBAC5G,UAAA,cAAwB,CAAA,EAC/B,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,GACrE,CAAA;AAAA,iBACM,UAAA,IAAc,GAAA,WAAc,CAAA,IAAK,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBAAkB,CAAA;;;;;;;ANjDjH;;;;;;;iBOoBgB,SAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,aAAA;AAAA,iBACV,SAAA,IACd,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBACpD,aAAA;AAAA,kBAHa,SAAA;EAAA,mBAAS,eAAA;AAAA;AAAA,iBAQhB,eAAA,IACP,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA;AAAA,iBACT,eAAA,IACP,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA;;;;;;;APpCvD;;;;;;;iBQuBgB,QAAA,cAAsB,CAAA,EACpC,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,IACpE,GAAA,WAAc,CAAA,OAAQ,aAAA,GAAgB,CAAA;AAAA,iBAC1B,QAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,aAAA,GAAgB,CAAA;AAAA,iBAC1B,QAAA,cAAsB,CAAA,EACpC,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,KAAA,IAAS,CAAA,GACrE,aAAA,GAAgB,CAAA;AAAA,iBACH,QAAA,IACd,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBACpD,aAAA,GAAgB,CAAA;AAAA,kBAHH,QAAA;EAAA,mBAAQ,cAAA;AAAA;AAAA,iBAQf,cAAA,IACP,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACjB,cAAA,IAAkB,GAAA,WAAc,CAAA,IAAK,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBAAkB,CAAA;;;;;;;AR5CrH;;;;;;;iBSoBgB,aAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,aAAA;AAAA,iBACV,aAAA,IACd,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBACpD,aAAA;AAAA,kBAHa,aAAA;EAAA,mBAAa,mBAAA;AAAA;AAAA,iBAQpB,mBAAA,IACP,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA;AAAA,iBACT,mBAAA,IACP,GAAA,WAAc,CAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA;;;;;;ATpCvD;;;;;;;iBUQgB,KAAA,IAAS,GAAA,EAAK,qBAAA,CAAsB,CAAA,IAAK,CAAA;AAAA,iBACzC,KAAA,IAAS,GAAA,WAAc,CAAA,KAAM,eAAA,GAAkB,CAAA;AAAA,kBAA/C,KAAA;EAAA,mBAAK,WAAA;AAAA;AAAA,iBAQZ,WAAA,IAAe,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;AVjB7C;;;;iBWYgB,OAAA,OACd,UAAA,GAAa,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,YAAa,CAAA,MACzE,GAAA,EAAK,CAAA,OAAQ,CAAA;AAAA,iBACD,OAAA,OAAc,GAAA,EAAK,CAAA,IAAK,UAAA,GAAa,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,KAAM,CAAA;;;;;;;;AXf5G;;;;iBYUgB,OAAA,IAAW,UAAA,GAAa,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,eAAgB,GAAA,EAAK,CAAA,OAAQ,CAAA;AAAA,iBAC9F,OAAA,IAAW,GAAA,EAAK,CAAA,IAAK,UAAA,GAAa,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,cAAe,CAAA;;;;;;;;AZX1G;;;;iBaKgB,IAAA,IAAQ,GAAA,WAAc,CAAA,KAAM,CAAC;AAAA,kBAA7B,IAAA;EAAA,mBAAI,UAAA;AAAA;AAAA,iBAIX,UAAA,IAAc,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;AbT5C;;;;;;iBcgBgB,MAAA,IAAU,KAAA,UAAe,KAAA,EAAO,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBAC3D,MAAA,IAAU,GAAA,WAAc,CAAA,IAAK,KAAA,UAAe,KAAA,EAAO,CAAA,GAAI,CAAA;AAAA,kBAAvD,MAAA;EAAA,mBAAM,YAAA;AAAA;AAAA,iBAKb,YAAA,IAAgB,KAAA,UAAe,KAAA,EAAO,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACjE,YAAA,IAAgB,GAAA,WAAc,CAAA,IAAK,KAAA,UAAe,KAAA,EAAO,CAAA,GAAI,CAAA;;;;;;;AdvBtE;;;;;iBeKgB,UAAA,IAAc,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,aAAA,CAAc,CAAA;AAAA,iBAClD,UAAA,IAAc,KAAA,WAAgB,CAAA,KAAM,KAAA,IAAS,qBAAA,CAAsB,CAAA;;;;;;;;;;iBAenE,OAAA,IAAW,KAAA,EAAO,CAAC,KAAK,KAAA;AAAA,iBACxB,OAAA,IAAW,KAAA,WAAgB,CAAC,KAAK,KAAA;;;;;;;;AftBjD;;;;iBgBSgB,IAAA,CAAK,SAAA,YAAqB,GAAa;AAAA,iBACvC,IAAA,CAAK,GAAA,YAAe,SAAiB;;;;;;AhBVrD;;;;;;;iBiBQgB,IAAA,IAAQ,GAAA,EAAK,qBAAA,CAAsB,CAAA,IAAK,CAAA;AAAA,iBACxC,IAAA,IAAQ,GAAA,WAAc,CAAA,KAAM,eAAA,GAAkB,CAAA;AAAA,kBAA9C,IAAA;EAAA,mBAAI,UAAA;AAAA;AAAA,iBAQX,UAAA,IAAc,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;AjBjB5C;;;;iBkBGgB,MAAA,CAAO,GAAuB;;;;;;;;AlBH9C;;;;iBmBYgB,GAAA,OAAU,UAAA,GAAa,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACnG,GAAA,OAAU,IAAA,WAAe,CAAA,IAAK,UAAA,GAAa,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,GAAI,CAAA;;;;;;;;AnBbhH;;;;iBoBGgB,QAAA,cAAsB,WAAA,WAAsB,CAAC;;;;;;;;ApBH7D;;;;;iBqBwBgB,SAAA,cAAuB,CAAA,EACrC,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,GAAA,WAAc,CAAA,OAAQ,KAAA,IAAS,CAAA,IAClE,IAAA,WAAe,CAAA,QAAS,CAAA,IAAK,CAAA;AAAA,iBACjB,SAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,GAAA,WAAc,CAAA,kBACjD,IAAA,WAAe,CAAA,QAAS,CAAA,IAAK,CAAA;AAAA,iBACjB,SAAA,cAAuB,CAAA,EACrC,IAAA,WAAe,CAAA,IACf,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,GAAA,WAAc,CAAA,OAAQ,KAAA,IAAS,CAAA,IAClE,CAAA,IAAK,CAAA;AAAA,iBACO,SAAA,IACd,IAAA,WAAe,CAAA,IACf,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,GAAA,WAAc,CAAA,kBACjD,CAAA,IAAK,CAAA;;;;;;ArBrCT;;;;;;;iBsBQgB,GAAA,IAAO,GAAA,EAAK,qBAAA,CAAsB,CAAA,KAAM,CAAA,EAAG,CAAA;AAAA,iBAC3C,GAAA,IAAO,GAAA,WAAc,CAAA,KAAM,eAAA,IAAmB,CAAA,EAAG,CAAA;AAAA,kBAAjD,GAAA;EAAA,mBAAG,SAAA;AAAA;AAAA,iBAWV,SAAA,IAAa,GAAA,WAAc,CAAA,MAAO,CAAA,EAAG,CAAA;;;;;;;;AtBpB9C;;;;iBuBSgB,OAAA,IAAW,KAAA,WAAgB,CAAA,MAAO,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACxD,OAAA,IAAW,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,CAAA,KAAM,CAAA;;;;;;;;AvBVpE;;;;iBwBSgB,IAAA,IAAQ,KAAA,EAAO,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBAC1C,IAAA,IAAQ,GAAA,WAAc,CAAA,IAAK,KAAA,EAAO,CAAA,GAAI,CAAA;;;;;;;;AxBVtD;;;;iByBagB,MAAA,OACd,GAAA,WAAc,CAAA,IACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,EACtE,YAAA,EAAc,CAAA,GACb,CAAA;AAAA,iBACa,MAAA,OACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,EACtE,YAAA,EAAc,CAAA,IACZ,GAAA,WAAc,CAAA,OAAQ,CAAA;;;;;;;;AzBrB1B;;;;iB0BYgB,OAAA,IACd,GAAA,WAAc,CAAA,IACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,GACrE,CAAA;AAAA,iBACa,OAAA,IACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,IACpE,GAAA,WAAc,CAAA,OAAQ,CAAA;;;;;;;;A1BlB1B;;;;iB2BagB,WAAA,OACd,GAAA,WAAc,CAAA,IACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,EACtE,YAAA,EAAc,CAAA,GACb,CAAA;AAAA,iBACa,WAAA,OACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,EACtE,YAAA,EAAc,CAAA,IACZ,GAAA,WAAc,CAAA,OAAQ,CAAA;;;;;;;;A3BrB1B;;;;iB4BYgB,YAAA,IACd,GAAA,WAAc,CAAA,IACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,GACrE,CAAA;AAAA,iBACa,YAAA,IACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,IACpE,GAAA,WAAc,CAAA,OAAQ,CAAA;;;;;;;;A5BlB1B;;;;iB6BGgB,IAAA,IAAQ,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;A7BH7C;;;iB8BEgB,OAAA,IAAW,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;A9BFhD;;;;;iB+BsBgB,IAAA,OACd,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,EACtE,YAAA,EAAc,CAAA,IACZ,GAAA,EAAK,CAAA,OAAQ,CAAA;AAAA,iBACD,IAAA,OACd,GAAA,EAAK,CAAA,IACL,UAAA,GAAa,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,OAAQ,CAAA,EACtE,YAAA,EAAc,CAAA,GACb,CAAA;;;;;;;A/B9BH;;;;;;iBgCQgB,KAAA,IAAS,GAAA,EAAK,qBAAA,CAAsB,CAAA,KAAM,CAAA,EAAG,CAAA;AAAA,kBAA7C,KAAA;EAAA,mBAAK,WAAA;AAAA;AAAA,iBASZ,WAAA,IAAe,GAAA,WAAc,CAAA,MAAO,CAAA,EAAG,CAAA;;;;;;;;AhCjBhD;;;iBiCEgB,OAAA,IAAW,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;AjCFhD;;;;iBkCYgB,IAAA,IACd,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,kBACnD,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACV,IAAA,IAAQ,GAAA,WAAc,CAAA,IAAK,SAAA,GAAY,KAAA,EAAO,CAAA,EAAG,KAAA,UAAe,KAAA,WAAgB,CAAA,iBAAkB,CAAA;;;;;;;AlCflH;;;;;iBmCUgB,IAAA,IAAQ,SAAA,GAAY,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,GAAA,EAAK,CAAA,OAAQ,CAAA;AAAA,iBAChE,IAAA,IAAQ,GAAA,EAAK,CAAA,IAAK,SAAA,GAAY,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,KAAM,KAAA,GAAQ,CAAA;;;;;;;;AnCX5E;;;;iBoCegB,MAAA,IAAU,KAAA,GAAQ,KAAA,EAAO,CAAA,KAAM,IAAA,gCAAoC,GAAA,EAAK,CAAA,OAAQ,CAAA;AAAA,iBAChF,MAAA,IAAU,GAAA,EAAK,CAAA,IAAK,KAAA,GAAQ,KAAA,EAAO,CAAA,KAAM,IAAA,+BAAmC,CAAA;;;;;;;;ApChB5F;;;;iBqCagB,IAAA,IAAQ,KAAA,YAAiB,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBAChD,IAAA,IAAQ,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,CAAC;;;;;;;;ArCd5D;;;iBsCEgB,SAAA,IAAa,GAAA,EAAK,CAAA,OAAQ,CAAC;;;;;;;;AtCF3C;;;;iBuCGgB,MAAA,IAAU,GAAA,WAAc,CAAA,KAAM,CAAC;;;;;;;;AvCH/C;;;;;iBwCqBgB,QAAA,IAAY,KAAA,GAAQ,KAAA,EAAO,CAAA,gBAAiB,GAAA,EAAK,CAAA,OAAQ,CAAA;AAAA,iBACzD,QAAA,IAAY,GAAA,EAAK,CAAA,IAAK,KAAA,GAAQ,KAAA,EAAO,CAAA,eAAgB,CAAA;;;;;;;;AxCtBrE;;;;;iByCIgB,UAAA,IAAc,GAAA,WAAc,CAAA,IAAK,OAAA,GAAU,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,eAAgB,CAAA;;;;;;;;AzCJ3F;;;;iB0CSgB,OAAA,IAAW,KAAA,EAAO,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBAC7C,OAAA,IAAW,GAAA,WAAc,CAAA,IAAK,KAAA,EAAO,CAAA,GAAI,CAAA;;;;;;;;A1CVzD;;;;;iB2CkBgB,MAAA,IAAU,KAAA,UAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,UAAA,GAAa,CAAA;AAAA,iBACnF,MAAA,IAAU,GAAA,WAAc,CAAA,IAAK,KAAA,UAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,UAAA,GAAa,CAAA;AAAA,kBAA/E,MAAA;EAAA,mBAAM,YAAA;AAAA;AAAA,iBAKb,YAAA,IAAgB,KAAA,UAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBAC5E,YAAA,IAAgB,GAAA,WAAc,CAAA,IAAK,KAAA,UAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,CAAA;;;;;;;;A3CzBjF;;;;;iB4CqBgB,MAAA,CAAO,IAAA,eAAmB,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBACjD,MAAA,IAAU,GAAA,WAAc,CAAA,IAAK,IAAA,WAAe,CAAC;AAAA,kBAA7C,MAAA;EAAA,mBAAM,YAAA;AAAA;AAAA,iBAKb,YAAA,IAAgB,IAAA,YAAgB,GAAA,WAAc,CAAA,OAAQ,CAAC;AAAA,iBACvD,YAAA,IAAgB,GAAA,WAAc,CAAA,IAAK,IAAA,WAAe,CAAC;;;;;;;;A5C5B5D;;;;iB6CWgB,GAAA,OAAU,KAAA,WAAgB,CAAA,MAAO,GAAA,WAAc,CAAA,QAAS,CAAA,EAAG,CAAA;AAAA,iBAC3D,GAAA,OAAU,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,CAAA,MAAO,CAAA,EAAG,CAAA;;;;;;;;A7CZvE;;;;iB8CWgB,OAAA,UAAiB,KAAA,WAAgB,CAAA,IAAK,EAAA,GAAK,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,CAAA,IAAK,GAAA,WAAc,CAAA,OAAQ,CAAA;AAAA,iBACrF,OAAA,UAAiB,GAAA,WAAc,CAAA,IAAK,KAAA,WAAgB,CAAA,IAAK,EAAA,GAAK,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,CAAA,GAAI,CAAA"}
+{"version":3,"file":"index.d.mts","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/filter.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/includes.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"],"mappings":"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"}

package/dist/array/index.mjs

@@ -1,4 +1,4 @@
-import { p as orThrow } from "../function-CYHPhQCQ.mjs";
+import { m as orThrow } from "../function-DI38qfqp.mjs";
 import { t as purry } from "../purry-DXnhXie9.mjs";
 import { i as NotFoundError, t as EmptyArrayError } from "../errors-Dw1kitu_.mjs";
 //#region src/array/_globalAliases.ts
@@ -104,6 +104,14 @@ function every(...args) {
 	return purry(everyImplementation, args);
 }
 //#endregion
+//#region src/array/filter.ts
+function filterImplementation(arr, predicate) {
+	return arr.filter(predicate);
+}
+function filter(...args) {
+	return purry(filterImplementation, args);
+}
+//#endregion
 //#region src/array/find.ts
 function findImplementation(arr, predicate) {
 	const foundIndex = arr.findIndex(predicate);
@@ -126,6 +134,24 @@ function findAssert(...args) {
 * ```
 */
 find.assert = findAssert;
+function findToNullImplementation(arr, predicate) {
+	const result = findImplementation(arr, predicate);
+	if (result instanceof NotFoundError) return null;
+	return result;
+}
+/**
+* Instead of returning an error, it returns `null` when no element matches the predicate.
+*
+* @example
+* ```ts
+* find.toNull([1, 2, 3], n => n > 1); // 2
+* find.toNull(n => n > 10)([1, 2, 3]); // null
+* ```
+*/
+const findToNull = (...args) => {
+	return purry(findToNullImplementation, args);
+};
+find.toNull = findToNull;
 //#endregion
 //#region src/array/findIndex.ts
 function findIndexImplementation(arr, predicate) {
@@ -284,6 +310,31 @@ function insertAssert(...args) {
 */
 insert.assert = insertAssert;
 //#endregion
+//#region src/array/includes.ts
+function includesImplementation(arr, searchElement) {
+	return arr.includes(searchElement);
+}
+function includes(...args) {
+	return purry(includesImplementation, args);
+}
+function includesFromIndexImplementation(arr, searchElement, fromIndex) {
+	return arr.includes(searchElement, fromIndex);
+}
+function includesFromIndex(...args) {
+	return purry(includesFromIndexImplementation, args);
+}
+/**
+* Returns whether an array contains a search element at or after an index.
+*
+* @example
+* ```ts
+* includes.fromIndex([1, 2, 3, 4], 4, 2); // true
+* includes.fromIndex(4, 2)([1, 2, 3, 4]); // true
+* includes.fromIndex([1, 2, 3], 1, 2); // false
+* ```
+*/
+includes.fromIndex = includesFromIndex;
+//#endregion
 //#region src/array/isEmpty.ts
 function isNotEmpty(arr) {
 	return arr.length > 0;
@@ -696,6 +747,6 @@ function zipWith(...args) {
 	return purry(zipWithImplementation, args);
 }
 //#endregion
-export { Ctor, at, 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 };
+export { Ctor, at, chunk, concat, drop, every, filter, find, findIndex, findLast, findLastIndex, first, flatMap, forEach, from, fromAsync, includes, 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

@@ -1 +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":["/* eslint-disable @typescript-eslint/prefer-destructuring */\n\n/**\n * Creates an array from an iterable or array-like object.\n * @function\n */\nexport const from = Array.from;\n\n/**\n * Creates an array from an async iterable.\n * @function\n */\nexport const fromAsync = Array.fromAsync;\n\n/**\n * Checks whether a value is an array.\n * @function\n */\nexport const isArray = Array.isArray;\n\n/**\n * Creates an array containing the given values.\n * @function\n */\nexport const of = Array.of;\n\n/**\n * Alias of the built-in array constructor. `new Array() === new Arr.Ctor()\n * @function\n */\nexport const Ctor = Array;\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\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 * Gets an element from an array by index, including negative indices from the end.\n * Returns a range error when the array is empty or the index is out of bounds.\n *\n * @example\n * ```ts\n * at([1, 2, 3], 1); // 2\n * at(-1)([1, 2, 3]); // 3\n * at([1, 2, 3], 3); // RangeError\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\nfunction atAssert<T>(index: number): (arr: readonly T[]) => T;\nfunction atAssert<T>(arr: readonly T[], index: number): T;\nfunction atAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(atImplementation), args);\n}\n\n/**\n * Like `at`, but throws when the index is out of bounds.\n *\n * @example\n * ```ts\n * at.assert([1, 2, 3], 1); // 2\n * at.assert(-1)([1, 2, 3]); // 3\n * at.assert([1, 2, 3], 3); // throws RangeError\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 * Splits an array into consecutive groups of the given size.\n * The last chunk may contain fewer elements when the length is not evenly divisible.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk(2)([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]\n * ```\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\n/**\n * Like `chunk`, but throws when the size is not a positive integer.\n *\n * @example\n * ```ts\n * chunk.assert([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk.assert(0)([1, 2, 3]); // throws RangeError\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\n/**\n * Concatenates two arrays without mutating either input.\n *\n * @example\n * ```ts\n * concat([1, 2], [3, 4]); // [1, 2, 3, 4]\n * concat([3, 4])([1, 2]); // [1, 2, 3, 4]\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\n/**\n * Drops the first `n` elements from an array.\n *\n * @example\n * ```ts\n * drop([1, 2, 3, 4], 2); // [3, 4]\n * drop(2)([1, 2, 3, 4]); // [3, 4]\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\n/**\n * Tests whether every element satisfies a predicate.\n *\n * @example\n * ```ts\n * every([2, 4, 6], n => n % 2 === 0); // true\n * every(n => n > 0)([1, 2, 3]); // true\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\n/**\n * Returns the first element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * find([1, 2, 3], n => n > 1); // 2\n * find(n => n > 1)([1, 2, 3]); // 2\n * find([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `find`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * find.assert([1, 2, 3], n => n > 1); // 2\n * find.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\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\n/**\n * Returns the index of the first element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * findIndex([1, 2, 3], n => n > 1); // 1\n * findIndex(n => n > 1)([1, 2, 3]); // 1\n * findIndex([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `findIndex`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * findIndex.assert([1, 2, 3], n => n > 1); // 1\n * findIndex.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\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\n/**\n * Returns the last element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * findLast([1, 2, 3, 2], n => n === 2); // 2\n * findLast(n => n === 2)([1, 2, 3, 2]); // 2\n * findLast([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `findLast`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * findLast.assert([1, 2, 3, 2], n => n === 2); // 2\n * findLast.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\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\n/**\n * Returns the index of the last element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * findLastIndex([1, 2, 3, 2], n => n === 2); // 3\n * findLastIndex(n => n === 2)([1, 2, 3, 2]); // 3\n * findLastIndex([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `findLastIndex`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * findLastIndex.assert([1, 2, 3, 2], n => n === 2); // 3\n * findLastIndex.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\n * ```\n */\nfindLastIndex.assert = findLastIndexAssert;\n","import { EmptyArrayError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport type { ReadonlyNonEmptyArray } from '../types';\n\n/**\n * Returns the first element of an array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * first([1, 2, 3]); // 1\n * first([]); // EmptyArrayError\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\n/**\n * Like `first`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * first.assert([1, 2, 3]); // 1\n * first.assert([]); // throws EmptyArrayError\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\n/**\n * Maps each element to an array and flattens the result by one level.\n *\n * @example\n * ```ts\n * flatMap([1, 2, 3], n => [n, n * 10]); // [1, 10, 2, 20, 3, 30]\n * flatMap(n => [n, n * 10])([1, 2, 3]); // [1, 10, 2, 20, 3, 30]\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\n/**\n * Runs a callback for each element and returns the original array.\n *\n * @example\n * ```ts\n * forEach([1, 2, 3], n => console.log(n)); // [1, 2, 3]\n * forEach(n => console.log(n))([1, 2, 3]); // [1, 2, 3]\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 * Returns all elements except the last.\n *\n * @example\n * ```ts\n * init([1, 2, 3]); // [1, 2]\n * init([1]); // []\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\n/**\n * Like `init`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * init.assert([1, 2, 3]); // [1, 2]\n * init.assert([]); // throws EmptyArrayError\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 * Inserts or replaces the element at the given index without mutating the original array.\n * Named `insert` because `with` is a reserved word.\n * Returns a range error when the index is invalid.\n *\n * @example\n * ```ts\n * insert([1, 2, 3], 1, 9); // [1, 9, 3]\n * insert(1, 9)([1, 2, 3]); // [1, 9, 3]\n * ```\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\n/**\n * Like `insert`, but throws when the index is invalid.\n *\n * @example\n * ```ts\n * insert.assert([1, 2, 3], 1, 9); // [1, 9, 3]\n * insert.assert(10, 9)([1, 2, 3]); // throws RangeError\n * ```\n */\ninsert.assert = insertAssert;\n","import type { NonEmptyArray, ReadonlyNonEmptyArray } from '../types';\n\n/**\n * Checks whether an array contains at least one element.\n *\n * @example\n * ```ts\n * isNotEmpty([1, 2]); // true\n * isNotEmpty([]); // false\n * ```\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/**\n * Checks whether an array has no elements.\n *\n * @example\n * ```ts\n * isEmpty([]); // true\n * isEmpty([1]); // false\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\n/**\n * Joins string array elements with a separator.\n *\n * @example\n * ```ts\n * join(['a', 'b', 'c'], '-'); // 'a-b-c'\n * join('-')(['a', 'b', 'c']); // 'a-b-c'\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 * Returns the last element of an array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * last([1, 2, 3]); // 3\n * last([]); // EmptyArrayError\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\n/**\n * Like `last`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * last.assert([1, 2, 3]); // 3\n * last.assert([]); // throws EmptyArrayError\n * ```\n */\nlast.assert = lastAssert;\n","/**\n * Returns the number of elements in an array.\n *\n * @example\n * ```ts\n * length([1, 2, 3]); // 3\n * length([]); // 0\n * ```\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\n/**\n * Transforms each element with a callback.\n *\n * @example\n * ```ts\n * map([1, 2, 3], n => n * 2); // [2, 4, 6]\n * map(n => n * 2)([1, 2, 3]); // [2, 4, 6]\n * ```\n */\nexport function map<T, U>(callbackfn: (value: T, index: number, array: readonly T[]) => U): (arr: readonly T[]) => U[];\nexport function map<T, U>(data: readonly 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 * Creates a sparse array with the given length.\n *\n * @example\n * ```ts\n * ofLength(3); // [empty × 3]\n * ofLength<string>(2); // [empty × 2]\n * ```\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\n/**\n * Splits an array into two groups based on a predicate.\n * The first group contains matching elements; the second contains the rest.\n *\n * @example\n * ```ts\n * partition([1, 2, 3, 4], n => n % 2 === 0); // [[2, 4], [1, 3]]\n * partition(n => n % 2 === 0)([1, 2, 3, 4]); // [[2, 4], [1, 3]]\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 * Removes and returns the last element along with the remaining array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * pop([1, 2, 3]); // [3, [1, 2]]\n * pop([]); // EmptyArrayError\n * ```\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\n/**\n * Like `pop`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * pop.assert([1, 2, 3]); // [3, [1, 2]]\n * pop.assert([]); // throws EmptyArrayError\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\n/**\n * Prepends the elements of one array to another without mutating either input.\n *\n * @example\n * ```ts\n * prepend([3, 4], [1, 2]); // [1, 2, 3, 4]\n * prepend([1, 2])([3, 4]); // [1, 2, 3, 4]\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\n/**\n * Appends a value to an array without mutating the original.\n *\n * @example\n * ```ts\n * push([1, 2], 3); // [1, 2, 3]\n * push(3)([1, 2]); // [1, 2, 3]\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\n/**\n * Reduces an array to a single value using an initial accumulator.\n *\n * @example\n * ```ts\n * reduce([1, 2, 3], (acc, n) => acc + n, 0); // 6\n * reduce((acc, n) => acc + n, 0)([1, 2, 3]); // 6\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\n/**\n * Reduces a non-empty array to a single value using the first element as the initial accumulator.\n *\n * @example\n * ```ts\n * reduce1([1, 2, 3], (acc, n) => acc + n); // 6\n * reduce1((acc, n) => acc + n)([1, 2, 3]); // 6\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\n/**\n * Reduces an array from the right using an initial accumulator.\n *\n * @example\n * ```ts\n * reduceRight([1, 2, 3], (acc, n) => acc - n, 0); // -6\n * reduceRight((acc, n) => acc - n, 0)([1, 2, 3]); // -6\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\n/**\n * Reduces a non-empty array from the right using the last element as the initial accumulator.\n *\n * @example\n * ```ts\n * reduceRight1([1, 2, 3], (acc, n) => acc - n); // 0\n * reduceRight1((acc, n) => acc - n)([1, 2, 3]); // 0\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 all elements except the first.\n *\n * @example\n * ```ts\n * rest([1, 2, 3]); // [2, 3]\n * rest([1]); // []\n * ```\n */\nexport function rest<T>(arr: readonly T[]): T[] {\n  const [, ...tail] = arr;\n  return tail;\n}\n","/**\n * Returns a reversed copy of an array without mutating the original.\n *\n * @example\n * ```ts\n * reverse([1, 2, 3]); // [3, 2, 1]\n * ```\n */\nexport function reverse<T>(arr: readonly T[]): T[] {\n  return arr.toReversed();\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\n/**\n * Returns the intermediate accumulator values produced while reducing an array.\n * The first element is the initial value; each subsequent element is the accumulator after processing one more item.\n *\n * @example\n * ```ts\n * scan([1, 2, 3], (acc, n) => acc + n, 0); // [0, 1, 3, 6]\n * scan((acc, n) => acc + n, 0)([1, 2, 3]); // [0, 1, 3, 6]\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 * Removes and returns the first element along with the remaining array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * shift([1, 2, 3]); // [1, [2, 3]]\n * shift([]); // EmptyArrayError\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\n/**\n * Like `shift`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * shift.assert([1, 2, 3]); // [1, [2, 3]]\n * shift.assert([]); // throws EmptyArrayError\n * ```\n */\nshift.assert = shiftAssert;\n","/**\n * Returns a shuffled copy of an array using the Fisher-Yates algorithm.\n *\n * @example\n * ```ts\n * shuffle([1, 2, 3, 4]); // e.g. [3, 1, 4, 2]\n * ```\n */\nexport function shuffle<T>(arr: readonly 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\n/**\n * Tests whether at least one element satisfies a predicate.\n *\n * @example\n * ```ts\n * some([1, 2, 3], n => n > 2); // true\n * some(n => n > 2)([1, 2, 3]); // true\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\n/**\n * Returns a sorted copy of an array using a comparison function.\n *\n * @example\n * ```ts\n * sort([3, 1, 2], (a, b) => a - b); // [1, 2, 3]\n * sort((a, b) => a - b)([3, 1, 2]); // [1, 2, 3]\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\n/**\n * Returns a sorted copy of an array by mapping each element to a comparable value first.\n *\n * @example\n * ```ts\n * sortBy([{ n: 3 }, { n: 1 }], x => x.n); // [{ n: 1 }, { n: 3 }]\n * sortBy(x => x.n)([{ n: 3 }, { n: 1 }]); // [{ n: 1 }, { n: 3 }]\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 * Returns the first `limit` elements from an array.\n *\n * @example\n * ```ts\n * take([1, 2, 3, 4], 2); // [1, 2]\n * take(3)([1, 2, 3, 4]); // [1, 2, 3]\n * ```\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","/**\n * Transposes a matrix so rows become columns and columns become rows.\n *\n * @example\n * ```ts\n * transpose([[1, 2], [3, 4], [5, 6]]); // [[1, 3, 5], [2, 4, 6]]\n * ```\n */\nexport 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","/**\n * Returns a copy of an array with duplicate values removed.\n *\n * @example\n * ```ts\n * unique([1, 2, 2, 3]); // [1, 2, 3]\n * unique([]); // []\n * ```\n */\nexport 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\n/**\n * Returns a copy of an array with duplicates removed by a derived key.\n * Keeps the first occurrence for each key.\n *\n * @example\n * ```ts\n * uniqueBy([{ id: 1 }, { id: 2 }, { id: 1 }], x => x.id); // [{ id: 1 }, { id: 2 }]\n * uniqueBy(x => x.id)([{ id: 1 }, { id: 2 }, { id: 1 }]); // [{ id: 1 }, { id: 2 }]\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","/**\n * Returns a copy of an array with duplicates removed using a custom equality function.\n * Keeps the first occurrence of each equivalent value.\n *\n * @example\n * ```ts\n * uniqueWith([1, 1.0, 2], (a, b) => a === b); // [1, 2]\n * uniqueWith([], (a, b) => a === b); // []\n * ```\n */\nexport 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 * Prepends a value to an array without mutating the original.\n *\n * @example\n * ```ts\n * unshift([1, 2], 0); // [0, 1, 2]\n * unshift(0)([1, 2]); // [0, 1, 2]\n * ```\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 * Replaces the element at the given index using a callback without mutating the original array.\n * Returns a range error when the index is out of bounds.\n *\n * @example\n * ```ts\n * update([1, 2, 3], 1, n => n * 10); // [1, 20, 3]\n * update(1, n => n * 10)([1, 2, 3]); // [1, 20, 3]\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\n/**\n * Like `update`, but throws when the index is out of bounds.\n *\n * @example\n * ```ts\n * update.assert([1, 2, 3], 1, n => n * 10); // [1, 20, 3]\n * update.assert(10, n => n)([1, 2, 3]); // throws RangeError\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 * Creates a sliding window of consecutive elements with the given size.\n * Returns an empty array when the window size is larger than the input.\n *\n * @example\n * ```ts\n * window([1, 2, 3, 4], 2); // [[1, 2], [2, 3], [3, 4]]\n * window(3)([1, 2, 3, 4]); // [[1, 2, 3], [2, 3, 4]]\n * ```\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\n/**\n * Like `window`, but throws when the size is not a positive integer.\n *\n * @example\n * ```ts\n * window.assert([1, 2, 3, 4], 2); // [[1, 2], [2, 3], [3, 4]]\n * window.assert(0)([1, 2, 3]); // throws RangeError\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\n/**\n * Pairs elements from two arrays up to the length of the shorter one.\n *\n * @example\n * ```ts\n * zip([1, 2, 3], ['a', 'b']); // [[1, 'a'], [2, 'b']]\n * zip(['a', 'b'])([1, 2, 3]); // [[1, 'a'], [2, 'b']]\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\n/**\n * Combines two arrays element-wise using a callback, up to the length of the shorter one.\n *\n * @example\n * ```ts\n * zipWith([1, 2, 3], [10, 20], (a, b) => a + b); // [11, 22]\n * zipWith([10, 20], (a, b) => a + b)([1, 2, 3]); // [11, 22]\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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"}
+{"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/filter.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/includes.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":["/* eslint-disable @typescript-eslint/prefer-destructuring */\n\n/**\n * Creates an array from an iterable or array-like object.\n * @function\n */\nexport const from = Array.from;\n\n/**\n * Creates an array from an async iterable.\n * @function\n */\nexport const fromAsync = Array.fromAsync;\n\n/**\n * Checks whether a value is an array.\n * @function\n */\nexport const isArray = Array.isArray;\n\n/**\n * Creates an array containing the given values.\n * @function\n */\nexport const of = Array.of;\n\n/**\n * Alias of the built-in array constructor. `new Array() === new Arr.Ctor()\n * @function\n */\nexport const Ctor = Array;\n","import { orThrow } from '../function/orThrow';\nimport { purry } from '../function/purry';\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 * Gets an element from an array by index, including negative indices from the end.\n * Returns a range error when the array is empty or the index is out of bounds.\n *\n * @example\n * ```ts\n * at([1, 2, 3], 1); // 2\n * at(-1)([1, 2, 3]); // 3\n * at([1, 2, 3], 3); // RangeError\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\nfunction atAssert<T>(index: number): (arr: readonly T[]) => T;\nfunction atAssert<T>(arr: readonly T[], index: number): T;\nfunction atAssert(...args: readonly unknown[]): unknown {\n  return purry(orThrow(atImplementation), args);\n}\n\n/**\n * Like `at`, but throws when the index is out of bounds.\n *\n * @example\n * ```ts\n * at.assert([1, 2, 3], 1); // 2\n * at.assert(-1)([1, 2, 3]); // 3\n * at.assert([1, 2, 3], 3); // throws RangeError\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 * Splits an array into consecutive groups of the given size.\n * The last chunk may contain fewer elements when the length is not evenly divisible.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk(2)([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]\n * ```\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\n/**\n * Like `chunk`, but throws when the size is not a positive integer.\n *\n * @example\n * ```ts\n * chunk.assert([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * chunk.assert(0)([1, 2, 3]); // throws RangeError\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\n/**\n * Concatenates two arrays without mutating either input.\n *\n * @example\n * ```ts\n * concat([1, 2], [3, 4]); // [1, 2, 3, 4]\n * concat([3, 4])([1, 2]); // [1, 2, 3, 4]\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\n/**\n * Drops the first `n` elements from an array.\n *\n * @example\n * ```ts\n * drop([1, 2, 3, 4], 2); // [3, 4]\n * drop(2)([1, 2, 3, 4]); // [3, 4]\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\n/**\n * Tests whether every element satisfies a predicate.\n *\n * @example\n * ```ts\n * every([2, 4, 6], n => n % 2 === 0); // true\n * every(n => n > 0)([1, 2, 3]); // true\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 { purry } from '../function/purry';\n\nfunction filterImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): T[] {\n  return arr.filter(predicate);\n}\n\n/**\n * Keeps the elements that satisfy a predicate.\n *\n * @example\n * ```ts\n * filter([1, 2, 3, 4], n => n % 2 === 0); // [2, 4]\n * filter(n => n > 2)([1, 2, 3, 4]); // [3, 4]\n * ```\n */\nexport function filter<T, S extends T>(\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): (arr: readonly T[]) => S[];\nexport function filter<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => T[];\nexport function filter<T, S extends T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => value is S,\n): S[];\nexport function filter<T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];\nexport function filter(...args: readonly unknown[]): unknown {\n  return purry(filterImplementation, 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\n/**\n * Returns the first element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * find([1, 2, 3], n => n > 1); // 2\n * find(n => n > 1)([1, 2, 3]); // 2\n * find([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `find`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * find.assert([1, 2, 3], n => n > 1); // 2\n * find.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\n * ```\n */\nfind.assert = findAssert;\n\nfunction findToNullImplementation<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): T | null {\n  const result = findImplementation(arr, predicate);\n  if (result instanceof NotFoundError) {\n    return null;\n  }\n  return result;\n}\n\ntype FindToNull = {\n  <T, S extends T>(\n    predicate: (value: T, index: number, array: readonly T[]) => value is S,\n  ): (arr: readonly T[]) => S | null;\n  <T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T | null;\n  <T, S extends T>(\n    arr: readonly T[],\n    predicate: (value: T, index: number, array: readonly T[]) => value is S,\n  ): S | null;\n  <T>(arr: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T | null;\n};\n\n/**\n * Instead of returning an error, it returns `null` when no element matches the predicate.\n *\n * @example\n * ```ts\n * find.toNull([1, 2, 3], n => n > 1); // 2\n * find.toNull(n => n > 10)([1, 2, 3]); // null\n * ```\n */\nconst findToNull: FindToNull = (...args: readonly any[]): any => {\n  return purry(findToNullImplementation, args);\n};\n\n// export function findToNull<T, S extends T>(\n//   predicate: (value: T, index: number, array: readonly T[]) => value is S,\n// ): (arr: readonly T[]) => S | null;\n// export function findToNull<T>(\n//   predicate: (value: T, index: number, array: readonly T[]) => boolean,\n// ): (arr: readonly T[]) => T | null;\n// export function findToNull<T, S extends T>(\n//   arr: readonly T[],\n//   predicate: (value: T, index: number, array: readonly T[]) => value is S,\n// ): S | null;\n// export function findToNull<T>(\n//   arr: readonly T[],\n//   predicate: (value: T, index: number, array: readonly T[]) => boolean,\n// ): T | null;\n// export function findToNull(...args: readonly unknown[]): unknown {\n//   return purry(findToNullImplementation, args);\n// }\n\nfind.toNull = findToNull;\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\n/**\n * Returns the index of the first element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * findIndex([1, 2, 3], n => n > 1); // 1\n * findIndex(n => n > 1)([1, 2, 3]); // 1\n * findIndex([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `findIndex`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * findIndex.assert([1, 2, 3], n => n > 1); // 1\n * findIndex.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\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\n/**\n * Returns the last element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * findLast([1, 2, 3, 2], n => n === 2); // 2\n * findLast(n => n === 2)([1, 2, 3, 2]); // 2\n * findLast([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `findLast`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * findLast.assert([1, 2, 3, 2], n => n === 2); // 2\n * findLast.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\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\n/**\n * Returns the index of the last element that satisfies a predicate.\n * Returns a not-found error when no element matches.\n *\n * @example\n * ```ts\n * findLastIndex([1, 2, 3, 2], n => n === 2); // 3\n * findLastIndex(n => n === 2)([1, 2, 3, 2]); // 3\n * findLastIndex([1, 2, 3], n => n > 10); // NotFoundError\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\n/**\n * Like `findLastIndex`, but throws when no element matches the predicate.\n *\n * @example\n * ```ts\n * findLastIndex.assert([1, 2, 3, 2], n => n === 2); // 3\n * findLastIndex.assert(n => n > 10)([1, 2, 3]); // throws NotFoundError\n * ```\n */\nfindLastIndex.assert = findLastIndexAssert;\n","import { EmptyArrayError } from '../errors';\nimport { orThrow } from '../function/orThrow';\nimport type { ReadonlyNonEmptyArray } from '../types';\n\n/**\n * Returns the first element of an array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * first([1, 2, 3]); // 1\n * first([]); // EmptyArrayError\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\n/**\n * Like `first`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * first.assert([1, 2, 3]); // 1\n * first.assert([]); // throws EmptyArrayError\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\n/**\n * Maps each element to an array and flattens the result by one level.\n *\n * @example\n * ```ts\n * flatMap([1, 2, 3], n => [n, n * 10]); // [1, 10, 2, 20, 3, 30]\n * flatMap(n => [n, n * 10])([1, 2, 3]); // [1, 10, 2, 20, 3, 30]\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\n/**\n * Runs a callback for each element and returns the original array.\n *\n * @example\n * ```ts\n * forEach([1, 2, 3], n => console.log(n)); // [1, 2, 3]\n * forEach(n => console.log(n))([1, 2, 3]); // [1, 2, 3]\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 * Returns all elements except the last.\n *\n * @example\n * ```ts\n * init([1, 2, 3]); // [1, 2]\n * init([1]); // []\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\n/**\n * Like `init`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * init.assert([1, 2, 3]); // [1, 2]\n * init.assert([]); // throws EmptyArrayError\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 * Inserts or replaces the element at the given index without mutating the original array.\n * Named `insert` because `with` is a reserved word.\n * Returns a range error when the index is invalid.\n *\n * @example\n * ```ts\n * insert([1, 2, 3], 1, 9); // [1, 9, 3]\n * insert(1, 9)([1, 2, 3]); // [1, 9, 3]\n * ```\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\n/**\n * Like `insert`, but throws when the index is invalid.\n *\n * @example\n * ```ts\n * insert.assert([1, 2, 3], 1, 9); // [1, 9, 3]\n * insert.assert(10, 9)([1, 2, 3]); // throws RangeError\n * ```\n */\ninsert.assert = insertAssert;\n","import { purry } from '../function/purry';\n\nfunction includesImplementation<T>(arr: readonly T[], searchElement: T): boolean {\n  return arr.includes(searchElement);\n}\n\n/**\n * Returns whether an array contains a search element.\n *\n * @example\n * ```ts\n * includes([1, 2, 3], 2); // true\n * includes(2)([1, 2, 3]); // true\n * includes([1, 2, 3], 4); // false\n * ```\n */\nexport function includes<T>(searchElement: T): (arr: readonly T[]) => boolean;\nexport function includes<T>(arr: readonly T[], searchElement: T): boolean;\nexport function includes(...args: unknown[]): unknown {\n  return purry(includesImplementation, args);\n}\n\nfunction includesFromIndexImplementation<T>(arr: readonly T[], searchElement: T, fromIndex: number): boolean {\n  return arr.includes(searchElement, fromIndex);\n}\n\nfunction includesFromIndex<T>(searchElement: T, fromIndex: number): (arr: readonly T[]) => boolean;\nfunction includesFromIndex<T>(arr: readonly T[], searchElement: T, fromIndex: number): boolean;\nfunction includesFromIndex(...args: unknown[]): unknown {\n  return purry(includesFromIndexImplementation, args);\n}\n\n/**\n * Returns whether an array contains a search element at or after an index.\n *\n * @example\n * ```ts\n * includes.fromIndex([1, 2, 3, 4], 4, 2); // true\n * includes.fromIndex(4, 2)([1, 2, 3, 4]); // true\n * includes.fromIndex([1, 2, 3], 1, 2); // false\n * ```\n */\nincludes.fromIndex = includesFromIndex;\n","import type { NonEmptyArray, ReadonlyNonEmptyArray } from '../types';\n\n/**\n * Checks whether an array contains at least one element.\n *\n * @example\n * ```ts\n * isNotEmpty([1, 2]); // true\n * isNotEmpty([]); // false\n * ```\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/**\n * Checks whether an array has no elements.\n *\n * @example\n * ```ts\n * isEmpty([]); // true\n * isEmpty([1]); // false\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\n/**\n * Joins string array elements with a separator.\n *\n * @example\n * ```ts\n * join(['a', 'b', 'c'], '-'); // 'a-b-c'\n * join('-')(['a', 'b', 'c']); // 'a-b-c'\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 * Returns the last element of an array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * last([1, 2, 3]); // 3\n * last([]); // EmptyArrayError\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\n/**\n * Like `last`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * last.assert([1, 2, 3]); // 3\n * last.assert([]); // throws EmptyArrayError\n * ```\n */\nlast.assert = lastAssert;\n","/**\n * Returns the number of elements in an array.\n *\n * @example\n * ```ts\n * length([1, 2, 3]); // 3\n * length([]); // 0\n * ```\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\n/**\n * Transforms each element with a callback.\n *\n * @example\n * ```ts\n * map([1, 2, 3], n => n * 2); // [2, 4, 6]\n * map(n => n * 2)([1, 2, 3]); // [2, 4, 6]\n * ```\n */\nexport function map<T, U>(callbackfn: (value: T, index: number, array: readonly T[]) => U): (arr: readonly T[]) => U[];\nexport function map<T, U>(data: readonly 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 * Creates a sparse array with the given length.\n *\n * @example\n * ```ts\n * ofLength(3); // [empty × 3]\n * ofLength<string>(2); // [empty × 2]\n * ```\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\n/**\n * Splits an array into two groups based on a predicate.\n * The first group contains matching elements; the second contains the rest.\n *\n * @example\n * ```ts\n * partition([1, 2, 3, 4], n => n % 2 === 0); // [[2, 4], [1, 3]]\n * partition(n => n % 2 === 0)([1, 2, 3, 4]); // [[2, 4], [1, 3]]\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 * Removes and returns the last element along with the remaining array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * pop([1, 2, 3]); // [3, [1, 2]]\n * pop([]); // EmptyArrayError\n * ```\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\n/**\n * Like `pop`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * pop.assert([1, 2, 3]); // [3, [1, 2]]\n * pop.assert([]); // throws EmptyArrayError\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\n/**\n * Prepends the elements of one array to another without mutating either input.\n *\n * @example\n * ```ts\n * prepend([3, 4], [1, 2]); // [1, 2, 3, 4]\n * prepend([1, 2])([3, 4]); // [1, 2, 3, 4]\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\n/**\n * Appends a value to an array without mutating the original.\n *\n * @example\n * ```ts\n * push([1, 2], 3); // [1, 2, 3]\n * push(3)([1, 2]); // [1, 2, 3]\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\n/**\n * Reduces an array to a single value using an initial accumulator.\n *\n * @example\n * ```ts\n * reduce([1, 2, 3], (acc, n) => acc + n, 0); // 6\n * reduce((acc, n) => acc + n, 0)([1, 2, 3]); // 6\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\n/**\n * Reduces a non-empty array to a single value using the first element as the initial accumulator.\n *\n * @example\n * ```ts\n * reduce1([1, 2, 3], (acc, n) => acc + n); // 6\n * reduce1((acc, n) => acc + n)([1, 2, 3]); // 6\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\n/**\n * Reduces an array from the right using an initial accumulator.\n *\n * @example\n * ```ts\n * reduceRight([1, 2, 3], (acc, n) => acc - n, 0); // -6\n * reduceRight((acc, n) => acc - n, 0)([1, 2, 3]); // -6\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\n/**\n * Reduces a non-empty array from the right using the last element as the initial accumulator.\n *\n * @example\n * ```ts\n * reduceRight1([1, 2, 3], (acc, n) => acc - n); // 0\n * reduceRight1((acc, n) => acc - n)([1, 2, 3]); // 0\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 all elements except the first.\n *\n * @example\n * ```ts\n * rest([1, 2, 3]); // [2, 3]\n * rest([1]); // []\n * ```\n */\nexport function rest<T>(arr: readonly T[]): T[] {\n  const [, ...tail] = arr;\n  return tail;\n}\n","/**\n * Returns a reversed copy of an array without mutating the original.\n *\n * @example\n * ```ts\n * reverse([1, 2, 3]); // [3, 2, 1]\n * ```\n */\nexport function reverse<T>(arr: readonly T[]): T[] {\n  return arr.toReversed();\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\n/**\n * Returns the intermediate accumulator values produced while reducing an array.\n * The first element is the initial value; each subsequent element is the accumulator after processing one more item.\n *\n * @example\n * ```ts\n * scan([1, 2, 3], (acc, n) => acc + n, 0); // [0, 1, 3, 6]\n * scan((acc, n) => acc + n, 0)([1, 2, 3]); // [0, 1, 3, 6]\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 * Removes and returns the first element along with the remaining array.\n * Returns an empty-array error when the array has no elements.\n *\n * @example\n * ```ts\n * shift([1, 2, 3]); // [1, [2, 3]]\n * shift([]); // EmptyArrayError\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\n/**\n * Like `shift`, but throws when the array is empty.\n *\n * @example\n * ```ts\n * shift.assert([1, 2, 3]); // [1, [2, 3]]\n * shift.assert([]); // throws EmptyArrayError\n * ```\n */\nshift.assert = shiftAssert;\n","/**\n * Returns a shuffled copy of an array using the Fisher-Yates algorithm.\n *\n * @example\n * ```ts\n * shuffle([1, 2, 3, 4]); // e.g. [3, 1, 4, 2]\n * ```\n */\nexport function shuffle<T>(arr: readonly 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\n/**\n * Tests whether at least one element satisfies a predicate.\n *\n * @example\n * ```ts\n * some([1, 2, 3], n => n > 2); // true\n * some(n => n > 2)([1, 2, 3]); // true\n * ```\n */\nexport function some<T>(\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): (arr: readonly T[]) => boolean;\nexport function some<T>(\n  arr: readonly T[],\n  predicate: (value: T, index: number, array: readonly T[]) => boolean,\n): boolean;\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\n/**\n * Returns a sorted copy of an array using a comparison function.\n *\n * @example\n * ```ts\n * sort([3, 1, 2], (a, b) => a - b); // [1, 2, 3]\n * sort((a, b) => a - b)([3, 1, 2]); // [1, 2, 3]\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\n/**\n * Returns a sorted copy of an array by mapping each element to a comparable value first.\n *\n * @example\n * ```ts\n * sortBy([{ n: 3 }, { n: 1 }], x => x.n); // [{ n: 1 }, { n: 3 }]\n * sortBy(x => x.n)([{ n: 3 }, { n: 1 }]); // [{ n: 1 }, { n: 3 }]\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 * Returns the first `limit` elements from an array.\n *\n * @example\n * ```ts\n * take([1, 2, 3, 4], 2); // [1, 2]\n * take(3)([1, 2, 3, 4]); // [1, 2, 3]\n * ```\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","/**\n * Transposes a matrix so rows become columns and columns become rows.\n *\n * @example\n * ```ts\n * transpose([[1, 2], [3, 4], [5, 6]]); // [[1, 3, 5], [2, 4, 6]]\n * ```\n */\nexport 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","/**\n * Returns a copy of an array with duplicate values removed.\n *\n * @example\n * ```ts\n * unique([1, 2, 2, 3]); // [1, 2, 3]\n * unique([]); // []\n * ```\n */\nexport 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\n/**\n * Returns a copy of an array with duplicates removed by a derived key.\n * Keeps the first occurrence for each key.\n *\n * @example\n * ```ts\n * uniqueBy([{ id: 1 }, { id: 2 }, { id: 1 }], x => x.id); // [{ id: 1 }, { id: 2 }]\n * uniqueBy(x => x.id)([{ id: 1 }, { id: 2 }, { id: 1 }]); // [{ id: 1 }, { id: 2 }]\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","/**\n * Returns a copy of an array with duplicates removed using a custom equality function.\n * Keeps the first occurrence of each equivalent value.\n *\n * @example\n * ```ts\n * uniqueWith([1, 1.0, 2], (a, b) => a === b); // [1, 2]\n * uniqueWith([], (a, b) => a === b); // []\n * ```\n */\nexport 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 * Prepends a value to an array without mutating the original.\n *\n * @example\n * ```ts\n * unshift([1, 2], 0); // [0, 1, 2]\n * unshift(0)([1, 2]); // [0, 1, 2]\n * ```\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 * Replaces the element at the given index using a callback without mutating the original array.\n * Returns a range error when the index is out of bounds.\n *\n * @example\n * ```ts\n * update([1, 2, 3], 1, n => n * 10); // [1, 20, 3]\n * update(1, n => n * 10)([1, 2, 3]); // [1, 20, 3]\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\n/**\n * Like `update`, but throws when the index is out of bounds.\n *\n * @example\n * ```ts\n * update.assert([1, 2, 3], 1, n => n * 10); // [1, 20, 3]\n * update.assert(10, n => n)([1, 2, 3]); // throws RangeError\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 * Creates a sliding window of consecutive elements with the given size.\n * Returns an empty array when the window size is larger than the input.\n *\n * @example\n * ```ts\n * window([1, 2, 3, 4], 2); // [[1, 2], [2, 3], [3, 4]]\n * window(3)([1, 2, 3, 4]); // [[1, 2, 3], [2, 3, 4]]\n * ```\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\n/**\n * Like `window`, but throws when the size is not a positive integer.\n *\n * @example\n * ```ts\n * window.assert([1, 2, 3, 4], 2); // [[1, 2], [2, 3], [3, 4]]\n * window.assert(0)([1, 2, 3]); // throws RangeError\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\n/**\n * Pairs elements from two arrays up to the length of the shorter one.\n *\n * @example\n * ```ts\n * zip([1, 2, 3], ['a', 'b']); // [[1, 'a'], [2, 'b']]\n * zip(['a', 'b'])([1, 2, 3]); // [[1, 'a'], [2, 'b']]\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\n/**\n * Combines two arrays element-wise using a callback, up to the length of the shorter one.\n *\n * @example\n * ```ts\n * zipWith([1, 2, 3], [10, 20], (a, b) => a + b); // [11, 22]\n * zipWith([10, 20], (a, b) => a + b)([1, 2, 3]); // [11, 22]\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/function/index.cjs

@@ -1,16 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_function = require("../function-DYPifnmg.cjs");
+const require_function = require("../function-Dn9QtmOy.cjs");
 const require_purry = require("../purry-Dqp_F64t.cjs");
 exports.always = require_function.always;
 exports.compose = require_function.compose;
-exports.composed = require_function.composed;
+exports.createCompose = require_function.createCompose;
+exports.createPipe = require_function.createPipe;
 exports.identity = require_function.identity;
 exports.memoizeOne = require_function.memoizeOne;
 exports.memoizeOneImplementation = require_function.memoizeOneImplementation;
 exports.noop = require_function.noop;
 exports.orThrow = require_function.orThrow;
 exports.pipe = require_function.pipe;
-exports.piped = require_function.piped;
 exports.purry = require_purry.purry;
 exports.tap = require_function.tap;
 exports.unless = require_function.unless;