@pithos/core 2.0.0

package/dist/arkhe/array/toggle.js

@@ -0,0 +1,29 @@
+/**
+ * Toggles the presence of an element in an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The source array.
+ * @param element - The element to toggle.
+ * @returns A new array with the element added or removed.
+ * @since 2.0.0
+ *
+ * @note Uses strict equality (===). Only the first occurrence is removed.
+ *
+ * @performance O(n) time & space, uses indexOf and filter/spread operations.
+ *
+ * @example
+ * ```typescript
+ * toggle([1, 2, 3], 2);
+ * // => [1, 3]
+ *
+ * toggle([1, 2, 3], 4);
+ * // => [1, 2, 3, 4]
+ * ```
+ */
+export function toggle(array, element) {
+    const index = array.indexOf(element);
+    return index === -1
+        ? [...array, element]
+        : array.filter((_, i) => i !== index);
+}
+//# sourceMappingURL=toggle.js.map

package/dist/arkhe/array/toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.js","sourceRoot":"","sources":["../../../src/arkhe/array/toggle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,MAAM,CAAI,KAAmB,EAAE,OAAU;IACvD,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,OAAO,KAAK,KAAK,CAAC,CAAC;QACjB,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;QACrB,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC;AAC1C,CAAC"}

package/dist/arkhe/array/union-by.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Creates an array of unique values from multiple arrays, using an iteratee for comparison.
+ *
+ * @template T - The type of elements in the arrays.
+ * @template Key - The type of the comparison key.
+ * @param arrays - An array of arrays to combine.
+ * @param iteratee - A function that produces the key for each element.
+ * @returns A new array with unique elements based on the iteratee key.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n) where n = total elements across all arrays — Set provides O(1) lookups.
+ *
+ * @example
+ * ```typescript
+ * unionBy(
+ *   [[{ id: 1 }, { id: 2 }], [{ id: 1 }, { id: 3 }]],
+ *   (item) => item.id
+ * );
+ * // => [{ id: 1 }, { id: 2 }, { id: 3 }]
+ *
+ * unionBy([[1.1, 2.5], [2.2, 3.1]], Math.floor);
+ * // => [1.1, 2.5, 3.1]
+ * ```
+ */
+export declare function unionBy<T, Key>(arrays: readonly (readonly T[])[], iteratee: (item: T) => Key): T[];
+//# sourceMappingURL=union-by.d.ts.map

package/dist/arkhe/array/union-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-by.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/union-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAC5B,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,EACjC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,GACzB,CAAC,EAAE,CAkBL"}

package/dist/arkhe/array/union-by.js

@@ -0,0 +1,44 @@
+/**
+ * Creates an array of unique values from multiple arrays, using an iteratee for comparison.
+ *
+ * @template T - The type of elements in the arrays.
+ * @template Key - The type of the comparison key.
+ * @param arrays - An array of arrays to combine.
+ * @param iteratee - A function that produces the key for each element.
+ * @returns A new array with unique elements based on the iteratee key.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n) where n = total elements across all arrays — Set provides O(1) lookups.
+ *
+ * @example
+ * ```typescript
+ * unionBy(
+ *   [[{ id: 1 }, { id: 2 }], [{ id: 1 }, { id: 3 }]],
+ *   (item) => item.id
+ * );
+ * // => [{ id: 1 }, { id: 2 }, { id: 3 }]
+ *
+ * unionBy([[1.1, 2.5], [2.2, 3.1]], Math.floor);
+ * // => [1.1, 2.5, 3.1]
+ * ```
+ */
+export function unionBy(arrays, iteratee) {
+    // Stryker disable next-line ConditionalExpression: equivalent mutant, loop on empty arrays returns []
+    if (arrays.length === 0)
+        return [];
+    const result = [];
+    const seen = new Set();
+    for (const array of arrays) {
+        for (const item of array) {
+            const key = iteratee(item);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=union-by.js.map

package/dist/arkhe/array/union-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-by.js","sourceRoot":"","sources":["../../../src/arkhe/array/union-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,OAAO,CACrB,MAAiC,EACjC,QAA0B;IAE1B,sGAAsG;IACtG,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEnC,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,MAAM,IAAI,GAAG,IAAI,GAAG,EAAO,CAAC;IAE5B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACd,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/union-with.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Creates an array of unique values from all given arrays using a comparator function.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param arrays - The arrays to combine.
+ * @param comparator - The function invoked to compare elements.
+ * @returns A new array with unique elements.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n²) — custom comparators cannot leverage Set optimization.
+ *
+ * @example
+ * ```typescript
+ * const objects = [
+ *   [{ x: 1, y: 2 }, { x: 2, y: 1 }],
+ *   [{ x: 1, y: 2 }, { x: 3, y: 4 }]
+ * ];
+ *
+ * unionWith(objects, (a, b) => a.x === b.x && a.y === b.y);
+ * // => [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 3, y: 4 }]
+ * ```
+ */
+export declare function unionWith<T>(arrays: readonly (readonly T[])[], comparator: (a: T, b: T) => boolean): T[];
+//# sourceMappingURL=union-with.d.ts.map

package/dist/arkhe/array/union-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-with.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/union-with.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,EACjC,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAClC,CAAC,EAAE,CAgBL"}

package/dist/arkhe/array/union-with.js

@@ -0,0 +1,40 @@
+/**
+ * Creates an array of unique values from all given arrays using a comparator function.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param arrays - The arrays to combine.
+ * @param comparator - The function invoked to compare elements.
+ * @returns A new array with unique elements.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n²) — custom comparators cannot leverage Set optimization.
+ *
+ * @example
+ * ```typescript
+ * const objects = [
+ *   [{ x: 1, y: 2 }, { x: 2, y: 1 }],
+ *   [{ x: 1, y: 2 }, { x: 3, y: 4 }]
+ * ];
+ *
+ * unionWith(objects, (a, b) => a.x === b.x && a.y === b.y);
+ * // => [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 3, y: 4 }]
+ * ```
+ */
+export function unionWith(arrays, comparator) {
+    // Stryker disable next-line ConditionalExpression: Early return optimization - empty arrays loop produces identical empty result
+    if (arrays.length === 0)
+        return [];
+    const result = [];
+    for (const array of arrays) {
+        for (const item of array) {
+            const isDuplicate = result.some((existing) => comparator(existing, item));
+            if (!isDuplicate) {
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=union-with.js.map

package/dist/arkhe/array/union-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-with.js","sourceRoot":"","sources":["../../../src/arkhe/array/union-with.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,SAAS,CACvB,MAAiC,EACjC,UAAmC;IAEnC,iIAAiI;IACjI,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEnC,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;YAC1E,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/union.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates an array of unique values from all given arrays using SameValueZero for equality.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param arrays - The arrays to combine.
+ * @returns A new array with unique elements.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n) — uses Set for constant-time lookups.
+ *
+ * @example
+ * ```typescript
+ * union([[1, 2], [2, 3], [3, 4]]);
+ * // => [1, 2, 3, 4]
+ *
+ * union([['a', 'b'], ['b', 'c']]);
+ * // => ['a', 'b', 'c']
+ * ```
+ */
+export declare function union<T>(arrays: readonly (readonly T[])[]): T[];
+//# sourceMappingURL=union.d.ts.map

package/dist/arkhe/array/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/union.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAiB/D"}

package/dist/arkhe/array/union.js

@@ -0,0 +1,38 @@
+/**
+ * Creates an array of unique values from all given arrays using SameValueZero for equality.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param arrays - The arrays to combine.
+ * @returns A new array with unique elements.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n) — uses Set for constant-time lookups.
+ *
+ * @example
+ * ```typescript
+ * union([[1, 2], [2, 3], [3, 4]]);
+ * // => [1, 2, 3, 4]
+ *
+ * union([['a', 'b'], ['b', 'c']]);
+ * // => ['a', 'b', 'c']
+ * ```
+ */
+export function union(arrays) {
+    // Stryker disable next-line ConditionalExpression: equivalent mutant, loop on empty arrays returns []
+    if (arrays.length === 0)
+        return [];
+    const result = [];
+    const seen = new Set();
+    for (const array of arrays) {
+        for (const item of array) {
+            if (!seen.has(item)) {
+                seen.add(item);
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=union.js.map

package/dist/arkhe/array/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../../src/arkhe/array/union.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,KAAK,CAAI,MAAiC;IACxD,sGAAsG;IACtG,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEnC,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,MAAM,IAAI,GAAG,IAAI,GAAG,EAAK,CAAC;IAE1B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/uniq-by.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Creates a duplicate-free version of an array using an iteratee for comparison.
+ *
+ * @template T - The type of elements in the array.
+ * @template Key - The type of the comparison key.
+ * @param array - The array to inspect.
+ * @param iteratee - A function that produces the key for each element.
+ * @returns A new array with unique elements based on the iteratee key.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n) — uses Set for constant-time lookups.
+ *
+ * @example
+ * ```typescript
+ * uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * uniqBy(
+ *   [{ id: 1, name: 'a' }, { id: 2, name: 'b' }, { id: 1, name: 'c' }],
+ *   item => item.id
+ * );
+ * // => [{ id: 1, name: 'a' }, { id: 2, name: 'b' }]
+ * ```
+ */
+export declare function uniqBy<T, Key>(array: readonly T[], iteratee: (item: T) => Key): T[];
+//# sourceMappingURL=uniq-by.d.ts.map

package/dist/arkhe/array/uniq-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq-by.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/uniq-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAC3B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,GACzB,CAAC,EAAE,CAaL"}

package/dist/arkhe/array/uniq-by.js

@@ -0,0 +1,39 @@
+/**
+ * Creates a duplicate-free version of an array using an iteratee for comparison.
+ *
+ * @template T - The type of elements in the array.
+ * @template Key - The type of the comparison key.
+ * @param array - The array to inspect.
+ * @param iteratee - A function that produces the key for each element.
+ * @returns A new array with unique elements based on the iteratee key.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n) — uses Set for constant-time lookups.
+ *
+ * @example
+ * ```typescript
+ * uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * uniqBy(
+ *   [{ id: 1, name: 'a' }, { id: 2, name: 'b' }, { id: 1, name: 'c' }],
+ *   item => item.id
+ * );
+ * // => [{ id: 1, name: 'a' }, { id: 2, name: 'b' }]
+ * ```
+ */
+export function uniqBy(array, iteratee) {
+    const result = [];
+    const seen = new Set();
+    for (const item of array) {
+        const key = iteratee(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(item);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=uniq-by.js.map

package/dist/arkhe/array/uniq-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq-by.js","sourceRoot":"","sources":["../../../src/arkhe/array/uniq-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,MAAM,CACpB,KAAmB,EACnB,QAA0B;IAE1B,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,MAAM,IAAI,GAAG,IAAI,GAAG,EAAO,CAAC;IAE5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/uniq-with.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a duplicate-free version of an array using a comparator function.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to inspect.
+ * @param comparator - The function invoked to compare elements.
+ * @returns A new array with unique elements.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n²) — custom comparators cannot leverage Set optimization.
+ *
+ * @example
+ * ```typescript
+ * const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 1, y: 2 }];
+ *
+ * uniqWith(objects, (a, b) => a.x === b.x && a.y === b.y);
+ * // => [{ x: 1, y: 2 }, { x: 2, y: 1 }]
+ * ```
+ */
+export declare function uniqWith<T>(array: readonly T[], comparator: (a: T, b: T) => boolean): T[];
+//# sourceMappingURL=uniq-with.d.ts.map

package/dist/arkhe/array/uniq-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq-with.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/uniq-with.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAClC,CAAC,EAAE,CAWL"}

package/dist/arkhe/array/uniq-with.js

@@ -0,0 +1,32 @@
+/**
+ * Creates a duplicate-free version of an array using a comparator function.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to inspect.
+ * @param comparator - The function invoked to compare elements.
+ * @returns A new array with unique elements.
+ * @since 2.0.0
+ *
+ * @note First occurrence wins when duplicates are found.
+ *
+ * @performance O(n²) — custom comparators cannot leverage Set optimization.
+ *
+ * @example
+ * ```typescript
+ * const objects = [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 1, y: 2 }];
+ *
+ * uniqWith(objects, (a, b) => a.x === b.x && a.y === b.y);
+ * // => [{ x: 1, y: 2 }, { x: 2, y: 1 }]
+ * ```
+ */
+export function uniqWith(array, comparator) {
+    const result = [];
+    for (const item of array) {
+        const isDuplicate = result.some((existing) => comparator(existing, item));
+        if (!isDuplicate) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=uniq-with.js.map

package/dist/arkhe/array/uniq-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq-with.js","sourceRoot":"","sources":["../../../src/arkhe/array/uniq-with.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAmB,EACnB,UAAmC;IAEnC,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;QAC1E,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/uniq.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to inspect.
+ * @returns A new array with unique values, preserving order of first occurrence.
+ * @since 2.0.0
+ *
+ * @note Uses strict equality (===). First occurrence wins.
+ *
+ * @performance O(n·k) linear scan for small arrays (≤200), O(n) with Set for larger ones.
+ *
+ * @example
+ * ```typescript
+ * uniq([1, 2, 2, 3, 4, 4, 5]);
+ * // => [1, 2, 3, 4, 5]
+ *
+ * uniq([11, 2, 3, 44, 11, 2, 3]);
+ * // => [11, 2, 3, 44]
+ * ```
+ */
+export declare function uniq<T>(array: readonly T[]): T[];
+//# sourceMappingURL=uniq.d.ts.map

package/dist/arkhe/array/uniq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/uniq.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAqChD"}

package/dist/arkhe/array/uniq.js

@@ -0,0 +1,57 @@
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to inspect.
+ * @returns A new array with unique values, preserving order of first occurrence.
+ * @since 2.0.0
+ *
+ * @note Uses strict equality (===). First occurrence wins.
+ *
+ * @performance O(n·k) linear scan for small arrays (≤200), O(n) with Set for larger ones.
+ *
+ * @example
+ * ```typescript
+ * uniq([1, 2, 2, 3, 4, 4, 5]);
+ * // => [1, 2, 3, 4, 5]
+ *
+ * uniq([11, 2, 3, 44, 11, 2, 3]);
+ * // => [11, 2, 3, 44]
+ * ```
+ */
+export function uniq(array) {
+    const len = array.length;
+    // Stryker disable next-line ConditionalExpression,EqualityOperator,BlockStatement: Performance optimization — both paths (loop and Set) produce identical results
+    if (len <= 200) {
+        // Small array: linear scan avoids Set allocation overhead
+        const result = [];
+        let rLen = 0;
+        for (let i = 0; i < len; i++) {
+            const item = array[i];
+            let found = false;
+            for (let j = 0; j < rLen; j++) {
+                if (result[j] === item) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                result.push(item);
+                rLen++;
+            }
+        }
+        return result;
+    }
+    // Large array: Set for O(1) lookups
+    const seen = new Set();
+    const result = [];
+    for (let i = 0; i < len; i++) {
+        const item = array[i];
+        if (!seen.has(item)) {
+            seen.add(item);
+            result.push(item);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=uniq.js.map

package/dist/arkhe/array/uniq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.js","sourceRoot":"","sources":["../../../src/arkhe/array/uniq.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,IAAI,CAAI,KAAmB;IACzC,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;IAEzB,kKAAkK;IAClK,IAAI,GAAG,IAAI,GAAG,EAAE,CAAC;QACf,0DAA0D;QAC1D,MAAM,MAAM,GAAQ,EAAE,CAAC;QACvB,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,KAAK,GAAG,KAAK,CAAC;YAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC9B,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;oBACvB,KAAK,GAAG,IAAI,CAAC;oBACb,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAClB,IAAI,EAAE,CAAC;YACT,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,oCAAoC;IACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAK,CAAC;IAC1B,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACf,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/unzip.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Maps each index of tuple T to an array of that index's type.
+ * @template T - The tuple type to transform.
+ * @example
+ * ```typescript
+ * type Result = UnzipResult<[string, number, boolean]>;
+ * // => [string[], number[], boolean[]]
+ * ```
+ */
+type UnzipResult<T extends readonly unknown[]> = {
+    [K in keyof T]: T[K][];
+} & unknown[];
+/**
+ * Transposes an array of tuples into separate arrays grouped by index position.
+ *
+ * Performs the inverse of `zip`, separating combined tuples back into their constituent arrays.
+ *
+ * @template T - A tuple type representing the structure of each element.
+ * @param tuples - The array of tuples to unzip.
+ * @returns An array of arrays where `result[i]` contains all values from position `i` of each tuple.
+ * @throws {RangeError} If tuples have inconsistent lengths.
+ * @see zip
+ * @since 2.0.0
+ *
+ * @performance O(n × m) time & space where n = tuple length, m = number of tuples. Pre-allocates result arrays with `new Array(n)` for minimal allocation overhead.
+ *
+ * @example
+ * ```typescript
+ * unzip([['a', 1], ['b', 2], ['c', 3]] as const);
+ * // => [['a', 'b', 'c'], [1, 2, 3]]
+ * // Type: [string[], number[]]
+ *
+ * unzip([[1, true, 'x'], [2, false, 'y']] as const);
+ * // => [[1, 2], [true, false], ['x', 'y']]
+ * // Type: [number[], boolean[], string[]]
+ * ```
+ */
+export declare function unzip<T extends readonly unknown[]>(tuples: readonly T[]): UnzipResult<T>;
+export {};
+//# sourceMappingURL=unzip.d.ts.map

package/dist/arkhe/array/unzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/unzip.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,KAAK,WAAW,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI;KAC9C,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;CACvB,GAAG,OAAO,EAAE,CAAC;AAEd;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAChD,MAAM,EAAE,SAAS,CAAC,EAAE,GACnB,WAAW,CAAC,CAAC,CAAC,CA6BhB"}

package/dist/arkhe/array/unzip.js

@@ -0,0 +1,50 @@
+/**
+ * Transposes an array of tuples into separate arrays grouped by index position.
+ *
+ * Performs the inverse of `zip`, separating combined tuples back into their constituent arrays.
+ *
+ * @template T - A tuple type representing the structure of each element.
+ * @param tuples - The array of tuples to unzip.
+ * @returns An array of arrays where `result[i]` contains all values from position `i` of each tuple.
+ * @throws {RangeError} If tuples have inconsistent lengths.
+ * @see zip
+ * @since 2.0.0
+ *
+ * @performance O(n × m) time & space where n = tuple length, m = number of tuples. Pre-allocates result arrays with `new Array(n)` for minimal allocation overhead.
+ *
+ * @example
+ * ```typescript
+ * unzip([['a', 1], ['b', 2], ['c', 3]] as const);
+ * // => [['a', 'b', 'c'], [1, 2, 3]]
+ * // Type: [string[], number[]]
+ *
+ * unzip([[1, true, 'x'], [2, false, 'y']] as const);
+ * // => [[1, 2], [true, false], ['x', 'y']]
+ * // Type: [number[], boolean[], string[]]
+ * ```
+ */
+export function unzip(tuples) {
+    // Stryker disable next-line EqualityOperator: empty array returns empty result
+    if (tuples.length === 0)
+        return [];
+    const tupleLength = tuples[0].length;
+    const numTuples = tuples.length;
+    const result = new Array(tupleLength);
+    for (let i = 0; i < tupleLength; i++) {
+        // Stryker disable next-line ArrayDeclaration: Preallocation optimization — all indices are assigned in the transpose loop below
+        result[i] = new Array(numTuples);
+    }
+    for (let i = 0; i < numTuples; i++) {
+        const tuple = tuples[i];
+        if (tuple.length !== tupleLength) {
+            throw new RangeError(
+            // Stryker disable next-line StringLiteral: error message content is not critical
+            `Tuple at index ${i} has length ${tuple.length}, expected ${tupleLength}`);
+        }
+        for (let j = 0; j < tupleLength; j++) {
+            result[j][i] = tuple[j];
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=unzip.js.map

package/dist/arkhe/array/unzip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.js","sourceRoot":"","sources":["../../../src/arkhe/array/unzip.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,KAAK,CACnB,MAAoB;IAEpB,+EAA+E;IAC/E,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAoB,CAAC;IAErD,MAAM,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACrC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IAChC,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,WAAW,CAAmB,CAAC;IAExD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,gIAAgI;QAChI,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAExB,IAAI,KAAK,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACjC,MAAM,IAAI,UAAU;YAClB,iFAAiF;YACjF,kBAAkB,CAAC,eAAe,KAAK,CAAC,MAAM,cAAc,WAAW,EAAE,CAC1E,CAAC;QACJ,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,MAAM,CAAC,CAAC,CAAe,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/window.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a sliding window array of consecutive elements.
+ *
+ * Returns an array of overlapping subarrays of the specified size,
+ * each shifted by one element from the previous.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The source array to process.
+ * @param size - The size of each window (must be a positive integer).
+ * @returns An array of subarrays, each containing `size` consecutive elements.
+ * @throws {RangeError} When size is not a positive integer.
+ * @since 2.0.0
+ *
+ * @performance O(n×m) time & space, pre-allocated array, early return when size > length.
+ *
+ * @example
+ * ```typescript
+ * window([1, 2, 3, 4, 5], 3);
+ * // => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
+ * ```
+ */
+export declare function window<T>(array: readonly T[], size: number): T[][];
+//# sourceMappingURL=window.d.ts.map

package/dist/arkhe/array/window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/window.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAoBlE"}