ts-data-forge 1.5.1 → 2.0.0

package/dist/array/array-utils.mjs

@@ -2,7 +2,6 @@ import '../collections/imap-mapped.mjs';
 import { IMap } from '../collections/imap.mjs';
 import '../collections/iset-mapped.mjs';
 import '../collections/iset.mjs';
-import './tuple-utils.mjs';
 import { isString, isUndefined } from '../guard/is-type.mjs';
 import { Optional } from '../functional/optional.mjs';
 import { pipe } from '../functional/pipe.mjs';
@@ -32,7 +31,7 @@ import '../number/branded-types/safe-int.mjs';
 import '../number/branded-types/safe-uint.mjs';
 import '../number/branded-types/uint.mjs';
 import '../number/branded-types/uint16.mjs';
-import { asUint32, Uint32 } from '../number/branded-types/uint32.mjs';
+import { Uint32, asUint32 } from '../number/branded-types/uint32.mjs';
 import '../number/enum/int8.mjs';
 import '../number/enum/uint8.mjs';
 import { Num } from '../number/num.mjs';
@@ -77,7 +76,7 @@ var Arr;
      * // Type: IntersectBrand<PositiveNumber, SizeType.Arr>
      * // Value: 3 (branded, guaranteed positive)
      *
-     * const nonEmpty: NonEmptyArray<string> = ['a', 'b'] as NonEmptyArray<string>;
+     * const nonEmpty: NonEmptyArray<string> = ['a', 'b'];
      * const nonEmptySize = Arr.size(nonEmpty);
      * // Type: IntersectBrand<PositiveNumber, SizeType.Arr>
      * // Guaranteed to be > 0
@@ -107,13 +106,6 @@ var Arr;
      * const indices = Arr.seq(dataSize); // Creates [0, 1, 2]
      * const zeros = Arr.zeros(dataSize); // Creates [0, 0, 0]
      *
-     * // Safe for bounds checking
-     * const isValidIndex = (index: number) => index >= 0 && index < dataSize;
-     *
-     * // Comparison with other sizes
-     * const otherArray = ['a', 'b'];
-     * const sizeDiff = Uint32.sub(Arr.size(data), Arr.size(otherArray)); // 1
-     *
      * // Functional composition
      * const arrays = [
      *   [1, 2],
@@ -140,9 +132,9 @@ var Arr;
      * @see {@link isEmpty} for checking if size is 0
      * @see {@link isNonEmpty} for checking if size > 0
      */
+    Arr.size = (array) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.size = ((array) => asUint32(array.length));
-    Arr.length = Arr.size;
+    array.length;
     // type guard
     /**
      * Type guard that checks if a value is an array, excluding types that cannot be arrays.
@@ -192,26 +184,11 @@ var Arr;
      *   if (Arr.isEmpty(arr)) {
      *     // arr is now typed as readonly []
      *     console.log('Array is empty');
+     *     // arr[0]; // type error!
      *     return 0;
-     *   } else {
-     *     // arr is now typed as NonEmptyArray<number>
-     *     return arr[0]; // Safe access - TypeScript knows it's non-empty
      *   }
      * }
      *
-     * // Conditional processing
-     * const data = [10, 20, 30];
-     * if (!Arr.isEmpty(data)) {
-     *   // Safe to access elements
-     *   const firstElement = data[0]; // No undefined risk
-     *   const lastElement = data[data.length - 1];
-     * }
-     *
-     * // Filtering empty arrays
-     * const arrayList: readonly number[][] = [[1, 2], [], [3], []];
-     * const nonEmptyArrays = arrayList.filter(arr => !Arr.isEmpty(arr));
-     * // nonEmptyArrays: [[1, 2], [3]]
-     *
      * // Early returns
      * function sumArray(numbers: readonly number[]): number {
      *   if (Arr.isEmpty(numbers)) {
@@ -220,12 +197,6 @@ var Arr;
      *   return numbers.reduce((sum, n) => sum + n, 0);
      * }
      *
-     * // Type inference examples
-     * const testEmpty = [] as const;
-     * const testNonEmpty = [1, 2] as const;
-     *
-     * expectType<Parameters<typeof Arr.isEmpty>[0], readonly unknown[]>('=');
-     * expectType<ReturnType<typeof Arr.isEmpty>, boolean>('=');
      * ```
      *
      * @see {@link isNonEmpty} for the opposite check (non-empty arrays)
@@ -266,16 +237,14 @@ var Arr;
      *
      * // Safe operations on non-empty arrays
      * function processData(data: readonly string[]) {
-     *   if (Arr.isNonEmpty(data)) {
-     *     // All of these are now safe without undefined checks
-     *     const first = data[0];
-     *     const last = data[data.length - 1];
-     *     const middle = data[Math.floor(data.length / 2)];
-     *
-     *     // Can safely use non-empty array methods
-     *     const joined = data.join(', ');
-     *     const reduced = data.reduce((acc, item) => acc + item.length, 0);
-     *   }
+     *   if (!Arr.isNonEmpty(data)) return;  // early return pattern
+     *
+     *   // This is now safe without undefined checks
+     *   const first = data[0];
+     *
+     *   // Can safely use non-empty array methods
+     *   const lastElement = Arr.last(data);
+     *
      * }
      *
      * // Filtering and working with arrays
@@ -300,7 +269,7 @@ var Arr;
      *   }
      *
      *   // numbers is now NonEmptyArray<number>
-     *   return numbers.reduce((sum, n) => sum + n, 0) / numbers.length;
+     *   return Arr.sum(numbers) / Arr.size(numbers);
      * }
      *
      * // Functional composition
@@ -432,8 +401,9 @@ var Arr;
      * expectType<typeof maybeEmpty, readonly 0[]>('=');
      * ```
      */
+    Arr.zeros = (len) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.zeros = ((len) => Array.from({ length: len }).fill(0));
+    Array.from({ length: len }).fill(0);
     /**
      * Creates a sequence of consecutive integers from 0 to `len-1`.
      *
@@ -475,8 +445,9 @@ var Arr;
      * expectType<typeof single, readonly [0]>('=');
      * ```
      */
+    Arr.seq = (len) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.seq = ((len) => Array.from({ length: len }, (_, i) => asUint32(i)));
+    Array.from({ length: len }, (_, i) => i);
     /**
      * Creates a new array of the specified length, with each position filled with the provided initial value.
      *
@@ -525,9 +496,9 @@ var Arr;
      * @see {@link zeros} for creating arrays filled with zeros
      * @see {@link seq} for creating sequences of consecutive integers
      */
+    Arr.create = (len, init) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.create = ((len, init) => Array.from({ length: Math.max(0, len) }, () => init));
-    Arr.newArray = Arr.create;
+    Array.from({ length: Math.max(0, len) }, () => init);
     /**
      * Creates an array from a generator function.
      *
@@ -615,216 +586,11 @@ var Arr;
     Arr.copy = (array) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     array.slice();
-    /**
-     * Creates an array of numbers within a specified range with optional step increment.
-     *
-     * This function generates arithmetic sequences with advanced compile-time type inference:
-     * - When `start` and `end` are {@link SmallUint} literals and `step` is 1 (or omitted), returns a precise tuple type
-     * - When parameters are runtime values, returns appropriate array types based on sign constraints
-     * - Empty arrays are returned for invalid ranges (e.g., start ≥ end with positive step)
-     * - Never throws exceptions - invalid parameters result in empty arrays
-     *
-     * **SmallUint Constraint:** The {@link SmallUint} constraint (0-255) enables precise tuple type inference
-     * for compile-time known ranges. This allows TypeScript to compute exact tuple types like `readonly [1, 2, 3, 4]`
-     * instead of generic `readonly number[]`.
-     *
-     * **Type Inference Behavior:**
-     * - Literal {@link SmallUint} values with step=1 → precise tuple type (`RangeList<S, E>`)
-     * - Non-negative parameters → `readonly SafeUint[]`
-     * - Mixed signs or negative parameters → `readonly SafeInt[]`
-     * - Runtime values → lose precise typing but maintain safety
-     *
-     * @template S The type of the start value. When a {@link SmallUint} literal (0-255), enables precise tuple typing.
-     * @template E The type of the end value. When a {@link SmallUint} literal (0-255), enables precise tuple typing.
-     * @param start The start of the range (inclusive). Must be a safe integer. Supports:
-     *   - **Literal {@link SmallUint}:** Enables precise tuple types (0-255)
-     *   - **Runtime {@link SafeInt}:** Fallback to general array types
-     *   - **Negative values:** Supported for countdown sequences
-     * @param end The end of the range (exclusive). Must be a safe integer. Supports:
-     *   - **Literal {@link SmallUint}:** Enables precise tuple types (0-255)
-     *   - **Runtime {@link SafeInt}:** Fallback to general array types
-     *   - **Equal to start:** Results in empty array
-     * @param step The step increment (default: 1). Must be a non-zero safe integer.
-     *   - **Positive step:** generates increasing sequence from start to end
-     *   - **Negative step:** generates decreasing sequence from start to end
-     *   - **Zero step:** Not allowed (branded type prevents this)
-     * @returns An immutable array containing the arithmetic sequence. Return type depends on parameters:
-     *   - `RangeList<S, E>` (precise tuple like `readonly [1, 2, 3, 4]`) when `S` and `E` are {@link SmallUint} literals and step is 1
-     *   - `readonly SafeUint[]` when all parameters are non-negative
-     *   - `readonly SafeInt[]` for general integer ranges including negative values
-     *
-     * @example
-     * ```typescript
-     * // Compile-time known ranges with step=1 produce precise tuple types
-     * const range1to4 = Arr.range(1, 5); // readonly [1, 2, 3, 4]
-     * const range0to2 = Arr.range(0, 3); // readonly [0, 1, 2]
-     * const emptyRange = Arr.range(5, 5); // readonly []
-     * const reverseEmpty = Arr.range(5, 1); // readonly [] (invalid with positive step)
-     *
-     * // SmallUint constraint examples (0-255 for precise typing)
-     * const small = Arr.range(0, 10); // readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-     * const maxSmall = Arr.range(250, 255); // readonly [250, 251, 252, 253, 254]
-     * const beyondSmall = Arr.range(0, 300); // readonly SafeUint[] (loses precision)
-     *
-     * // Custom step increments
-     * const evens = Arr.range(0, 10, 2); // readonly SafeUint[] -> [0, 2, 4, 6, 8]
-     * const odds = Arr.range(1, 10, 2); // readonly SafeUint[] -> [1, 3, 5, 7, 9]
-     * const countdown = Arr.range(5, 0, -1); // readonly SafeInt[] -> [5, 4, 3, 2, 1]
-     * const bigStep = Arr.range(0, 20, 5); // readonly SafeUint[] -> [0, 5, 10, 15]
-     *
-     * // Edge cases that return empty arrays
-     * const singleElement = Arr.range(3, 4); // readonly [3]
-     * const invalidRange = Arr.range(10, 5, 2); // readonly [] (start > end with positive step)
-     * const invalidReverse = Arr.range(1, 10, -1); // readonly [] (start < end with negative step)
-     * const zeroRange = Arr.range(42, 42); // readonly [] (start equals end)
-     *
-     * // Runtime ranges lose precise typing but maintain safety
-     * const dynamicStart = Math.floor(Math.random() * 10) as SafeInt;
-     * const dynamicEnd = (dynamicStart + 5) as SafeInt;
-     * const dynamicRange = Arr.range(dynamicStart, dynamicEnd); // readonly SafeInt[]
-     *
-     * // Negative numbers and mixed signs
-     * const negativeRange = Arr.range(-5, 5); // readonly SafeInt[] -> [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
-     * const negativeCountdown = Arr.range(0, -5, -1); // readonly SafeInt[] -> [0, -1, -2, -3, -4]
-     *
-     * // Useful for generating index ranges and iteration
-     * const indices = Arr.range(0, 10); // readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-     * const reversedIndices = Arr.range(9, -1, -1); // readonly SafeInt[] -> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-     *
-     * // Functional programming patterns
-     * const squares = Arr.range(1, 6).map(x => x * x); // [1, 4, 9, 16, 25]
-     * const fibonacci = Arr.range(0, 10).reduce((acc, _, i) => {\n   *   if (i <= 1) return [...acc, i];\n   *   return [...acc, acc[i-1] + acc[i-2]];\n   * }, [] as number[]); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
-     *
-     * // Type inference examples showing precise vs general types
-     * expectType<typeof range1to4, readonly [1, 2, 3, 4]>('='); // Precise tuple
-     * expectType<typeof emptyRange, readonly []>('='); // Precise empty tuple
-     * expectType<typeof evens, readonly SafeUint[]>('='); // General positive array
-     * expectType<typeof countdown, readonly SafeInt[]>('='); // General integer array
-     * expectType<typeof negativeRange, readonly SafeInt[]>('='); // General integer array
-     * expectType<typeof small, readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>('='); // Precise tuple
-     * expectType<typeof beyondSmall, readonly SafeUint[]>('='); // General array (beyond SmallUint)
-     * ```
-     *
-     * @throws Never throws - invalid ranges simply return empty arrays
-     * @see {@link seq} for creating sequences starting from 0
-     * @see {@link SmallUint} for understanding the constraint that enables precise typing
-     * @see {@link SafeInt} and {@link SafeUint} for the safe integer types used
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.range = ((start, end, step = 1) => Array.from(range(start, end, step)));
-    // element access
-    /**
-     * Safely retrieves an element at a given index from an array, returning an {@link Optional}.
-     *
-     * This function provides type-safe array access with support for negative indexing
-     * (e.g., -1 for the last element). Unlike direct array access which can return
-     * `undefined` for out-of-bounds indices, this function always returns a well-typed
-     * {@link Optional} that explicitly represents the possibility of absence.
-     *
-     * **Negative Indexing:** Negative indices count from the end of the array:
-     * - `-1` refers to the last element
-     * - `-2` refers to the second-to-last element, etc.
-     *
-     * **Curried Usage:** This function supports currying - when called with only an index, it returns
-     * a function that can be applied to arrays, making it ideal for use in pipe operations.
-     *
-     * **Optional Return Type:** The return type is always {@link Optional}<E> which provides:
-     * - Type-safe access without `undefined` in your business logic
-     * - Explicit handling of \"not found\" cases
-     * - Composable error handling with {@link Optional} utilities
-     *
-     * @template E The type of elements in the array.
-     * @param array The array to access (when using direct call syntax).
-     * @param index The index to access. Must be a branded `SizeType.ArgArr` (safe integer). Can be:
-     *   - **Positive integer:** 0-based index from the start (0, 1, 2, ...)
-     *   - **Negative integer:** index from the end (-1 is last element, -2 is second-to-last, etc.)
-     *   - **Out of bounds:** any index beyond array bounds returns {@link Optional.None}
-     * @returns An {@link Optional}<E> containing:
-     *   - {@link Optional.Some}<E> with the element if the index is valid
-     *   - {@link Optional.None} if the index is out of bounds (including empty arrays)
-     *
-     * @example
-     * ```typescript
-     * // Direct usage with positive indices
-     * const fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry'];
-     * const first = Arr.at(fruits, 0); // Optional.Some('apple')
-     * const third = Arr.at(fruits, 2); // Optional.Some('cherry')
-     * const outOfBounds = Arr.at(fruits, 10); // Optional.None
-     *
-     * // Negative indexing (accessing from the end)
-     * const last = Arr.at(fruits, -1); // Optional.Some('elderberry')
-     * const secondLast = Arr.at(fruits, -2); // Optional.Some('date')
-     * const negativeOutOfBounds = Arr.at(fruits, -10); // Optional.None
-     *
-     * // Edge cases
-     * const emptyResult = Arr.at([], 0); // Optional.None
-     * const negativeOnEmpty = Arr.at([], -1); // Optional.None
-     * const singleElement = Arr.at(['only'], 0); // Optional.Some('only')
-     * const singleNegative = Arr.at(['only'], -1); // Optional.Some('only')
-     *
-     * // Safe access pattern with type-safe unwrapping
-     * const maybeElement = Arr.at(fruits, 2);
-     * if (Optional.isSome(maybeElement)) {
-     *   console.log(`Found: ${maybeElement.value}`); // Type-safe access, no undefined
-     * } else {
-     *   console.log('Index out of bounds');
-     * }
-     *
-     * // Alternative unwrapping with default
-     * const elementOrDefault = Optional.unwrapOr(Arr.at(fruits, 100), 'not found');
-     * console.log(elementOrDefault); // 'not found'
-     *
-     * // Curried usage for functional composition
-     * const getSecondElement = Arr.at(1);
-     * const getLastElement = Arr.at(-1);
-     * const getMiddleElement = Arr.at(2);
-     *
-     * const nestedArrays = [
-     *   [10, 20, 30, 40],
-     *   [50, 60],
-     *   [70]
-     * ];
-     * const secondElements = nestedArrays.map(getSecondElement);
-     * // [Optional.Some(20), Optional.None, Optional.None]
-     *
-     * const lastElements = nestedArrays.map(getLastElement);
-     * // [Optional.Some(40), Optional.Some(60), Optional.Some(70)]
-     *
-     * // Pipe composition for data processing
-     * const processArray = (arr: readonly string[]) => pipe(arr)
-     *   .map(getSecondElement)
-     *   .map(opt => Optional.map(opt, s => s.toUpperCase()))
-     *   .map(opt => Optional.unwrapOr(opt, 'MISSING'))
-     *   .value;
-     *
-     * console.log(processArray(['a', 'b', 'c'])); // 'B'
-     * console.log(processArray(['x'])); // 'MISSING'
-     *
-     * // Advanced curried usage with transformation pipelines
-     * const extractAndProcess = pipe([
-     *   ['hello', 'world', 'typescript'],
-     *   ['functional', 'programming'],
-     *   ['type', 'safety', 'matters', 'most']
-     * ])
-     *   .map(arr => arr.map(getSecondElement))
-     *   .map(opts => opts.map(opt => Optional.unwrapOr(opt, '[missing]')))
-     *   .value;
-     * // [['world'], ['[missing]'], ['safety']]
-     *
-     * // Type inference examples
-     * expectType<typeof first, Optional<string>>('=');
-     * expectType<typeof getSecondElement, <T>(array: readonly T[]) => Optional<T>>('=');
-     * expectType<typeof negativeOutOfBounds, Optional<string>>('=');
-     * ```
-     *
-     * @see {@link head} for getting the first element specifically
-     * @see {@link last} for getting the last element specifically
-     * @see {@link Optional} for working with the returned Optional values
-     * @see {@link Optional.unwrapOr} for safe unwrapping with defaults
-     * @see {@link Optional.map} for transforming Optional values
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.at = ((...args) => {
+    function range$1(start, end, step = 1) {
+        return Array.from(range(start, end, step));
+    }
+    Arr.range = range$1;
+    function at(...args) {
         switch (args.length) {
             case 2: {
                 const [array, index] = args;
@@ -835,10 +601,11 @@ var Arr;
             }
             case 1: {
                 const [index] = args;
-                return (array) => Arr.at(array, index);
+                return (array) => at(array, index);
             }
         }
-    });
+    }
+    Arr.at = at;
     /**
      * Returns the first element of an array wrapped in an Optional.
      *
@@ -910,11 +677,9 @@ var Arr;
      * @see {@link at} for accessing elements at specific indices
      * @see {@link tail} for getting all elements except the first
      */
+    Arr.head = (array) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.head = ((array) => {
-        const element = array.at(0);
-        return element === undefined ? Optional.none : Optional.some(element);
-    });
+    (array.length === 0 ? Optional.none : Optional.some(array.at(0)));
     /**
      * Returns the last element of an array wrapped in an Optional.
      *
@@ -995,97 +760,10 @@ var Arr;
      * @see {@link at} for accessing elements at specific indices with negative indexing support
      * @see {@link butLast} for getting all elements except the last
      */
+    Arr.last = (array) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.last = ((array) => {
-        const element = array.at(-1);
-        return element === undefined ? Optional.none : Optional.some(element);
-    });
-    // slicing
-    /**
-     * Slices an array with automatically clamped start and end indices for safe bounds handling.
-     *
-     * This function provides a safer alternative to `Array.slice()` by automatically clamping
-     * the start and end indices to valid bounds, preventing out-of-bounds access and ensuring
-     * consistent behavior regardless of input values.
-     *
-     * **Clamping Behavior:**
-     * - `start` is clamped to `[0, array.length]`
-     * - `end` is clamped to `[clampedStart, array.length]` (ensuring end ≥ start)
-     * - Invalid ranges (start > end after clamping) return empty arrays
-     * - Negative indices are clamped to 0, large indices are clamped to array.length
-     *
-     * **Curried Usage:** This function supports currying - when called with only start and end
-     * indices, it returns a function that can be applied to arrays.
-     *
-     * @template E The type of elements in the array.
-     * @param array The array to slice (when using direct call syntax).
-     * @param start The start index for the slice (inclusive). Will be clamped to valid bounds.
-     * @param end The end index for the slice (exclusive). Will be clamped to valid bounds.
-     * @returns A new immutable array containing the sliced elements. Always returns a valid array,
-     *   never throws for out-of-bounds indices.
-     *
-     * @example
-     * ```typescript
-     * const data = [10, 20, 30, 40, 50];
-     *
-     * // Normal slicing
-     * const middle = Arr.sliceClamped(data, 1, 4); // [20, 30, 40]
-     * const beginning = Arr.sliceClamped(data, 0, 2); // [10, 20]
-     * const end = Arr.sliceClamped(data, 3, 5); // [40, 50]
-     *
-     * // Automatic clamping for out-of-bounds indices
-     * const clampedStart = Arr.sliceClamped(data, -10, 3); // [10, 20, 30] (start clamped to 0)
-     * const clampedEnd = Arr.sliceClamped(data, 2, 100); // [30, 40, 50] (end clamped to length)
-     * const bothClamped = Arr.sliceClamped(data, -5, 100); // [10, 20, 30, 40, 50] (entire array)
-     *
-     * // Invalid ranges become empty arrays
-     * const emptyReversed = Arr.sliceClamped(data, 4, 1); // [] (start > end after clamping)
-     * const emptyAtEnd = Arr.sliceClamped(data, 5, 10); // [] (start at end of array)
-     *
-     * // Edge cases
-     * const emptyArray = Arr.sliceClamped([], 0, 5); // [] (empty input)
-     * const singleElement = Arr.sliceClamped([42], 0, 1); // [42]
-     * const fullCopy = Arr.sliceClamped(data, 0, data.length); // [10, 20, 30, 40, 50]
-     *
-     * // Curried usage for functional composition
-     * const takeFirst3 = Arr.sliceClamped(0, 3);
-     * const getMiddle2 = Arr.sliceClamped(1, 3);
-     *
-     * const arrays = [
-     *   [1, 2, 3, 4, 5],
-     *   [10, 20],
-     *   [100, 200, 300, 400, 500, 600]
-     * ];
-     *
-     * const first3Elements = arrays.map(takeFirst3);
-     * // [[1, 2, 3], [10, 20], [100, 200, 300]]
-     *
-     * const middle2Elements = arrays.map(getMiddle2);
-     * // [[2, 3], [20], [200, 300]]
-     *
-     * // Pipe composition
-     * const result = pipe([1, 2, 3, 4, 5, 6])
-     *   .map(takeFirst3)
-     *   .map(Arr.sum)
-     *   .value; // 6 (sum of [1, 2, 3])
-     *
-     * // Comparison with regular Array.slice (which can throw or behave unexpectedly)
-     * try {
-     *   // Regular slice with out-of-bounds - works but may be unintuitive
-     *   const regularSlice = data.slice(-10, 100); // [10, 20, 30, 40, 50]
-     *   // sliceClamped provides same safe behavior explicitly
-     *   const clampedSlice = Arr.sliceClamped(data, -10, 100); // [10, 20, 30, 40, 50]
-     * } catch (error) {
-     *   // sliceClamped never throws
-     * }
-     * ```
-     *
-     * @see {@link take} for taking the first N elements
-     * @see {@link skip} for skipping the first N elements
-     * @see {@link takeLast} for taking the last N elements
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.sliceClamped = ((...args) => {
+    (array.length === 0 ? Optional.none : Optional.some(array.at(-1)));
+    function sliceClamped(...args) {
         switch (args.length) {
             case 3: {
                 const [array, start, end] = args;
@@ -1096,10 +774,11 @@ var Arr;
             }
             case 2: {
                 const [start, end] = args;
-                return (array) => Arr.sliceClamped(array, start, end);
+                return (array) => sliceClamped(array, start, end);
             }
         }
-    });
+    }
+    Arr.sliceClamped = sliceClamped;
     /**
      * Returns all elements of an array except the first one.
      * @template E The type of the array (can be a tuple for more precise typing).
@@ -1130,342 +809,87 @@ var Arr;
     Arr.butLast = (array) => 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     (Arr.isEmpty(array) ? [] : array.slice(0, -1));
-    /**
-     * Takes the first N elements from an array.
-     *
-     * - If the array is a tuple, the return type is inferred as a tuple of the first N elements.
-     * - If the array is a NonEmptyArray and N is a SizeType.ArgArrPositive, returns a NonEmptyArray.
-     * - Otherwise, returns a readonly array of up to N elements.
-     *
-     * @template E The type of the array (can be a tuple for more precise typing).
-     * @template N The number of elements to take, constrained to `SmallUint`.
-     * @param array The input array.
-     * @param num The number of elements to take.
-     * @returns A new array containing the first N elements.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.take([1, 2, 3, 4] as const, 2); // [1, 2]
-     *
-     * // Curried usage for pipe composition
-     * const takeFirst3 = Arr.take(3);
-     * const result = pipe([1, 2, 3, 4, 5]).map(takeFirst3).value;
-     * console.log(result); // [1, 2, 3]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.take = ((...args) => {
+    function take(...args) {
         switch (args.length) {
             case 2: {
                 const [array, num] = args;
-                return Arr.sliceClamped(array, 0, num);
+                return sliceClamped(array, 0, num);
             }
             case 1: {
                 const [num] = args;
-                return (array) => Arr.take(array, num);
+                return (array) => take(array, num);
             }
         }
-    });
-    /**
-     * Takes the last N elements from an array.
-     *
-     * - If the array is a tuple, the return type is inferred as a tuple of the last N elements.
-     * - If the array is a non-empty array and N is a positive integer, returns a non-empty array.
-     * - Otherwise, returns a readonly array of up to N elements.
-     *
-     * @template E The type of the array (can be a tuple for more precise typing).
-     * @template N The number of elements to take, constrained to `SmallUint`.
-     * @param array The input array.
-     * @param num The number of elements to take.
-     * @returns A new array containing the last N elements.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.takeLast([1, 2, 3, 4] as const, 2); // [3, 4]
-     *
-     * // Curried usage for pipe composition
-     * const takeLast2 = Arr.takeLast(2);
-     * const result = pipe([1, 2, 3, 4, 5]).map(takeLast2).value;
-     * console.log(result); // [4, 5]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.takeLast = ((...args) => {
+    }
+    Arr.take = take;
+    function takeLast(...args) {
         switch (args.length) {
             case 2: {
                 const [array, num] = args;
-                return Arr.sliceClamped(array, Uint32.sub(Arr.size(array), num), Arr.size(array));
+                return sliceClamped(array, Uint32.sub(Arr.size(array), num), Arr.size(array));
             }
             case 1: {
                 const [num] = args;
-                return (array) => Arr.takeLast(array, num);
+                return (array) => takeLast(array, num);
             }
         }
-    });
-    /**
-     * Skips the first N elements of an array.
-     *
-     * - If the array is a tuple, the return type is inferred as a tuple with the first N elements removed.
-     * - If the array is a non-empty array and N is a positive integer, returns a readonly array (may be empty).
-     * - Otherwise, returns a readonly array with the first N elements skipped.
-     *
-     * @template E The type of the array (can be a tuple for more precise typing).
-     * @template N The number of elements to skip, constrained to `SmallUint`.
-     * @param array The input array.
-     * @param num The number of elements to skip.
-     * @returns A new array containing the elements after skipping the first N.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.skip([1, 2, 3, 4] as const, 2); // [3, 4]
-     *
-     * // Curried usage for pipe composition
-     * const skipFirst2 = Arr.skip(2);
-     * const result = pipe([1, 2, 3, 4, 5]).map(skipFirst2).value;
-     * console.log(result); // [3, 4, 5]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.skip = ((...args) => {
+    }
+    Arr.takeLast = takeLast;
+    function skip(...args) {
         switch (args.length) {
             case 2: {
                 const [array, num] = args;
-                return Arr.sliceClamped(array, num, Arr.size(array));
+                return sliceClamped(array, num, Arr.size(array));
             }
             case 1: {
                 const [num] = args;
-                return (array) => Arr.skip(array, num);
+                return (array) => skip(array, num);
             }
         }
-    });
-    /**
-     * Skips the last N elements of an array.
-     *
-     * - If the array is a tuple, the return type is inferred as a tuple with the last N elements removed.
-     * - If the array is a non-empty array and N is a positive integer, returns a readonly array (may be empty).
-     * - Otherwise, returns a readonly array with the last N elements skipped.
-     *
-     * @template E The type of the array (can be a tuple for more precise typing).
-     * @template N The number of elements to skip, constrained to `SmallUint`.
-     * @param array The input array.
-     * @param num The number of elements to skip from the end.
-     * @returns A new array containing the elements after skipping the last N.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.skipLast([1, 2, 3, 4] as const, 2); // [1, 2]
-     *
-     * // Curried usage for pipe composition
-     * const skipLast2 = Arr.skipLast(2);
-     * const result = pipe([1, 2, 3, 4, 5]).map(skipLast2).value;
-     * console.log(result); // [1, 2, 3]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.skipLast = ((...args) => {
+    }
+    Arr.skip = skip;
+    function skipLast(...args) {
         switch (args.length) {
             case 2: {
                 const [array, num] = args;
-                return Arr.sliceClamped(array, 0, Uint32.sub(Arr.size(array), num));
+                return sliceClamped(array, 0, Uint32.sub(Arr.size(array), num));
             }
             case 1: {
                 const [num] = args;
-                return (array) => Arr.skipLast(array, num);
+                return (array) => skipLast(array, num);
             }
         }
-    });
-    // modification (returns new array)
-    /**
-     * Returns a new array with the element at the specified index updated by a function.
-     *
-     * This function provides immutable array updates with type-safe bounds checking. It applies an updater
-     * function to the element at the given index and returns a new array with the transformed value.
-     * The original array is never modified, ensuring immutability.
-     *
-     * **Type Union Behavior:** When the updater function returns a different type `U` than the original
-     * element type `E`, the result type becomes `readonly (E | U)[]` to accommodate both original and
-     * updated element types. This ensures type safety when elements have different types after updating.
-     *
-     * **Bounds Checking:** Unlike native array access which can cause runtime errors, this function
-     * performs safe bounds checking:
-     * - **Valid index:** Creates new array with updated element
-     * - **Invalid index:** Returns the original array unchanged (no errors thrown)
-     * - **Negative index:** Treated as invalid (returns original array)
-     *
-     * **Curried Usage:** Supports currying for functional composition - when called with only index and
-     * updater, returns a reusable function that can be applied to arrays.
-     *
-     * @template E The type of elements in the original array.
-     * @template U The type of the value returned by the updater function.
-     * @param array The input array to update. Can be any readonly array.
-     * @param index The index of the element to update. Must be a non-negative {@link SizeType.ArgArrNonNegative}.
-     *   - **Valid range:** `0 <= index < array.length`
-     *   - **Out of bounds:** Returns original array unchanged
-     *   - **Negative values:** Not allowed by type system (non-negative constraint)
-     * @param updater A function `(prev: E) => U` that transforms the existing element:
-     *   - **prev:** The current element at the specified index
-     *   - **returns:** The new value to place at that index (can be different type)
-     * @returns A new `readonly (E | U)[]` array where:
-     *   - All elements except the target index remain unchanged (type `E`)
-     *   - The element at the target index is replaced with the updater result (type `U`)
-     *   - Type union `E | U` accommodates both original and updated element types
-     *   - If index is out of bounds, returns the original array unchanged
-     *
-     * @example
-     * ```typescript
-     * // Basic usage with same type transformation
-     * const numbers = [1, 2, 3, 4, 5];
-     * const doubled = Arr.toUpdated(numbers, 2, x => x * 2);
-     * // readonly number[] -> [1, 2, 6, 4, 5]
-     *
-     * // Type union when updater returns different type
-     * const mixed = Arr.toUpdated(numbers, 1, x => `value: ${x}`);
-     * // readonly (number | string)[] -> [1, 'value: 2', 3, 4, 5]
-     *
-     * // Complex object updates
-     * const users = [
-     *   { id: 1, name: 'Alice', active: true },
-     *   { id: 2, name: 'Bob', active: false },
-     *   { id: 3, name: 'Charlie', active: true }
-     * ];
-     *
-     * const activatedUser = Arr.toUpdated(users, 1, user => ({
-     *   ...user,
-     *   active: true,
-     *   lastUpdated: new Date()
-     * }));
-     * // Bob is now active with lastUpdated field
-     *
-     * // Bounds checking behavior
-     * const safe1 = Arr.toUpdated([1, 2, 3], 10, x => x * 2); // [1, 2, 3] (index out of bounds)
-     * const safe2 = Arr.toUpdated([1, 2, 3], 0, x => x * 2); // [2, 2, 3] (valid index)
-     * const safe3 = Arr.toUpdated([], 0, x => x); // [] (empty array, index out of bounds)
-     *
-     * // Functional transformations
-     * const products = [
-     *   { name: 'laptop', price: 1000 },
-     *   { name: 'mouse', price: 25 },
-     *   { name: 'keyboard', price: 75 }
-     * ];
-     *
-     * const discounted = Arr.toUpdated(products, 0, product => ({
-     *   ...product,
-     *   price: Math.round(product.price * 0.8), // 20% discount
-     *   onSale: true
-     * }));
-     * // First product now has discounted price and onSale flag
-     *
-     * // Curried usage for reusable updates
-     * const doubleAtIndex2 = Arr.toUpdated(2, (x: number) => x * 2);
-     * const capitalizeAtIndex0 = Arr.toUpdated(0, (s: string) => s.toUpperCase());
-     * const markCompleteAtIndex = (index: number) =>
-     *   Arr.toUpdated(index, (task: {done: boolean}) => ({...task, done: true}));
-     *
-     * const numberArrays = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
-     * const allDoubled = numberArrays.map(doubleAtIndex2);
-     * // [[1, 2, 6], [4, 5, 12], [7, 8, 18]]
-     *
-     * const words = [['hello', 'world'], ['foo', 'bar'], ['type', 'script']];
-     * const capitalized = words.map(capitalizeAtIndex0);
-     * // [['HELLO', 'world'], ['FOO', 'bar'], ['TYPE', 'script']]
-     *
-     * // Pipe composition for data processing
-     * const processArray = (arr: readonly number[]) => pipe(arr)
-     *   .map(Arr.toUpdated(0, x => x * 10)) // Scale first element
-     *   .map(Arr.toUpdated(1, x => typeof x === 'number' ? x + 100 : x)) // Add to second if number
-     *   .value;
-     *
-     * console.log(processArray([1, 2, 3])); // [10, 102, 3]
-     *
-     * // Multiple sequential updates
-     * const pipeline = (data: readonly number[]) => pipe(data)
-     *   .map(Arr.toUpdated(0, x => x * 2))
-     *   .map(Arr.toUpdated(1, x => typeof x === 'number' ? x + 10 : x))
-     *   .map(Arr.toUpdated(2, x => typeof x === 'number' ? x.toString() : x))
-     *   .value;
-     *
-     * console.log(pipeline([1, 2, 3])); // [2, 12, '3'] - readonly (number | string)[]
-     *
-     * // Error-safe updates in data processing
-     * const safeUpdate = <T, U>(
-     *   array: readonly T[],
-     *   index: number,
-     *   updater: (value: T) => U
-     * ) => {
-     *   if (index < 0 || index >= array.length) {
-     *     console.warn(`Index ${index} out of bounds for array of length ${array.length}`);
-     *     return array;
-     *   }
-     *   return Arr.toUpdated(array, index as SizeType.ArgArrNonNegative, updater);
-     * };
-     *
-     * // Advanced: State management pattern
-     * type AppState = {
-     *   users: Array<{id: number, name: string}>;
-     *   currentUserId: number;
-     * };
-     *
-     * const updateUserName = (state: AppState, userId: number, newName: string): AppState => {
-     *   const userIndex = state.users.findIndex(u => u.id === userId);
-     *   if (userIndex === -1) return state;
-     *
-     *   return {
-     *     ...state,
-     *     users: Arr.toUpdated(state.users, userIndex as SizeType.ArgArrNonNegative, user => ({
-     *       ...user,
-     *       name: newName
-     *     }))
-     *   };
-     * };
-     *
-     * // Type inference examples showing union types
-     * expectType<typeof doubled, readonly number[]>('='); // Same type
-     * expectType<typeof mixed, readonly (number | string)[]>('='); // Union type
-     * expectType<typeof doubleAtIndex2, <T extends readonly number[]>(array: T) => readonly (number | number)[]>('=');
-     * expectType<typeof safe1, readonly number[]>('='); // Bounds check preserves type
-     * ```
-     *
-     * @see {@link Array.prototype.with} for the native method with different error handling
-     * @see {@link SizeType.ArgArrNonNegative} for the index type constraint
-     * @see Immutable update patterns for functional programming approaches
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toUpdated = ((...args) => {
+    }
+    Arr.skipLast = skipLast;
+    function set(...args) {
+        switch (args.length) {
+            case 3: {
+                const [array, index, newValue] = args;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                return array.with(index, newValue);
+            }
+            case 2: {
+                const [index, newValue] = args;
+                return (array) => set(array, index, newValue);
+            }
+        }
+    }
+    Arr.set = set;
+    function toUpdated(...args) {
         switch (args.length) {
             case 3: {
                 const [array, index, updater] = args;
-                return index < 0 || index >= array.length
-                    ? array // Return a copy if index is out of bounds
-                    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unsafe-type-assertion
-                        array.with(index, updater(array[index]));
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unsafe-type-assertion
+                return array.with(index, updater(array[index]));
             }
             case 2: {
                 const [index, updater] = args;
-                return (array) => Arr.toUpdated(array, index, updater);
+                return (array) => toUpdated(array, index, updater);
             }
         }
-    });
-    /**
-     * Returns a new array with a new value inserted at the specified index.
-     * Index can be out of bounds (e.g., negative or greater than length), `toSpliced` handles this.
-     * @template E The type of elements in the array.
-     * @param array The input array.
-     * @param index The index at which to insert the new value.
-     * @param newValue The value to insert.
-     * @returns A new array with the value inserted.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.toInserted([1, 2, 3], 1, 10); // [1, 10, 2, 3]
-     *
-     * // Curried usage for pipe composition
-     * const insertAtStart = Arr.toInserted(0, 99);
-     * const result = pipe([1, 2, 3]).map(insertAtStart).value;
-     * console.log(result); // [99, 1, 2, 3]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toInserted = ((...args) => {
+    }
+    Arr.toUpdated = toUpdated;
+    function toInserted(...args) {
         switch (args.length) {
             case 3: {
                 const [array, index, newValue] = args;
@@ -1474,30 +898,12 @@ var Arr;
             }
             case 2: {
                 const [index, newValue] = args;
-                return (array) => Arr.toInserted(array, index, newValue);
+                return (array) => toInserted(array, index, newValue);
             }
         }
-    });
-    /**
-     * Returns a new array with the element at the specified index removed.
-     * If index is out of bounds, `toSpliced` handles this (usually by returning a copy).
-     * @template E The type of elements in the array.
-     * @param array The input array.
-     * @param index The index of the element to remove.
-     * @returns A new array with the element removed.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.toRemoved([1, 2, 3], 1); // [1, 3]
-     *
-     * // Curried usage for pipe composition
-     * const removeFirst = Arr.toRemoved(0);
-     * const result = pipe([10, 20, 30]).map(removeFirst).value;
-     * console.log(result); // [20, 30]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toRemoved = ((...args) => {
+    }
+    Arr.toInserted = toInserted;
+    function toRemoved(...args) {
         switch (args.length) {
             case 2: {
                 const [array, index] = args;
@@ -1505,109 +911,53 @@ var Arr;
             }
             case 1: {
                 const [index] = args;
-                return (array) => Arr.toRemoved(array, index);
+                return (array) => toRemoved(array, index);
             }
         }
-    });
-    /**
-     * Returns a new array with a value added to the end.
-     * @template E The type of the input array (can be a tuple).
-     * @template V The type of the value to add.
-     * @param array The input array.
-     * @param newValue The value to add.
-     * @returns A new array with the value added to the end. Type is `readonly [...E, V]`.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.toPushed([1, 2] as const, 3); // [1, 2, 3]
-     *
-     * // Curried usage for pipe composition
-     * const addZero = Arr.toPushed(0);
-     * const result = pipe([1, 2, 3]).map(addZero).value;
-     * console.log(result); // [1, 2, 3, 0]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toPushed = ((...args) => {
+    }
+    Arr.toRemoved = toRemoved;
+    function toPushed(...args) {
         switch (args.length) {
             case 2: {
                 const [array, newValue] = args;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 return array.toSpliced(array.length, 0, newValue);
             }
             case 1: {
                 const [newValue] = args;
-                return (array) => Arr.toPushed(array, newValue);
+                return (array) => toPushed(array, newValue);
             }
         }
-    });
-    /**
-     * Returns a new array with a value added to the beginning.
-     * @template E The type of the input array (can be a tuple).
-     * @template V The type of the value to add.
-     * @param array The input array.
-     * @param newValue The value to add.
-     * @returns A new array with the value added to the beginning. Type is `readonly [V, ...E]`.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.toUnshifted([1, 2] as const, 0); // [0, 1, 2]
-     *
-     * // Curried usage for pipe composition
-     * const prependZero = Arr.toUnshifted(0);
-     * const result = pipe([1, 2, 3]).map(prependZero).value;
-     * console.log(result); // [0, 1, 2, 3]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toUnshifted = ((...args) => {
+    }
+    Arr.toPushed = toPushed;
+    function toUnshifted(...args) {
         switch (args.length) {
             case 2: {
                 const [array, newValue] = args;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 return array.toSpliced(0, 0, newValue);
             }
             case 1: {
                 const [newValue] = args;
-                return (array) => Arr.toUnshifted(array, newValue);
+                return (array) => toUnshifted(array, newValue);
             }
         }
-    });
-    /**
-     * Fills an array with a value (creates a new filled array).
-     * @param array The array.
-     * @param value The value to fill with.
-     * @param start The start index.
-     * @param end The end index.
-     * @returns A new filled array.
-     * @example
-     * ```typescript
-     * // Regular usage
-     * const arr = [1, 2, 3, 4, 5];
-     * const result = Arr.toFilled(arr, 0, 1, 4);
-     * console.log(result); // [1, 0, 0, 0, 5]
-     *
-     * // Curried usage for pipe composition
-     * const fillWithZeros = Arr.toFilled(0, 1, 3);
-     * const result2 = pipe([1, 2, 3, 4]).map(fillWithZeros).value;
-     * console.log(result2); // [1, 0, 0, 4]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toFilled = ((...args) => {
+    }
+    Arr.toUnshifted = toUnshifted;
+    function toFilled(...args) {
         switch (args.length) {
             case 2: {
                 const [array, value] = args;
-                const cp = castMutable(Arr.copy(array));
-                cp.fill(value);
-                return cp;
+                return Arr.create(asPositiveUint32(array.length), value);
             }
             case 1: {
                 const [value] = args;
-                return (array) => Arr.toFilled(array, value);
+                return (array) => toFilled(array, value);
             }
         }
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.toRangeFilled = ((...args) => {
+    }
+    Arr.toFilled = toFilled;
+    function toRangeFilled(...args) {
         switch (args.length) {
             case 3: {
                 const [array, value, [start, end]] = args;
@@ -1617,50 +967,12 @@ var Arr;
             }
             case 2: {
                 const [value, fillRange] = args;
-                return (array) => Arr.toRangeFilled(array, value, fillRange);
+                return (array) => toRangeFilled(array, value, fillRange);
             }
         }
-    });
-    // searching
-    /**
-     * Safely finds the first element in an array that satisfies a predicate function.
-     *
-     * This function provides type-safe searching with no risk of runtime errors. It returns
-     * the first element that matches the predicate wrapped in an Optional, or Optional.None
-     * if no element is found. The predicate receives the element, its index, and the entire array.
-     *
-     * **Curried Usage:** This function supports currying - when called with only a predicate,
-     * it returns a function that can be applied to arrays, making it ideal for functional composition.
-     *
-     * @template E The type of elements in the array.
-     * @param array The array to search through (when using direct call syntax).
-     * @param predicate A function that tests each element. Called with:
-     *   - `value`: The current element being tested
-     *   - `index`: The index of the current element (branded as `SizeType.Arr`)
-     *   - `arr`: The entire array being searched
-     * @returns An `Optional<E>` containing:
-     *   - `Optional.Some<E>` with the first matching element if found
-     *   - `Optional.None` if no element satisfies the predicate
-     *
-     * @example
-     * ```typescript
-     * const numbers = [1, 2, 3, 4, 5];
-     * const firstEven = Arr.find(numbers, x => x % 2 === 0);
-     * if (Optional.isSome(firstEven)) {
-     *   console.log(firstEven.value); // 2
-     * }
-     *
-     * const users = [{ id: 1, name: 'Alice', age: 25 }, { id: 2, name: 'Bob', age: 30 }];
-     * const adult = Arr.find(users, user => user.age >= 30);
-     * // Optional.Some({ id: 2, name: 'Bob', age: 30 })
-     * ```
-     *
-     * @see {@link findIndex} for finding the index instead of the element
-     * @see {@link indexOf} for finding elements by equality
-     * @see {@link Optional} for working with the returned Optional values
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.find = ((...args) => {
+    }
+    Arr.toRangeFilled = toRangeFilled;
+    function find(...args) {
         switch (args.length) {
             case 2: {
                 const [array, predicate] = args;
@@ -1674,117 +986,31 @@ var Arr;
             }
             case 1: {
                 const [predicate] = args;
-                return (array) => Arr.find(array, predicate);
+                return (array) => find(array, predicate);
             }
         }
-    });
-    /**
-     * Safely finds the index of the first element in an array that satisfies a predicate function.
-     *
-     * This function provides type-safe index searching with no risk of runtime errors. It returns
-     * the index of the first element that matches the predicate wrapped in an Optional, or Optional.None
-     * if no element is found. The returned index is branded as `SizeType.Arr` for type safety.
-     *
-     * **Curried Usage:** This function supports currying - when called with only a predicate,
-     * it returns a function that can be applied to arrays, making it ideal for functional composition.
-     *
-     * @template E The type of elements in the array.
-     * @param array The array to search through (when using direct call syntax).
-     * @param predicate A function that tests each element. Called with:
-     *   - `value`: The current element being tested
-     *   - `index`: The index of the current element (branded as `SizeType.Arr`)
-     * @returns An `Optional<SizeType.Arr>` containing:
-     *   - `Optional.Some<SizeType.Arr>` with the index of the first matching element if found
-     *   - `Optional.None` if no element satisfies the predicate
-     *
-     * @example
-     * ```typescript
-     * // Basic index finding
-     * const fruits = ['apple', 'banana', 'cherry', 'banana'];
-     * const bananaIndex = Arr.findIndex(fruits, fruit => fruit === 'banana');
-     * if (Optional.isSome(bananaIndex)) {
-     *   console.log(bananaIndex.value); // 1 - index of first 'banana'
-     * }
-     *
-     * // Finding with complex conditions
-     * const numbers = [1, 5, 10, 15, 20];
-     * const firstLargeIndex = Arr.findIndex(numbers, (value, index) =>
-     *   value > 10 && index > 1
-     * );
-     * // Optional.Some(3) - index of 15 (first value > 10 after index 1)
-     *
-     * // Finding objects by property
-     * const users = [
-     *   { id: 1, active: false },
-     *   { id: 2, active: true },
-     *   { id: 3, active: true }
-     * ];
-     *
-     * const firstActiveIndex = Arr.findIndex(users, user => user.active);
-     * // Optional.Some(1) - index of first active user
-     *
-     * const inactiveAdminIndex = Arr.findIndex(users, user => !user.active && user.id > 5);
-     * // Optional.None - no inactive user with id > 5
-     *
-     * // Empty array handling
-     * const emptyResult = Arr.findIndex([], x => x > 0); // Optional.None
-     *
-     * // Curried usage for functional composition
-     * const findNegativeIndex = Arr.findIndex((x: number) => x < 0);
-     * const findLongStringIndex = Arr.findIndex((s: string) => s.length > 5);
-     *
-     * const datasets = [
-     *   [1, 2, -3, 4],    // index 2 has negative
-     *   [5, 6, 7, 8],     // no negative
-     *   [-1, 0, 1]        // index 0 has negative
-     * ];
-     *
-     * const negativeIndices = datasets.map(findNegativeIndex);
-     * // [Optional.Some(2), Optional.None, Optional.Some(0)]
-     *
-     * // Using found indices for further operations
-     * const data = ['short', 'medium', 'very long string', 'tiny'];
-     * const longStringIndex = Arr.findIndex(data, s => s.length > 8);
-     *
-     * if (Optional.isSome(longStringIndex)) {
-     *   const index = longStringIndex.value;
-     *   console.log(`Found at position ${index}: ${data[index]}`);
-     *   // "Found at position 2: very long string"
-     * }
-     *
-     * // Pipe composition
-     * const result = pipe(['a', 'bb', 'ccc'])
-     *   .map(findLongStringIndex)
-     *   .map(opt => Optional.unwrapOr(opt, -1))
-     *   .value; // 2 (index of 'ccc')
-     *
-     * // Comparing with native findIndex (which returns -1)
-     * const nativeResult = fruits.findIndex(fruit => fruit === 'grape'); // -1
-     * const safeResult = Arr.findIndex(fruits, fruit => fruit === 'grape'); // Optional.None
-     *
-     * // Safe index usage patterns
-     * const maybeIndex = Arr.findIndex(numbers, x => x > 100);
-     * const indexOrDefault = Optional.unwrapOr(maybeIndex, 0); // 0 (not found)
-     *
-     * // Using index for array access
-     * const foundIndex = Arr.findIndex(fruits, f => f.startsWith('c'));
-     * const foundElement = Optional.isSome(foundIndex)
-     *   ? fruits[foundIndex.value]
-     *   : 'not found';
-     * // 'cherry'
-     *
-     * // Type inference examples
-     * expectType<typeof bananaIndex, Optional<SizeType.Arr>>('=');
-     * expectType<typeof findNegativeIndex, (array: readonly number[]) => Optional<SizeType.Arr>>('=');
-     * ```
-     *
-     * @see {@link find} for finding the element instead of its index
-     * @see {@link indexOf} for finding elements by equality (not predicate)
-     * @see {@link lastIndexOf} for finding the last occurrence
-     * @see {@link Optional} for working with the returned Optional values
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.findIndex = ((...args) => {
+    }
+    Arr.find = find;
+    function findLast(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, predicate] = args;
+                const foundIndex = array.findLastIndex(
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                predicate);
+                return foundIndex === -1
+                    ? Optional.none
+                    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        Optional.some(array[foundIndex]);
+            }
+            case 1: {
+                const [predicate] = args;
+                return (array) => findLast(array, predicate);
+            }
+        }
+    }
+    Arr.findLast = findLast;
+    function findIndex(...args) {
         switch (args.length) {
             case 2: {
                 const [array, predicate] = args;
@@ -1794,33 +1020,27 @@ var Arr;
             }
             case 1: {
                 const [predicate] = args;
-                return (array) => Arr.findIndex(array, predicate);
+                return (array) => findIndex(array, predicate);
             }
         }
-    });
-    /**
-     * Gets the index of a value in an array.
-     * @param array The array to search.
-     * @param searchElement The element to search for.
-     * @param fromIndex The index to start searching from.
-     * @returns The index if found, -1 otherwise.
-     * @example
-     * ```typescript
-     * // Regular usage
-     * const arr = ['a', 'b', 'c', 'b'];
-     * const result = Arr.indexOf(arr, 'b');
-     * if (Optional.isSome(result)) {
-     *   console.log(result.value); // 1 (branded as SizeType.Arr)
-     * }
-     *
-     * // Curried usage for pipe composition
-     * const findB = Arr.indexOf('b');
-     * const result2 = pipe(['a', 'b', 'c']).map(findB).value;
-     * console.log(Optional.unwrapOr(result2, -1)); // 1
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.indexOf = ((...args) => {
+    }
+    Arr.findIndex = findIndex;
+    function findLastIndex(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, predicate] = args;
+                return pipe(array.findLastIndex(
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                predicate)).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
+            }
+            case 1: {
+                const [predicate] = args;
+                return (array) => findLastIndex(array, predicate);
+            }
+        }
+    }
+    Arr.findLastIndex = findLastIndex;
+    function indexOf(...args) {
         switch (args.length) {
             case 2: {
                 const [array, searchElement] = args;
@@ -1829,12 +1049,12 @@ var Arr;
             }
             case 1: {
                 const [searchElement] = args;
-                return (array) => Arr.indexOf(array, searchElement);
+                return (array) => indexOf(array, searchElement);
             }
         }
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.indexOfFrom = ((...args) => {
+    }
+    Arr.indexOf = indexOf;
+    function indexOfFrom(...args) {
         switch (args.length) {
             case 3: {
                 const [array, searchElement, fromIndex] = args;
@@ -1843,33 +1063,12 @@ var Arr;
             }
             case 2: {
                 const [searchElement, fromIndex] = args;
-                return (array) => Arr.indexOfFrom(array, searchElement, fromIndex);
+                return (array) => indexOfFrom(array, searchElement, fromIndex);
             }
         }
-    });
-    /**
-     * Gets the last index of a value in an array.
-     * @param array The array to search.
-     * @param searchElement The element to search for.
-     * @param fromIndex The index to start searching from (searches backwards).
-     * @returns Optional.Some with the index if found, Optional.None otherwise.
-     * @example
-     * ```typescript
-     * // Regular usage
-     * const arr = ['a', 'b', 'c', 'b'];
-     * const result = Arr.lastIndexOf(arr, 'b');
-     * if (Optional.isSome(result)) {
-     *   console.log(result.value); // 3 (branded as SizeType.Arr)
-     * }
-     *
-     * // Curried usage for pipe composition
-     * const findLastB = Arr.lastIndexOf('b');
-     * const result2 = pipe(['a', 'b', 'c', 'b']).map(findLastB).value;
-     * console.log(Optional.unwrapOr(result2, -1)); // 3
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.lastIndexOf = ((...args) => {
+    }
+    Arr.indexOfFrom = indexOfFrom;
+    function lastIndexOf(...args) {
         switch (args.length) {
             case 2: {
                 const [array, searchElement] = args;
@@ -1878,12 +1077,12 @@ var Arr;
             }
             case 1: {
                 const [searchElement] = args;
-                return (array) => Arr.lastIndexOf(array, searchElement);
+                return (array) => lastIndexOf(array, searchElement);
             }
         }
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.lastIndexOfFrom = ((...args) => {
+    }
+    Arr.lastIndexOf = lastIndexOf;
+    function lastIndexOfFrom(...args) {
         switch (args.length) {
             case 3: {
                 const [array, searchElement, fromIndex] = args;
@@ -1892,27 +1091,38 @@ var Arr;
             }
             case 2: {
                 const [searchElement, fromIndex] = args;
-                return (array) => Arr.lastIndexOfFrom(array, searchElement, fromIndex);
+                return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
             }
         }
-    });
-    // reducing value
-    /**
-     * Applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.
-     * This is an alias for `Array.prototype.reduce`.
-     * @template E The type of elements in the array.
-     * @template S The type of the accumulated value.
-     * @param array The input array.
-     * @param callbackfn A function to execute on each element in the array: `(previousValue: S, currentValue: A, currentIndex: SizeType.Arr) => S`.
-     * @param initialValue The initial value of the accumulator.
-     * @returns The single value that results from the reduction.
-     * @example
-     * ```ts
-     * Arr.foldl([1, 2, 3], (sum, n) => sum + n, 0); // 6
-     * Arr.foldl(['a', 'b', 'c'], (acc, str) => acc + str.toUpperCase(), ''); // 'ABC'
-     * ```
-     */
-    Arr.foldl = (...args) => {
+    }
+    Arr.lastIndexOfFrom = lastIndexOfFrom;
+    function every(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, predicate] = args;
+                return array.every((a, i) => predicate(a, asUint32(i)));
+            }
+            case 1: {
+                const [predicate] = args;
+                return (array) => every(array, predicate);
+            }
+        }
+    }
+    Arr.every = every;
+    function some(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, predicate] = args;
+                return array.some((a, i) => predicate(a, asUint32(i)));
+            }
+            case 1: {
+                const [predicate] = args;
+                return (array) => some(array, predicate);
+            }
+        }
+    }
+    Arr.some = some;
+    function foldl(...args) {
         switch (args.length) {
             case 3: {
                 const [array, callbackfn, initialValue] = args;
@@ -1920,31 +1130,12 @@ var Arr;
             }
             case 2: {
                 const [callbackfn, initialValue] = args;
-                return (array) => Arr.foldl(array, callbackfn, initialValue);
+                return (array) => foldl(array, callbackfn, initialValue);
             }
         }
-    };
-    /**
-     * Applies a function against an accumulator and each element in the array (from right to left) to reduce it to a single value.
-     * This is an alias for `Array.prototype.reduceRight`.
-     * @template E The type of elements in the array.
-     * @template S The type of the accumulated value.
-     * @param array The input array.
-     * @param callbackfn A function to execute on each element in the array: `(previousValue: S, currentValue: A, currentIndex: SizeType.Arr) => S`.
-     * @param initialValue The initial value of the accumulator.
-     * @returns The single value that results from the reduction.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.foldr([1, 2, 3], (sum, n) => sum + n, 0); // 6
-     *
-     * // Curried usage for pipe composition
-     * const concatRight = Arr.foldr((acc: string, curr: string) => curr + acc, '');
-     * const result = pipe(['a', 'b', 'c']).map(concatRight).value;
-     * console.log(result); // "abc"
-     * ```
-     */
-    Arr.foldr = (...args) => {
+    }
+    Arr.foldl = foldl;
+    function foldr(...args) {
         switch (args.length) {
             case 3: {
                 const [array, callbackfn, initialValue] = args;
@@ -1952,124 +1143,40 @@ var Arr;
             }
             case 2: {
                 const [callbackfn, initialValue] = args;
-                return (array) => Arr.foldr(array, callbackfn, initialValue);
+                return (array) => foldr(array, callbackfn, initialValue);
             }
         }
-    };
-    /**
-     * Finds the minimum value in an array.
-     * @template E The type of numbers in the array (must extend `number`).
-     * @param array The input array.
-     * @param comparator An optional custom comparator function `(x: N, y: N) => number`. Should return < 0 if x is smaller, 0 if equal, > 0 if x is larger. Defaults to `x - y`.
-     * @returns The minimum value in the array wrapped in Optional.
-     * @example
-     * ```ts
-     * Arr.min([3, 1, 4, 1, 5] as const); // Optional.some(1)
-     * Arr.min([{v:3}, {v:1}], (a,b) => a.v - b.v) // Optional.some({v:1})
-     * Arr.min([]); // Optional.none
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.min = ((array, comparator) => {
+    }
+    Arr.foldr = foldr;
+    function min(array, comparator) {
         if (!Arr.isNonEmpty(array)) {
             return Optional.none;
         }
         const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
         return Optional.some(array.reduce((currentMin, curr) => (cmp(curr, currentMin) < 0 ? curr : currentMin), array[0]));
-    });
-    /**
-     * Finds the maximum value in an array.
-     *
-     * - If the array is non-empty, returns the maximum value.
-     * - If the array is empty, returns `Optional.none`.
-     * - You can provide a custom comparator for arbitrary types.
-     *
-     * @template E The type of elements in the array.
-     * @param array The input array.
-     * @param comparator An optional custom comparator function `(x: A, y: A) => number`. Should return < 0 if x is smaller, 0 if equal, > 0 if x is larger. Defaults to numeric comparison.
-     * @returns The maximum value in the array wrapped in Optional.
-     * @example
-     * ```ts
-     * Arr.max([3, 1, 4, 1, 5] as const); // Optional.some(5)
-     * Arr.max([{v:3}, {v:1}], (a,b) => a.v - b.v) // Optional.some({v:3})
-     * Arr.max([]); // Optional.none
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.max = ((array, comparator) => {
+    }
+    Arr.min = min;
+    function max(array, comparator) {
         const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
         // Find max by finding min with an inverted comparator
-        return Arr.min(array, (x, y) => -cmp(x, y));
-    });
-    /**
-     * Finds the element with the minimum value according to a mapped numeric value.
-     *
-     * - If the array is non-empty, returns the element with the minimum mapped value.
-     * - If the array is empty, returns `Optional.none`.
-     * - You can provide a custom comparator for the mapped values.
-     *
-     * @template E The type of elements in the array.
-     * @template V The type of the value to compare by.
-     * @param array The input array.
-     * @param comparatorValueMapper A function that maps an element to a value for comparison.
-     * @param comparator An optional custom comparator function for the mapped values.
-     * @returns The element with the minimum mapped value wrapped in Optional.
-     * @example
-     * ```ts
-     * const people = [{ name: 'Alice', age: 30 }, { name: 'Bob', age: 20 }] as const;
-     * Arr.minBy(people, p => p.age); // Optional.some({ name: 'Bob', age: 20 })
-     * Arr.minBy([], p => p.age); // Optional.none
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.minBy = ((array, comparatorValueMapper, comparator) => Arr.min(array, (x, y) => comparator === undefined
-        ? Num.from(comparatorValueMapper(x)) -
-            Num.from(comparatorValueMapper(y))
-        : comparator(comparatorValueMapper(x), comparatorValueMapper(y))));
-    /**
-     * Finds the element with the maximum value according to a mapped numeric value.
-     *
-     * - If the array is non-empty, returns the element with the maximum mapped value.
-     * - If the array is empty, returns `Optional.none`.
-     * - You can provide a custom comparator for the mapped values.
-     *
-     * @template E The type of elements in the array.
-     * @template V The type of the value to compare by.
-     * @param array The input array.
-     * @param comparatorValueMapper A function that maps an element to a value for comparison.
-     * @param comparator An optional custom comparator function for the mapped values.
-     * @returns The element with the maximum mapped value wrapped in Optional.
-     * @example
-     * ```ts
-     * const people = [{ name: 'Alice', age: 30 }, { name: 'Bob', age: 20 }] as const;
-     * Arr.maxBy(people, p => p.age); // Optional.some({ name: 'Alice', age: 30 })
-     * Arr.maxBy([], p => p.age); // Optional.none
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.maxBy = ((array, comparatorValueMapper, comparator) => Arr.max(array, (x, y) => comparator === undefined
-        ? Num.from(comparatorValueMapper(x)) -
-            Num.from(comparatorValueMapper(y))
-        : comparator(comparatorValueMapper(x), comparatorValueMapper(y))));
-    /**
-     * Counts the number of elements in an array that satisfy a predicate.
-     * @template E The type of elements in the array.
-     * @param array The input array.
-     * @param predicate A function `(value: A, index: number) => boolean` to test each element for a condition.
-     * @returns The number of elements that satisfy the predicate.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.count([1, 2, 3, 4], (x) => x > 2); // 2
-     *
-     * // Curried usage for pipe composition
-     * const countEvens = Arr.count((x: number) => x % 2 === 0);
-     * const result = pipe([1, 2, 3, 4, 5, 6]).map(countEvens).value;
-     * console.log(result); // 3
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.count = ((...args) => {
+        return min(array, (x, y) => -cmp(x, y));
+    }
+    Arr.max = max;
+    function minBy(array, comparatorValueMapper, comparator) {
+        return min(array, (x, y) => comparator === undefined
+            ? Num.from(comparatorValueMapper(x)) -
+                Num.from(comparatorValueMapper(y))
+            : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
+    }
+    Arr.minBy = minBy;
+    function maxBy(array, comparatorValueMapper, comparator) {
+        return max(array, (x, y) => comparator === undefined
+            ? Num.from(comparatorValueMapper(x)) -
+                Num.from(comparatorValueMapper(y))
+            : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
+    }
+    Arr.maxBy = maxBy;
+    function count(...args) {
         switch (args.length) {
             case 2: {
                 const [array, predicate] = args;
@@ -2077,32 +1184,12 @@ var Arr;
             }
             case 1: {
                 const [predicate] = args;
-                return (array) => Arr.count(array, predicate);
+                return (array) => count(array, predicate);
             }
         }
-    });
-    /**
-     * Groups elements of an array by a key derived from each element and counts the elements in each group.
-     * @template E The type of elements in the array.
-     * @template G The type of the group key (must be a primitive type: `string`, `number`, `boolean`, `symbol`, `bigint`, `null`, or `undefined`).
-     * @param array The input array.
-     * @param grouper A function `(value: A, index: number) => G` that maps an element and its index to a group key.
-     * @returns An `IMap` where keys are group keys and values are the counts of elements in each group.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.countBy([1, 2, 2, 3, 1, 1], (x) => x);
-     * // IMap { 1 => 3, 2 => 2, 3 => 1 }
-     *
-     * // Curried usage for pipe composition
-     * const countByType = Arr.countBy((x: {type: string}) => x.type);
-     * const data = [{type: 'a'}, {type: 'b'}, {type: 'a'}];
-     * const result = pipe(data).map(countByType).value;
-     * // IMap { 'a' => 2, 'b' => 1 }
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.countBy = ((...args) => {
+    }
+    Arr.count = count;
+    function countBy(...args) {
         switch (args.length) {
             case 2: {
                 const [array, grouper] = args;
@@ -2116,45 +1203,16 @@ var Arr;
             }
             case 1: {
                 const [grouper] = args;
-                return (array) => Arr.countBy(array, grouper);
+                return (array) => countBy(array, grouper);
             }
         }
-    });
-    /**
-     * Calculates the sum of numbers in an array.
-     * @param array The input array of numbers.
-     * @returns The sum of the numbers. Returns 0 for an empty array.
-     * @example
-     * ```ts
-     * Arr.sum([1, 2, 3]); // 6
-     * Arr.sum([]); // 0
-     * Arr.sum([-1, 0, 1]); // 0
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.sum = ((array) => array.reduce((prev, curr) => prev + curr, 0));
-    /**
-     * Joins array elements into a string.
-     * @param array The array to join.
-     * @param separator The separator string.
-     * @returns Result.Ok with the joined string, Result.Err if the operation throws.
-     * @example
-     * ```typescript
-     * // Regular usage
-     * const arr = ['Hello', 'World'];
-     * const result = Arr.join(arr, ' ');
-     * if (Result.isOk(result)) {
-     *   console.log(result.value); // "Hello World"
-     * }
-     *
-     * // Curried usage for pipe composition
-     * const joinWithComma = Arr.join(',');
-     * const result2 = pipe(['a', 'b', 'c']).map(joinWithComma).value;
-     * console.log(Result.unwrapOr(result2, '')); // "a,b,c"
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.join = ((...args) => {
+    }
+    Arr.countBy = countBy;
+    function sum(array) {
+        return array.reduce((prev, curr) => prev + curr, 0);
+    }
+    Arr.sum = sum;
+    function join(...args) {
         switch (args.length) {
             case 0:
                 return (array) => joinImpl(array, undefined);
@@ -2170,7 +1228,8 @@ var Arr;
                 return joinImpl(array, separator);
             }
         }
-    });
+    }
+    Arr.join = join;
     const joinImpl = (array, separator) => {
         try {
             const result = array.join(separator);
@@ -2207,26 +1266,34 @@ var Arr;
     // Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     tp(array1[i], array2[i]));
-    /**
-     * Filters an array by excluding elements for which the predicate returns true.
-     * This is the opposite of `Array.prototype.filter`.
-     * @template E The type of elements in the array.
-     * @param array The input array.
-     * @param predicate A function `(a: A, index: number) => boolean` that returns `true` for elements to be excluded.
-     * @returns A new array with elements for which the predicate returned `false`.
-     * @example
-     * ```ts
-     * // Regular usage
-     * Arr.filterNot([1, 2, 3, 4], (x) => x % 2 === 0); // [1, 3] (excludes even numbers)
-     *
-     * // Curried usage for pipe composition
-     * const excludeEvens = Arr.filterNot((x: number) => x % 2 === 0);
-     * const result = pipe([1, 2, 3, 4, 5, 6]).map(excludeEvens).value;
-     * console.log(result); // [1, 3, 5]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.filterNot = ((...args) => {
+    function map(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, mapFn] = args;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                return array.map(mapFn);
+            }
+            case 1: {
+                const [mapFn] = args;
+                return (array) => map(array, mapFn);
+            }
+        }
+    }
+    Arr.map = map;
+    function filter(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, predicate] = args;
+                return array.filter((a, i) => predicate(a, asUint32(i)));
+            }
+            case 1: {
+                const [predicate] = args;
+                return (array) => filter(array, predicate);
+            }
+        }
+    }
+    Arr.filter = filter;
+    function filterNot(...args) {
         switch (args.length) {
             case 2: {
                 const [array, predicate] = args;
@@ -2234,10 +1301,48 @@ var Arr;
             }
             case 1: {
                 const [predicate] = args;
-                return (array) => Arr.filterNot(array, predicate);
+                return (array) => filterNot(array, predicate);
+            }
+        }
+    }
+    Arr.filterNot = filterNot;
+    function flat(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, depth] = args;
+                return array.flat(depth);
+            }
+            case 1: {
+                const [arrayOrDepth] = args;
+                if (typeof arrayOrDepth === 'number') {
+                    const depth = arrayOrDepth;
+                    return (array) => flat(array, depth);
+                }
+                else if (arrayOrDepth === undefined) {
+                    return (array) => flat(array, 1);
+                }
+                else {
+                    return arrayOrDepth.flat(1);
+                }
+            }
+            case 0:
+                return (array) => flat(array, 1);
+        }
+    }
+    Arr.flat = flat;
+    function flatMap(...args) {
+        switch (args.length) {
+            case 2: {
+                const [array, mapFn] = args;
+                return array.flatMap((a, i) => mapFn(a, asUint32(i)));
+            }
+            case 1: {
+                const [mapFn] = args;
+                return (array) => flatMap(array, mapFn);
             }
         }
-    });
+    }
+    Arr.flatMap = flatMap;
     /**
      * Concatenates two arrays.
      * @template E1 The type of the first array (can be a tuple).
@@ -2253,23 +1358,7 @@ var Arr;
      * ```
      */
     Arr.concat = (array1, array2) => [...array1, ...array2];
-    /**
-     * Partitions an array into sub-arrays of a specified size.
-     * The last partition may be smaller if the array length is not a multiple of `chunkSize`.
-     * Returns an empty array if chunkSize < 2.
-     * @template N The size of each partition (must be a number type, typically a literal for precise typing).
-     * @template E The type of elements in the array.
-     * @param array The input array.
-     * @param chunkSize The size of each partition.
-     * @returns An array of arrays, where each inner array has up to `chunkSize` elements.
-     * @example
-     * ```ts
-     * Arr.partition([1, 2, 3, 4, 5, 6], 2); // [[1, 2], [3, 4], [5, 6]]
-     * Arr.partition([1, 2, 3, 4, 5, 6, 7], 3); // [[1, 2, 3], [4, 5, 6], [7]]
-     * ```
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.partition = ((...args) => {
+    function partition(...args) {
         switch (args.length) {
             case 2: {
                 const [array, chunkSize] = args;
@@ -2279,10 +1368,43 @@ var Arr;
             }
             case 1: {
                 const [chunkSize] = args;
-                return (array) => Arr.partition(array, chunkSize);
+                return (array) => partition(array, chunkSize);
             }
         }
-    });
+    }
+    Arr.partition = partition;
+    /**
+     * Reverses a tuple, preserving element types in their new positions.
+     *
+     * The type system precisely tracks the reversal, so the returned tuple
+     * has its element types in the exact reverse order. This is more precise
+     * than array reversal which loses positional type information.
+     *
+     * @template T - The tuple type to reverse
+     * @param array - The input tuple
+     * @returns A new tuple with elements in reverse order and precise typing
+     *
+     * @example
+     * ```typescript
+     * // Basic reversal
+     * const nums = [1, 2, 3] as const;
+     * const reversed = Arr.toReversed(nums); // readonly [3, 2, 1]
+     *
+     * // Mixed types preserved in reverse positions
+     * const mixed = [1, 'hello', true, null] as const;
+     * const revMixed = Arr.toReversed(mixed);
+     * // readonly [null, true, 'hello', 1]
+     *
+     * // Empty and single-element tuples
+     * const empty = [] as const;
+     * const revEmpty = Arr.toReversed(empty); // readonly []
+     * const single = [42] as const;
+     * const revSingle = Arr.toReversed(single); // readonly [42]
+     * ```
+     */
+    Arr.toReversed = (array) => 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    array.toReversed();
     /**
      * Sorts an array by a value derived from its elements, using a numeric mapping.
      * @template E The type of elements in the array.
@@ -2299,172 +1421,25 @@ var Arr;
      * // [{ name: 'Adam', score: 90 }, { name: 'Bob', score: 80 }, { name: 'Eve', score: 70 }]
      * ```
      */
-    Arr.toSortedBy = (array, comparatorValueMapper, comparator) => array.toSorted((x, y) => comparator === undefined
-        ? // This branch assumes B is number if comparator is undefined.
-            // The overloads should handle this, but explicit cast might be needed if B is not number.
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-            comparatorValueMapper(x) -
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-                comparatorValueMapper(y)
-        : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
-    /**
-     * Returns an array of successively reduced values from an array, starting with an initial value.
-     *
-     * This function creates a \"running tally\" by applying a reducer function to each element and
-     * accumulating the results. Unlike {@link reduce} which returns a single final value, `scan`
-     * returns all intermediate accumulated values, providing visibility into the reduction process.
-     *
-     * **Key Differences from Reduce:**
-     * - {@link reduce}: `[1, 2, 3] -> 6` (final sum only)
-     * - `scan`: `[1, 2, 3] -> [0, 1, 3, 6]` (all intermediate sums including initial value)
-     *
-     * **Guaranteed Non-Empty Return:** The result is always a {@link NonEmptyArray}<S> because it includes
-     * the initial value as the first element, even for empty input arrays. This provides type safety
-     * and eliminates the need for empty array checks.
-     *
-     * **Array Length Relationship:** `result.length === array.length + 1` (includes initial value)
-     *
-     * **Curried Usage:** Supports currying for functional composition - when called with only the reducer
-     * and initial value, returns a reusable function that can be applied to arrays.
-     *
-     * @template E The type of elements in the input array.
-     * @template S The type of the accumulated values and the initial value.
-     * @param array The input array to scan over. Can be empty (result will still contain the initial value).
-     * @param reducer A function `(accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S` that:
-     *   - **accumulator:** The current accumulated value (starts with `init`, then previous results)
-     *   - **currentValue:** The current array element being processed
-     *   - **currentIndex:** The 0-based index of the current element (typed as {@link SizeType.Arr})
-     *   - **returns:** The new accumulated value to include in the result array
-     * @param init The initial accumulated value. Becomes the first element of the result array.
-     * @returns A {@link NonEmptyArray}<S> of accumulated values with length `array.length + 1`:
-     *   - `result[0]` is always the `init` value
-     *   - `result[i+1]` is the result of applying the reducer to `result[i]` and `array[i]`
-     *   - Guaranteed to be non-empty regardless of input array length
-     *
-     * @example
-     * ```typescript
-     * // Basic running sum example
-     * const numbers = [1, 2, 3, 4];
-     * const runningSum = Arr.scan(numbers, (acc, curr) => acc + curr, 0);
-     * // NonEmptyArray<number> -> [0, 1, 3, 6, 10]
-     * //                           ^  ^  ^  ^  ^
-     * //                           |  |  |  |  └─ 0+1+2+3+4 = 10
-     * //                           |  |  |  └─ 0+1+2+3 = 6
-     * //                           |  |  └─ 0+1+2 = 3
-     * //                           |  └─ 0+1 = 1
-     * //                           └─ init = 0
-     *
-     * // Difference from reduce
-     * const reduced = numbers.reduce((acc, curr) => acc + curr, 0); // 10 (final only)
-     * const scanned = Arr.scan(numbers, (acc, curr) => acc + curr, 0); // [0, 1, 3, 6, 10] (all steps)
-     *
-     * // Running product
-     * const factorial = Arr.scan([1, 2, 3, 4, 5], (acc, curr) => acc * curr, 1);
-     * // [1, 1, 2, 6, 24, 120] - factorial sequence
-     *
-     * // Running maximum
-     * const temperatures = [20, 25, 18, 30, 22];
-     * const runningMax = Arr.scan(temperatures, (max, temp) => Math.max(max, temp), -Infinity);
-     * // [-Infinity, 20, 25, 25, 30, 30]
-     *
-     * // Building strings incrementally
-     * const words = ['Hello', 'beautiful', 'world'];
-     * const sentences = Arr.scan(words, (sentence, word) => sentence + ' ' + word, '');
-     * // ['', ' Hello', ' Hello beautiful', ' Hello beautiful world']
-     *
-     * // Array accumulation (collecting elements)
-     * const items = ['a', 'b', 'c'];
-     * const growing = Arr.scan(items, (acc, item) => [...acc, item], [] as string[]);
-     * // [[], ['a'], ['a', 'b'], ['a', 'b', 'c']]
-     *
-     * // Financial running balance
-     * const transactions = [100, -20, 50, -30];
-     * const balances = Arr.scan(transactions, (balance, transaction) => balance + transaction, 1000);
-     * // [1000, 1100, 1080, 1130, 1100] - account balance after each transaction
-     *
-     * // Using index information
-     * const letters = ['a', 'b', 'c'];
-     * const indexed = Arr.scan(letters, (acc, letter, index) => acc + `${index}:${letter} `, '');
-     * // ['', '0:a ', '0:a 1:b ', '0:a 1:b 2:c ']
-     *
-     * // Edge cases
-     * const emptyArray: number[] = [];
-     * const emptyResult = Arr.scan(emptyArray, (acc, curr) => acc + curr, 42);
-     * // [42] - NonEmptyArray even for empty input
-     *
-     * const singleElement = Arr.scan([5], (acc, curr) => acc * curr, 2);
-     * // [2, 10] - init value plus one result
-     *
-     * // Complex object accumulation
-     * const sales = [
-     *   { product: 'A', amount: 100 },
-     *   { product: 'B', amount: 200 },
-     *   { product: 'A', amount: 150 }
-     * ];
-     *
-     * const runningSales = Arr.scan(sales, (totals, sale) => ({
-     *   ...totals,
-     *   [sale.product]: (totals[sale.product] || 0) + sale.amount
-     * }), {} as Record<string, number>);
-     * // [
-     * //   {},
-     * //   { A: 100 },
-     * //   { A: 100, B: 200 },
-     * //   { A: 250, B: 200 }
-     * // ]
-     *
-     * // Curried usage for functional composition
-     * const runningSumFn = Arr.scan((acc: number, curr: number) => acc + curr, 0);
-     * const runningProductFn = Arr.scan((acc: number, curr: number) => acc * curr, 1);
-     * const collectingFn = Arr.scan((acc: string[], curr: string) => [...acc, curr], [] as string[]);
-     *
-     * const datasets = [[1, 2, 3], [4, 5], [6, 7, 8, 9]];
-     * const allSums = datasets.map(runningSumFn);
-     * // [
-     * //   [0, 1, 3, 6],
-     * //   [0, 4, 9],
-     * //   [0, 6, 13, 21, 30]
-     * // ]
-     *
-     * // Pipe composition for data analysis
-     * const analysisResult = pipe([10, 20, 30, 40])
-     *   .map(runningSumFn)
-     *   .map(sums => sums.slice(1)) // Remove initial value to get pure running sums
-     *   .map(sums => sums.map((sum, i) => ({ step: i + 1, total: sum })))
-     *   .value;
-     * // [{ step: 1, total: 10 }, { step: 2, total: 30 }, { step: 3, total: 60 }, { step: 4, total: 100 }]
-     *
-     * // Advanced: State machine simulation
-     * type State = 'idle' | 'loading' | 'success' | 'error';
-     * type Event = 'start' | 'complete' | 'fail' | 'reset';
-     *
-     * const events: Event[] = ['start', 'complete', 'reset', 'start', 'fail'];
-     * const stateTransition = (state: State, event: Event): State => {
-     *   switch (state) {
-     *     case 'idle': return event === 'start' ? 'loading' : state;
-     *     case 'loading': return event === 'complete' ? 'success' : event === 'fail' ? 'error' : state;
-     *     case 'success': return event === 'reset' ? 'idle' : state;
-     *     case 'error': return event === 'reset' ? 'idle' : state;
-     *   }
-     * };
-     *
-     * const stateHistory = Arr.scan(events, stateTransition, 'idle' as State);
-     * // ['idle', 'loading', 'success', 'idle', 'loading', 'error']
-     *
-     * // Type inference examples
-     * expectType<typeof runningSum, NonEmptyArray<number>>('=');
-     * expectType<typeof emptyResult, NonEmptyArray<number>>('=');
-     * expectType<typeof runningSumFn, <T extends readonly number[]>(array: T) => NonEmptyArray<number>>('=');
-     * expectType<typeof stateHistory, NonEmptyArray<State>>('=');
-     * ```
-     *
-     * @see {@link reduce} for getting only the final accumulated value
-     * @see {@link NonEmptyArray} for understanding the guaranteed non-empty return type
-     * @see {@link SizeType.Arr} for the index parameter type
-     * @see Array.prototype.reduce for the standard reduce function
-     */
+    Arr.toSorted = (...[array, comparator]) => 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    array.toSorted(
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.scan = ((...args) => {
+    comparator ??
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        ((x, y) => x - y));
+    function toSortedBy(array, comparatorValueMapper, comparator) {
+        return array.toSorted((x, y) => comparator === undefined
+            ? // This branch assumes V is number if comparator is undefined.
+                // The overloads should handle this, but explicit cast might be needed if V is not number.
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                comparatorValueMapper(x) -
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    comparatorValueMapper(y)
+            : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
+    }
+    Arr.toSortedBy = toSortedBy;
+    function scan(...args) {
         switch (args.length) {
             case 3: {
                 const [array, reducer, init] = args;
@@ -2478,161 +1453,12 @@ var Arr;
             }
             case 2: {
                 const [reducer, init] = args;
-                return (array) => Arr.scan(array, reducer, init);
+                return (array) => scan(array, reducer, init);
             }
         }
-    });
-    /**
-     * Groups elements of an array by a key derived from each element, returning an immutable {@link IMap}.
-     *
-     * This function categorizes array elements into groups based on a computed key, using the efficient
-     * {@link IMap} data structure for the result. The grouper function receives both the element and its
-     * index, enabling flexible grouping strategies.
-     *
-     * **MapSetKeyType Constraint:** The group key type `G` must extend {@link MapSetKeyType}, which includes
-     * primitive types that can be used as Map keys (string, number, boolean, symbol, null, undefined).
-     * This constraint ensures type safety and efficient key-based operations.
-     *
-     * **IMap Return Type:** Returns an {@link IMap}<G, readonly E[]> where:
-     * - Keys are the computed group identifiers of type `G`
-     * - Values are immutable arrays containing all elements that belong to each group
-     * - Preserves insertion order of first occurrence of each group
-     * - Maintains type safety with precise generic types
-     *
-     * **Curried Usage:** Supports currying for functional composition - when called with only the grouper
-     * function, returns a reusable function that can be applied to arrays.
-     *
-     * @template E The type of elements in the input array.
-     * @template G The type of the group key, constrained to {@link MapSetKeyType} (primitives usable as Map keys).
-     *   Must be one of: `string | number | boolean | symbol | null | undefined`
-     * @param array The input array to group. Can be empty (returns empty {@link IMap}).
-     * @param grouper A function `(value: E, index: SizeType.Arr) => G` that computes the group key for each element.
-     *   - **value:** The current array element
-     *   - **index:** The 0-based index of the element (typed as {@link SizeType.Arr})
-     *   - **returns:** The group key (must be {@link MapSetKeyType})
-     * @returns An {@link IMap}<G, readonly E[]> where:
-     *   - Keys are unique group identifiers computed by the grouper function
-     *   - Values are immutable arrays of elements belonging to each group
-     *   - Empty groups are not included (only groups with at least one element)
-     *   - Insertion order is preserved based on first occurrence of each group key
-     *
-     * @example
-     * ```typescript
-     * // Basic grouping by object property
-     * const products = [
-     *   { type: 'fruit', name: 'apple', price: 1.2 },
-     *   { type: 'vegetable', name: 'carrot', price: 0.8 },
-     *   { type: 'fruit', name: 'banana', price: 0.9 },
-     *   { type: 'vegetable', name: 'broccoli', price: 2.1 },
-     *   { type: 'fruit', name: 'orange', price: 1.5 }
-     * ];
-     *
-     * const byType = Arr.groupBy(products, item => item.type);
-     * // IMap<string, readonly Product[]> {
-     * //   'fruit' => [
-     * //     { type: 'fruit', name: 'apple', price: 1.2 },
-     * //     { type: 'fruit', name: 'banana', price: 0.9 },
-     * //     { type: 'fruit', name: 'orange', price: 1.5 }
-     * //   ],
-     * //   'vegetable' => [
-     * //     { type: 'vegetable', name: 'carrot', price: 0.8 },
-     * //     { type: 'vegetable', name: 'broccoli', price: 2.1 }
-     * //   ]
-     * // }
-     *
-     * // Access grouped results with IMap methods
-     * const fruits = IMap.get(byType, 'fruit'); // Optional<readonly Product[]>
-     * const fruitCount = Optional.map(fruits, arr => arr.length); // Optional<number>
-     * const fruitNames = Optional.map(fruits, arr => arr.map(p => p.name)); // Optional<string[]>
-     *
-     * // Grouping by computed values
-     * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-     * const byParity = Arr.groupBy(numbers, n => n % 2 === 0 ? 'even' : 'odd');
-     * // IMap<string, readonly number[]> {
-     * //   'odd' => [1, 3, 5, 7, 9],
-     * //   'even' => [2, 4, 6, 8, 10]
-     * // }
-     *
-     * // Grouping by price ranges using index information
-     * const byPriceRange = Arr.groupBy(products, (product, index) => {
-     *   const category = product.price < 1.0 ? 'cheap' :
-     *                   product.price < 2.0 ? 'moderate' : 'expensive';
-     *   return `${category}_${index < 2 ? 'early' : 'late'}`;
-     * });
-     *
-     * // MapSetKeyType constraint examples (valid key types)
-     * const byStringKey = Arr.groupBy([1, 2, 3], n => `group_${n}`); // string keys
-     * const byNumberKey = Arr.groupBy(['a', 'b', 'c'], (_, i) => i); // number keys
-     * const byBooleanKey = Arr.groupBy([1, 2, 3, 4], n => n > 2); // boolean keys
-     * const bySymbolKey = Arr.groupBy([1, 2], n => Symbol(n.toString())); // symbol keys
-     *
-     * // Edge cases
-     * const emptyGroup = Arr.groupBy([], x => x); // IMap<never, readonly never[]> (empty)
-     * const singleGroup = Arr.groupBy([1, 2, 3], () => 'all'); // All elements in one group
-     * const uniqueGroups = Arr.groupBy([1, 2, 3], x => x); // Each element in its own group
-     *
-     * // Curried usage for functional composition
-     * const groupByType = Arr.groupBy((item: { type: string }) => item.type);
-     * const groupByLength = Arr.groupBy((str: string) => str.length);
-     * const groupByFirstChar = Arr.groupBy((str: string) => str.charAt(0).toLowerCase());
-     *
-     * const datasets = [
-     *   [{ type: 'A' }, { type: 'B' }, { type: 'A' }],
-     *   [{ type: 'C' }, { type: 'A' }],
-     *   [{ type: 'B' }, { type: 'B' }, { type: 'C' }]
-     * ];
-     * const allGrouped = datasets.map(groupByType);
-     * // Array of IMap instances, each grouped by type
-     *
-     * // Pipe composition for complex data processing
-     * const words = ['apple', 'banana', 'apricot', 'blueberry', 'avocado', 'blackberry'];
-     * const processedGroups = pipe(words)
-     *   .map(groupByFirstChar)
-     *   .map(groupMap => IMap.map(groupMap, (wordsInGroup, firstLetter) => ({
-     *     letter: firstLetter,
-     *     count: wordsInGroup.length,
-     *     longest: wordsInGroup.reduce((longest, word) =>
-     *       word.length > longest.length ? word : longest
-     *     )
-     *   })))
-     *   .value;
-     * // IMap<string, {letter: string, count: number, longest: string}>
-     *
-     * // Advanced: Grouping with complex transformations
-     * const students = [
-     *   { name: 'Alice', grade: 85, subject: 'Math' },
-     *   { name: 'Bob', grade: 92, subject: 'Science' },
-     *   { name: 'Charlie', grade: 78, subject: 'Math' },
-     *   { name: 'Diana', grade: 96, subject: 'Science' }
-     * ];
-     *
-     * const byGradeLevel = Arr.groupBy(students, student => {
-     *   if (student.grade >= 90) return 'A';
-     *   if (student.grade >= 80) return 'B';
-     *   return 'C';
-     * });
-     *
-     * // Working with the grouped results
-     * const aStudents = Optional.unwrapOr(IMap.get(byGradeLevel, 'A'), []);
-     * const averageAGrade = aStudents.length > 0
-     *   ? aStudents.reduce((sum, s) => sum + s.grade, 0) / aStudents.length
-     *   : 0;
-     *
-     * // Type inference examples
-     * expectType<typeof byType, IMap<string, readonly typeof products[number][]>>('=');
-     * expectType<typeof byParity, IMap<string, readonly number[]>>('=');
-     * expectType<typeof groupByType, <T extends {type: string}>(array: readonly T[]) => IMap<string, readonly T[]>>('=');
-     * expectType<typeof emptyGroup, IMap<never, readonly never[]>>('=');
-     * ```
-     *
-     * @see {@link IMap} for working with the returned immutable map
-     * @see {@link MapSetKeyType} for understanding valid key types
-     * @see {@link IMap.get} for safely accessing grouped results
-     * @see {@link IMap.map} for transforming grouped data
-     * @see {@link Optional} for handling potentially missing groups
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.groupBy = ((...args) => {
+    }
+    Arr.scan = scan;
+    function groupBy(...args) {
         switch (args.length) {
             case 2: {
                 const [array, grouper] = args;
@@ -2652,10 +1478,11 @@ var Arr;
             }
             case 1: {
                 const [grouper] = args;
-                return (array) => Arr.groupBy(array, grouper);
+                return (array) => groupBy(array, grouper);
             }
         }
-    });
+    }
+    Arr.groupBy = groupBy;
     /**
      * Creates a new array with unique elements from the input array. Order is preserved from the first occurrence.
      * Uses `Set` internally for efficient uniqueness checking.
@@ -2667,7 +1494,9 @@ var Arr;
      * Arr.uniq([1, 2, 2, 3, 1, 4]); // [1, 2, 3, 4]
      * ```
      */
-    Arr.uniq = (array) => Array.from(new Set(array));
+    Arr.uniq = (array) => 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    Array.from(new Set(array));
     /**
      * Creates a new array with unique elements from the input array, based on the values returned by `mapFn`.
      *
@@ -2689,9 +1518,9 @@ var Arr;
      * Arr.uniqBy(users, user => user.id); // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
      * ```
      */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    Arr.uniqBy = ((array, mapFn) => {
+    Arr.uniqBy = (array, mapFn) => {
         const mut_mappedValues = new Set();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         return array.filter((val) => {
             const mappedValue = mapFn(val);
             if (mut_mappedValues.has(mappedValue))
@@ -2699,7 +1528,7 @@ var Arr;
             mut_mappedValues.add(mappedValue);
             return true;
         });
-    });
+    };
     // set operations & equality
     /**
      * Checks if two arrays are equal by performing a shallow comparison of their elements.
@@ -2842,6 +1671,95 @@ var Arr;
         }
         return mut_result;
     };
+    // iterators
+    /**
+     * Returns an iterable of key-value pairs for every entry in the array.
+     *
+     * This function returns an array where each element is a tuple containing the index and value.
+     * The indices are branded as `SizeType.Arr` for type safety.
+     *
+     * @template Ar The exact type of the input array.
+     * @param array The array to get entries from.
+     * @returns An array of `[index, value]` pairs.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const fruits = ['apple', 'banana', 'cherry'];
+     * const entries = Arr.entries(fruits); // [[0, 'apple'], [1, 'banana'], [2, 'cherry']]
+     *
+     * // Curried usage
+     * const getEntries = Arr.entries;
+     * const result = getEntries(['a', 'b']); // [[0, 'a'], [1, 'b']]
+     *
+     * // With tuples
+     * const tuple = [10, 20, 30] as const;
+     * const tupleEntries = Arr.entries(tuple); // [[0, 10], [1, 20], [2, 30]]
+     * ```
+     */
+    function* entries(array) {
+        for (const [index, value] of array.entries()) {
+            yield [asUint32(index), value];
+        }
+    }
+    Arr.entries = entries;
+    /**
+     * Returns an iterable of values in the array.
+     *
+     * This function is essentially an identity function that returns a copy of the array.
+     * It's included for API completeness and consistency with native Array methods.
+     *
+     * @template Ar The exact type of the input array.
+     * @param array The array to get values from.
+     * @returns A copy of the input array.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const numbers = [1, 2, 3];
+     * const values = Arr.values(numbers); // [1, 2, 3]
+     *
+     * // Curried usage
+     * const getValues = Arr.values;
+     * const result = getValues(['a', 'b']); // ['a', 'b']
+     * ```
+     */
+    function* values(array) {
+        for (const value of array.values()) {
+            yield value;
+        }
+    }
+    Arr.values = values;
+    /**
+     * Returns an iterable of keys in the array.
+     *
+     * This function returns an array of branded indices (`SizeType.Arr`) for type safety.
+     *
+     * @template Ar The exact type of the input array.
+     * @param array The array to get indices from.
+     * @returns An array of indices.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const fruits = ['apple', 'banana', 'cherry'];
+     * const indices = Arr.indices(fruits); // [0, 1, 2]
+     *
+     * // Curried usage
+     * const getIndices = Arr.indices;
+     * const result = getIndices(['a', 'b']); // [0, 1]
+     *
+     * // Empty array
+     * const empty: string[] = [];
+     * const emptyIndices = Arr.indices(empty); // []
+     * ```
+     */
+    function* indices(array) {
+        for (const key of array.keys()) {
+            yield asUint32(key);
+        }
+    }
+    Arr.indices = indices;
     // aliases
     /**
      * Alias for `head`. Returns the first element of an array.
@@ -2857,22 +1775,37 @@ var Arr;
      * Alias for `skip`. Skips the first N elements of an array.
      * @see {@link skip}
      */
-    Arr.drop = Arr.skip;
+    Arr.drop = skip;
     /**
      * Alias for `foldl`. Applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.
      * @see {@link foldl}
      */
-    Arr.reduce = Arr.foldl;
+    Arr.reduce = foldl;
     /**
      * Alias for `foldr`. Applies a function against an accumulator and each element in the array (from right to left) to reduce it to a single value.
      * @see {@link foldr}
      */
-    Arr.reduceRight = Arr.foldr;
+    Arr.reduceRight = foldr;
     /**
      * Alias for `partition`. Splits an array into chunks of a specified size.
      * @see {@link partition}
      */
-    Arr.chunk = Arr.partition;
+    Arr.chunk = partition;
+    /**
+     * Alias for `create`. Creates a new array of the specified length, with each position filled with the provided initial value.
+     * @see {@link create}
+     */
+    Arr.newArray = Arr.create;
+    /**
+     * Alias for `size`. Returns the length of an array.
+     * @see {@link size}
+     */
+    Arr.length = Arr.size;
+    /**
+     * Alias for `indices`. Returns an iterable of keys in the array.
+     * @see {@link indices}
+     */
+    Arr.keys = indices;
 })(Arr || (Arr = {}));
 
 export { Arr };