@pithos/core 2.0.0

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

@@ -0,0 +1,24 @@
+/**
+ * Reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.
+ *
+ * @info Why wrapping native?: Unlike the native `Array.reverse()` which mutates the original array, this function returns a new array, preserving immutability. See [Design Philosophy](/guide/contribution/design-principles/design-philosophy/)
+ * @note For ES2023+, consider using `Array.toReversed()`.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to reverse.
+ * @returns A new array with elements in reverse order.
+ * @since 2.0.0
+ *
+ * @performance O(n) time and space — creates a shallow copy then reverses in place.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * const reversed = reverse(numbers);
+ * console.log(reversed); // [5, 4, 3, 2, 1]
+ * console.log(numbers); // [1, 2, 3, 4, 5] (original unchanged)
+ * ```
+ */
+export declare function reverse<T>(array: readonly T[]): T[];
+//# sourceMappingURL=reverse.d.ts.map

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

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

package/dist/arkhe/array/reverse.js

@@ -0,0 +1,26 @@
+/**
+ * Reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.
+ *
+ * @info Why wrapping native?: Unlike the native `Array.reverse()` which mutates the original array, this function returns a new array, preserving immutability. See [Design Philosophy](/guide/contribution/design-principles/design-philosophy/)
+ * @note For ES2023+, consider using `Array.toReversed()`.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to reverse.
+ * @returns A new array with elements in reverse order.
+ * @since 2.0.0
+ *
+ * @performance O(n) time and space — creates a shallow copy then reverses in place.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * const reversed = reverse(numbers);
+ * console.log(reversed); // [5, 4, 3, 2, 1]
+ * console.log(numbers); // [1, 2, 3, 4, 5] (original unchanged)
+ * ```
+ */
+export function reverse(array) {
+    return [...array].reverse();
+}
+//# sourceMappingURL=reverse.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.js","sourceRoot":"","sources":["../../../src/arkhe/array/reverse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,OAAO,CAAI,KAAmB;IAC1C,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;AAC9B,CAAC"}

package/dist/arkhe/array/sample-size.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Gets n random elements from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to sample from.
+ * @param n - The number of elements to sample.
+ * @returns A new array of sampled elements.
+ * @throws {RangeError} If n is negative.
+ * @since 2.0.0
+ *
+ * @note Uses Fisher-Yates shuffle algorithm for unbiased sampling.
+ *
+ * @performance O(n) time & space for the shuffled copy.
+ *
+ * @example
+ * ```typescript
+ * sampleSize([1, 2, 3, 4, 5], 3);
+ * // => [3, 1, 5] (random)
+ *
+ * sampleSize(['a', 'b', 'c'], 2);
+ * // => ['b', 'a'] (random)
+ *
+ * sampleSize([1, 2, 3], 5);
+ * // => [2, 3, 1] (returns all if n > length)
+ * ```
+ */
+export declare function sampleSize<T>(array: readonly T[], n: number): T[];
+//# sourceMappingURL=sample-size.d.ts.map

package/dist/arkhe/array/sample-size.d.ts.map

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

package/dist/arkhe/array/sample-size.js

@@ -0,0 +1,44 @@
+/**
+ * Gets n random elements from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to sample from.
+ * @param n - The number of elements to sample.
+ * @returns A new array of sampled elements.
+ * @throws {RangeError} If n is negative.
+ * @since 2.0.0
+ *
+ * @note Uses Fisher-Yates shuffle algorithm for unbiased sampling.
+ *
+ * @performance O(n) time & space for the shuffled copy.
+ *
+ * @example
+ * ```typescript
+ * sampleSize([1, 2, 3, 4, 5], 3);
+ * // => [3, 1, 5] (random)
+ *
+ * sampleSize(['a', 'b', 'c'], 2);
+ * // => ['b', 'a'] (random)
+ *
+ * sampleSize([1, 2, 3], 5);
+ * // => [2, 3, 1] (returns all if n > length)
+ * ```
+ */
+export function sampleSize(array, n) {
+    if (n < 0) {
+        throw new RangeError("n must be non-negative");
+    }
+    const length = array.length;
+    // Stryker disable next-line ConditionalExpression,LogicalOperator: Early return optimization - fallback (count=0, loop 0 times) produces identical result
+    if (length === 0 || n === 0)
+        return [];
+    const count = Math.min(n, length);
+    const copy = [...array];
+    // Stryker disable next-line EqualityOperator: i <= count adds one iteration affecting indices not included in slice result
+    for (let i = 0; i < count; i++) {
+        const randomIndex = i + Math.floor(Math.random() * (length - i));
+        [copy[i], copy[randomIndex]] = [copy[randomIndex], copy[i]];
+    }
+    return copy.slice(0, count);
+}
+//# sourceMappingURL=sample-size.js.map

package/dist/arkhe/array/sample-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-size.js","sourceRoot":"","sources":["../../../src/arkhe/array/sample-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,UAAU,CAAI,KAAmB,EAAE,CAAS;IAC1D,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACV,MAAM,IAAI,UAAU,CAAC,wBAAwB,CAAC,CAAC;IACjD,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,0JAA0J;IAC1J,IAAI,MAAM,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEvC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;IAExB,2HAA2H;IAC3H,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,MAAM,WAAW,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;QACjE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAC9B,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * Gets a random element from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to sample from.
+ * @returns A random element, or `undefined` if the array is empty.
+ * @since 2.0.0
+ *
+ * @performance O(1) time & space, direct index access with early return for empty arrays.
+ *
+ * @example
+ * ```typescript
+ * sample([1, 2, 3, 4, 5]);
+ * // => 3 (random)
+ *
+ * sample([{ name: 'John' }, { name: 'Jane' }]);
+ * // => { name: 'Jane' } (random)
+ * ```
+ */
+export declare function sample<T>(array: readonly T[]): T | undefined;
+//# sourceMappingURL=sample.d.ts.map

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

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

package/dist/arkhe/array/sample.js

@@ -0,0 +1,25 @@
+/**
+ * Gets a random element from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to sample from.
+ * @returns A random element, or `undefined` if the array is empty.
+ * @since 2.0.0
+ *
+ * @performance O(1) time & space, direct index access with early return for empty arrays.
+ *
+ * @example
+ * ```typescript
+ * sample([1, 2, 3, 4, 5]);
+ * // => 3 (random)
+ *
+ * sample([{ name: 'John' }, { name: 'Jane' }]);
+ * // => { name: 'Jane' } (random)
+ * ```
+ */
+export function sample(array) {
+    return array.length
+        ? array[Math.floor(Math.random() * array.length)]
+        : undefined;
+}
+//# sourceMappingURL=sample.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sample.js","sourceRoot":"","sources":["../../../src/arkhe/array/sample.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,MAAM,CAAI,KAAmB;IAC3C,OAAO,KAAK,CAAC,MAAM;QACjB,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QACjD,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC"}

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

@@ -0,0 +1,25 @@
+/**
+ * Creates a shuffled copy of an array using Fisher-Yates algorithm.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to shuffle.
+ * @returns A new shuffled array.
+ * @since 2.0.0
+ *
+ * @note Uses Fisher-Yates shuffle algorithm for unbiased randomization.
+ * @note Does not mutate the original array.
+ *
+ * @performance O(n) time & space.
+ *
+ * @example
+ * ```typescript
+ * shuffle([1, 2, 3, 4, 5]);
+ * // => [3, 1, 5, 2, 4] (random)
+ *
+ * const original = ['a', 'b', 'c'];
+ * const shuffled = shuffle(original);
+ * // original is unchanged
+ * ```
+ */
+export declare function shuffle<T>(array: readonly T[]): T[];
+//# sourceMappingURL=shuffle.d.ts.map

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

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

package/dist/arkhe/array/shuffle.js

@@ -0,0 +1,34 @@
+/**
+ * Creates a shuffled copy of an array using Fisher-Yates algorithm.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to shuffle.
+ * @returns A new shuffled array.
+ * @since 2.0.0
+ *
+ * @note Uses Fisher-Yates shuffle algorithm for unbiased randomization.
+ * @note Does not mutate the original array.
+ *
+ * @performance O(n) time & space.
+ *
+ * @example
+ * ```typescript
+ * shuffle([1, 2, 3, 4, 5]);
+ * // => [3, 1, 5, 2, 4] (random)
+ *
+ * const original = ['a', 'b', 'c'];
+ * const shuffled = shuffle(original);
+ * // original is unchanged
+ * ```
+ */
+export function shuffle(array) {
+    const result = [...array];
+    const length = result.length;
+    // Stryker disable next-line EqualityOperator: i >= 0 adds iteration at i=0 where randomIndex=0, swap with self has no effect
+    for (let i = length - 1; i > 0; i--) {
+        const randomIndex = Math.floor(Math.random() * (i + 1));
+        [result[i], result[randomIndex]] = [result[randomIndex], result[i]];
+    }
+    return result;
+}
+//# sourceMappingURL=shuffle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shuffle.js","sourceRoot":"","sources":["../../../src/arkhe/array/shuffle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,OAAO,CAAI,KAAmB;IAC5C,MAAM,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;IAC1B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAE7B,6HAA6H;IAC7H,KAAK,IAAI,CAAC,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACxD,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/arkhe/array/take-right-while.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Creates a slice of array with elements taken from the end while predicate returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param predicate - The function invoked per iteration.
+ * @returns A new array of taken elements.
+ * @since 2.0.0
+ *
+ * @performance O(n) time, stops at first falsy predicate result from end.
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { user: 'barney', active: false },
+ *   { user: 'fred', active: true },
+ *   { user: 'pebbles', active: true }
+ * ];
+ *
+ * takeRightWhile(users, u => u.active);
+ * // => [{ user: 'fred', active: true }, { user: 'pebbles', active: true }]
+ *
+ * takeRightWhile([1, 2, 3, 4, 5], n => n > 3);
+ * // => [4, 5]
+ * ```
+ */
+export declare function takeRightWhile<T>(array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];
+//# sourceMappingURL=take-right-while.d.ts.map

package/dist/arkhe/array/take-right-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-right-while.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/take-right-while.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACnE,CAAC,EAAE,CAWL"}

package/dist/arkhe/array/take-right-while.js

@@ -0,0 +1,37 @@
+/**
+ * Creates a slice of array with elements taken from the end while predicate returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param predicate - The function invoked per iteration.
+ * @returns A new array of taken elements.
+ * @since 2.0.0
+ *
+ * @performance O(n) time, stops at first falsy predicate result from end.
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { user: 'barney', active: false },
+ *   { user: 'fred', active: true },
+ *   { user: 'pebbles', active: true }
+ * ];
+ *
+ * takeRightWhile(users, u => u.active);
+ * // => [{ user: 'fred', active: true }, { user: 'pebbles', active: true }]
+ *
+ * takeRightWhile([1, 2, 3, 4, 5], n => n > 3);
+ * // => [4, 5]
+ * ```
+ */
+export function takeRightWhile(array, predicate) {
+    let endIndex = array.length;
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (!predicate(array[i], i, array)) {
+            break;
+        }
+        endIndex = i;
+    }
+    return array.slice(endIndex);
+}
+//# sourceMappingURL=take-right-while.js.map

package/dist/arkhe/array/take-right-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-right-while.js","sourceRoot":"","sources":["../../../src/arkhe/array/take-right-while.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,cAAc,CAC5B,KAAmB,EACnB,SAAoE;IAEpE,IAAI,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC;IAE5B,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM;QACR,CAAC;QACD,QAAQ,GAAG,CAAC,CAAC;IACf,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC"}

package/dist/arkhe/array/take-right.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates a slice of array with n elements taken from the end.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param count - The number of elements to take.
+ * @returns A new array with the last `count` elements.
+ * @throws {RangeError} If count is negative.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * takeRight(numbers, 3);
+ * // => [3, 4, 5]
+ *
+ * takeRight(numbers, 0);
+ * // => []
+ * ```
+ */
+export declare function takeRight<T>(array: readonly T[], count: number): T[];
+//# sourceMappingURL=take-right.d.ts.map

package/dist/arkhe/array/take-right.d.ts.map

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

package/dist/arkhe/array/take-right.js

@@ -0,0 +1,31 @@
+/**
+ * Creates a slice of array with n elements taken from the end.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param count - The number of elements to take.
+ * @returns A new array with the last `count` elements.
+ * @throws {RangeError} If count is negative.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * takeRight(numbers, 3);
+ * // => [3, 4, 5]
+ *
+ * takeRight(numbers, 0);
+ * // => []
+ * ```
+ */
+export function takeRight(array, count) {
+    if (count < 0) {
+        // Stryker disable next-line StringLiteral: error message content is not critical
+        throw new RangeError("count must be non-negative");
+    }
+    if (count === 0)
+        return [];
+    return array.slice(-count);
+}
+//# sourceMappingURL=take-right.js.map

package/dist/arkhe/array/take-right.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-right.js","sourceRoot":"","sources":["../../../src/arkhe/array/take-right.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,SAAS,CAAI,KAAmB,EAAE,KAAa;IAC7D,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,iFAAiF;QACjF,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,CAAC;IACrD,CAAC;IACD,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC"}

package/dist/arkhe/array/take-while.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Creates a slice of array with elements taken from the beginning while predicate returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param predicate - The function invoked per iteration.
+ * @returns A new array of taken elements.
+ * @since 2.0.0
+ *
+ * @performance O(n) time, stops at first falsy predicate result.
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { user: 'barney', active: true },
+ *   { user: 'fred', active: true },
+ *   { user: 'pebbles', active: false }
+ * ];
+ *
+ * takeWhile(users, u => u.active);
+ * // => [{ user: 'barney', active: true }, { user: 'fred', active: true }]
+ *
+ * takeWhile([1, 2, 3, 4, 5], n => n < 3);
+ * // => [1, 2]
+ * ```
+ */
+export declare function takeWhile<T>(array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => boolean): T[];
+//# sourceMappingURL=take-while.d.ts.map

package/dist/arkhe/array/take-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/take-while.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACnE,CAAC,EAAE,CAWL"}

package/dist/arkhe/array/take-while.js

@@ -0,0 +1,37 @@
+/**
+ * Creates a slice of array with elements taken from the beginning while predicate returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param predicate - The function invoked per iteration.
+ * @returns A new array of taken elements.
+ * @since 2.0.0
+ *
+ * @performance O(n) time, stops at first falsy predicate result.
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { user: 'barney', active: true },
+ *   { user: 'fred', active: true },
+ *   { user: 'pebbles', active: false }
+ * ];
+ *
+ * takeWhile(users, u => u.active);
+ * // => [{ user: 'barney', active: true }, { user: 'fred', active: true }]
+ *
+ * takeWhile([1, 2, 3, 4, 5], n => n < 3);
+ * // => [1, 2]
+ * ```
+ */
+export function takeWhile(array, predicate) {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        if (!predicate(array[i], i, array)) {
+            break;
+        }
+        result.push(array[i]);
+    }
+    return result;
+}
+//# sourceMappingURL=take-while.js.map

package/dist/arkhe/array/take-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.js","sourceRoot":"","sources":["../../../src/arkhe/array/take-while.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,SAAS,CACvB,KAAmB,EACnB,SAAoE;IAEpE,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM;QACR,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * Creates a slice of array with n elements taken from the beginning.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param count - The number of elements to take.
+ * @returns A new array with the first `count` elements.
+ * @throws {RangeError} If count is negative.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * take(numbers, 3);
+ * // => [1, 2, 3]
+ *
+ * take(numbers, 0);
+ * // => []
+ *
+ * take(numbers, 10);
+ * // => [1, 2, 3, 4, 5]
+ * ```
+ */
+export declare function take<T>(array: readonly T[], count: number): T[];
+//# sourceMappingURL=take.d.ts.map

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

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

package/dist/arkhe/array/take.js

@@ -0,0 +1,35 @@
+/**
+ * Creates a slice of array with n elements taken from the beginning.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param count - The number of elements to take.
+ * @returns A new array with the first `count` elements.
+ * @throws {RangeError} If count is negative.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * take(numbers, 3);
+ * // => [1, 2, 3]
+ *
+ * take(numbers, 0);
+ * // => []
+ *
+ * take(numbers, 10);
+ * // => [1, 2, 3, 4, 5]
+ * ```
+ */
+export function take(array, count) {
+    if (count < 0) {
+        // Stryker disable next-line StringLiteral: error message content is not critical
+        throw new RangeError("count must be non-negative");
+    }
+    // Stryker disable next-line ConditionalExpression: Early return optimization - slice(0, 0) produces identical empty array
+    if (count === 0)
+        return [];
+    return array.slice(0, count);
+}
+//# sourceMappingURL=take.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","sourceRoot":"","sources":["../../../src/arkhe/array/take.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,IAAI,CAAI,KAAmB,EAAE,KAAa;IACxD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,iFAAiF;QACjF,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,CAAC;IACrD,CAAC;IACD,0HAA0H;IAC1H,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAC/B,CAAC"}

package/dist/arkhe/array/to-array.d.ts

@@ -0,0 +1,27 @@
+import { Arrayable } from "../types/common/arrayable";
+/**
+ * Normalizes a value to an array.
+ *
+ * @template T - The type of elements.
+ * @param value - A single value or array of values.
+ * @returns The value wrapped in an array, or the original array if already one.
+ * @since 2.0.0
+ *
+ * @note Uses `Array.isArray()` for type discrimination — required for union types.
+ *
+ * @performance O(1) time & space, returns original array if already one, otherwise creates single-element array.
+ *
+ * @example
+ * ```typescript
+ * toArray(5);
+ * // => [5]
+ *
+ * toArray([1, 2, 3]);
+ * // => [1, 2, 3]
+ *
+ * toArray('hello');
+ * // => ['hello']
+ * ```
+ */
+export declare function toArray<T>(value: Arrayable<T>): T[];
+//# sourceMappingURL=to-array.d.ts.map

package/dist/arkhe/array/to-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-array.d.ts","sourceRoot":"","sources":["../../../src/arkhe/array/to-array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAEnD"}

package/dist/arkhe/array/to-array.js

@@ -0,0 +1,28 @@
+/**
+ * Normalizes a value to an array.
+ *
+ * @template T - The type of elements.
+ * @param value - A single value or array of values.
+ * @returns The value wrapped in an array, or the original array if already one.
+ * @since 2.0.0
+ *
+ * @note Uses `Array.isArray()` for type discrimination — required for union types.
+ *
+ * @performance O(1) time & space, returns original array if already one, otherwise creates single-element array.
+ *
+ * @example
+ * ```typescript
+ * toArray(5);
+ * // => [5]
+ *
+ * toArray([1, 2, 3]);
+ * // => [1, 2, 3]
+ *
+ * toArray('hello');
+ * // => ['hello']
+ * ```
+ */
+export function toArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+//# sourceMappingURL=to-array.js.map

package/dist/arkhe/array/to-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-array.js","sourceRoot":"","sources":["../../../src/arkhe/array/to-array.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,OAAO,CAAI,KAAmB;IAC5C,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC"}

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

@@ -0,0 +1,24 @@
+/**
+ * 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 declare function toggle<T>(array: readonly T[], element: T): T[];
+//# sourceMappingURL=toggle.d.ts.map

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

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