ts-data-forge 1.5.2 → 2.0.0

package/dist/array/array-utils.d.mts

@@ -9,6 +9,9 @@ import { Optional, Result } from '../functional/index.mjs';
  * ensuring immutability.
  */
 export declare namespace Arr {
+    type ArrayIndex<Ar extends readonly unknown[]> = IsFixedLengthList<Ar> extends true ? IndexOfTuple<Ar> : SizeType.Arr;
+    type ArgArrayIndex<Ar extends readonly unknown[]> = IsFixedLengthList<Ar> extends true ? IndexOfTuple<Ar> : SizeType.ArgArr;
+    type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> = IsFixedLengthList<Ar> extends true ? IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar> : SizeType.ArgArrWithNegative;
     /**
      * Returns the size (length) of an array as a type-safe branded integer.
      *
@@ -34,7 +37,7 @@ export declare namespace 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
@@ -64,13 +67,6 @@ export declare namespace 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],
@@ -97,9 +93,7 @@ export declare namespace Arr {
      * @see {@link isEmpty} for checking if size is 0
      * @see {@link isNonEmpty} for checking if size > 0
      */
-    export function size<Ar extends NonEmptyArray<unknown>>(array: Ar): IntersectBrand<PositiveNumber, SizeType.Arr>;
-    export function size<Ar extends readonly unknown[]>(array: Ar): SizeType.Arr;
-    export const length: typeof size;
+    export const size: <Ar extends readonly unknown[]>(array: Ar) => Ar extends NonEmptyArray<unknown> ? IntersectBrand<PositiveNumber, SizeType.Arr> : SizeType.Arr;
     /**
      * Type guard that checks if a value is an array, excluding types that cannot be arrays.
      * This function refines the type by filtering out non-array types from unions.
@@ -149,26 +143,11 @@ export declare namespace 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)) {
@@ -177,12 +156,6 @@ export declare namespace 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)
@@ -223,16 +196,14 @@ export declare namespace 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
@@ -257,7 +228,7 @@ export declare namespace 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
@@ -318,7 +289,7 @@ export declare namespace Arr {
      * Arr.isArrayOfLength([1, 2], 3); // false
      * ```
      */
-    export const isArrayOfLength: <E, N extends SizeType.ArgArrNonNegative>(array: readonly E[], len: N) => array is ArrayOfLength<N, E>;
+    export const isArrayOfLength: <E, N extends SizeType.ArgArr>(array: readonly E[], len: N) => array is ArrayOfLength<N, E>;
     /**
      * Checks if an array has at least a specific length.
      * @template E The type of elements in the array.
@@ -335,7 +306,7 @@ export declare namespace Arr {
      * Arr.isArrayAtLeastLength([1], 2); // false
      * ```
      */
-    export const isArrayAtLeastLength: <E, N extends SizeType.ArgArrNonNegative>(array: readonly E[], len: N) => array is ArrayAtLeastLen<N, E>;
+    export const isArrayAtLeastLength: <E, N extends SizeType.ArgArr>(array: readonly E[], len: N) => array is ArrayAtLeastLen<N, E>;
     /**
      * Checks if an index is within the valid range of an array (i.e., `0 <= index < array.length`).
      * @template E The type of elements in the array.
@@ -351,7 +322,7 @@ export declare namespace Arr {
      * Arr.indexIsInRange([], 0); // false
      * ```
      */
-    export const indexIsInRange: <E>(array: readonly E[], index: SizeType.ArgArrNonNegative) => boolean;
+    export const indexIsInRange: <E>(array: readonly E[], index: SizeType.ArgArr) => boolean;
     /**
      * Creates an array of zeros with the specified length.
      *
@@ -388,18 +359,7 @@ export declare namespace Arr {
      * expectType<typeof maybeEmpty, readonly 0[]>('=');
      * ```
      */
-    /**
-     * Create array of zeros with compile-time length.
-     */
-    export function zeros<N extends SmallUint>(len: N): ArrayOfLength<N, 0>;
-    /**
-     * Create non-empty array of zeros.
-     */
-    export function zeros(len: SizeType.ArgArrPositive): NonEmptyArray<0>;
-    /**
-     * Create array of zeros.
-     */
-    export function zeros(len: SizeType.ArgArrNonNegative): readonly 0[];
+    export const zeros: <N extends SizeType.ArgArr>(len: N) => N extends SmallUint ? ArrayOfLength<N, 0> : N extends SizeType.ArgArrPositive ? NonEmptyArray<0> : readonly 0[];
     /**
      * Creates a sequence of consecutive integers from 0 to `len-1`.
      *
@@ -441,9 +401,7 @@ export declare namespace Arr {
      * expectType<typeof single, readonly [0]>('=');
      * ```
      */
-    export function seq<N extends SmallUint>(len: N): Seq<N>;
-    export function seq(len: SizeType.ArgArrPositive): NonEmptyArray<SizeType.Arr>;
-    export function seq(len: SizeType.ArgArrNonNegative): readonly SizeType.Arr[];
+    export const seq: <N extends SizeType.ArgArr>(len: N) => N extends SmallUint ? Seq<N> : N extends SizeType.ArgArrPositive ? NonEmptyArray<SizeType.Arr> : readonly SizeType.Arr[];
     /**
      * Creates a new array of the specified length, with each position filled with the provided initial value.
      *
@@ -492,10 +450,7 @@ export declare namespace Arr {
      * @see {@link zeros} for creating arrays filled with zeros
      * @see {@link seq} for creating sequences of consecutive integers
      */
-    export function create<const V, N extends SmallUint>(len: N, init: V): ArrayOfLength<N, V>;
-    export function create<const V>(len: SizeType.ArgArrPositive, init: V): NonEmptyArray<V>;
-    export function create<const V>(len: SizeType.ArgArrNonNegative, init: V): readonly V[];
-    export const newArray: typeof create;
+    export const create: <const V, N extends SizeType.ArgArr>(len: N, init: V) => N extends SmallUint ? ArrayOfLength<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
     /**
      * Creates an array from a generator function.
      *
@@ -678,7 +633,10 @@ export declare namespace Arr {
      *
      * // 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]
+     * const fibonacci = Arr.range(0, 10).reduce((acc, _, i) => {
+     *   if (i <= 1) return [...acc, i];
+     *   return [...acc, acc[i-1] + acc[i-2]];
+     * }, [] 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
@@ -808,8 +766,8 @@ export declare namespace Arr {
      * @see {@link Optional.unwrapOr} for safe unwrapping with defaults
      * @see {@link Optional.map} for transforming Optional values
      */
-    export function at<E>(array: readonly E[], index: SizeType.ArgArr): Optional<E>;
-    export function at(index: SizeType.ArgArr): <E>(array: readonly E[]) => Optional<E>;
+    export function at<Ar extends readonly unknown[]>(array: Ar, index: ArgArrayIndexWithNegative<Ar>): Optional<Ar[number]>;
+    export function at(index: SizeType.ArgArrWithNegative): <E>(array: readonly E[]) => Optional<E>;
     /**
      * Returns the first element of an array wrapped in an Optional.
      *
@@ -881,10 +839,7 @@ export declare namespace Arr {
      * @see {@link at} for accessing elements at specific indices
      * @see {@link tail} for getting all elements except the first
      */
-    export function head(array: readonly []): Optional.None;
-    export function head<E, L extends readonly unknown[]>(array: readonly [E, ...L]): Optional.Some<E>;
-    export function head<E>(array: NonEmptyArray<E>): Optional.Some<E>;
-    export function head<E>(array: readonly E[]): Optional<E>;
+    export const head: <Ar extends readonly unknown[]>(array: Ar) => Ar extends readonly [] ? Optional.None : Ar extends readonly [infer E, ...unknown[]] ? Optional.Some<E> : Ar extends NonEmptyArray<infer E> ? Optional.Some<E> : Optional<Ar[number]>;
     /**
      * Returns the last element of an array wrapped in an Optional.
      *
@@ -965,10 +920,7 @@ export declare namespace Arr {
      * @see {@link at} for accessing elements at specific indices with negative indexing support
      * @see {@link butLast} for getting all elements except the last
      */
-    export function last(array: readonly []): Optional.None;
-    export function last<Ar extends readonly unknown[], L>(array: readonly [...Ar, L]): Optional.Some<L>;
-    export function last<E>(array: NonEmptyArray<E>): Optional.Some<E>;
-    export function last<E>(array: readonly E[]): Optional<E>;
+    export const last: <Ar extends readonly unknown[]>(array: Ar) => Ar extends readonly [] ? Optional.None : Ar extends readonly [...unknown[], infer E] ? Optional.Some<E> : Ar extends NonEmptyArray<infer E> ? Optional.Some<E> : Optional<Ar[number]>;
     /**
      * Slices an array with automatically clamped start and end indices for safe bounds handling.
      *
@@ -1052,8 +1004,8 @@ export declare namespace Arr {
      * @see {@link skip} for skipping the first N elements
      * @see {@link takeLast} for taking the last N elements
      */
-    export function sliceClamped<E>(array: readonly E[], start: SizeType.ArgArr, end: SizeType.ArgArr): readonly E[];
-    export function sliceClamped(start: SizeType.ArgArr, end: SizeType.ArgArr): <E>(array: readonly E[]) => readonly E[];
+    export function sliceClamped<Ar extends readonly unknown[]>(array: Ar, start: ArgArrayIndexWithNegative<Ar>, end: ArgArrayIndexWithNegative<Ar>): readonly Ar[number][];
+    export function sliceClamped(start: SizeType.ArgArrWithNegative, end: SizeType.ArgArrWithNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * 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).
@@ -1103,12 +1055,8 @@ export declare namespace Arr {
      * console.log(result); // [1, 2, 3]
      * ```
      */
-    export function take<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.Take<N, Ar>;
-    export function take<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.Take<N, Ar>;
-    export function take<E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): NonEmptyArray<E>;
-    export function take(num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => NonEmptyArray<E>;
-    export function take<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-    export function take(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
+    export function take<Ar extends readonly unknown[], N extends SizeType.ArgArr>(array: Ar, num: N): N extends SmallUint ? List.Take<N, Ar> : N extends SizeType.ArgArrPositive ? Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][] : readonly Ar[number][];
+    export function take<N extends SizeType.ArgArr>(num: N): <Ar extends readonly unknown[]>(array: Ar) => N extends SmallUint ? List.Take<N, Ar> : N extends SizeType.ArgArrPositive ? Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][] : readonly Ar[number][];
     /**
      * Takes the last N elements from an array.
      *
@@ -1132,12 +1080,8 @@ export declare namespace Arr {
      * console.log(result); // [4, 5]
      * ```
      */
-    export function takeLast<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.TakeLast<N, Ar>;
-    export function takeLast<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.TakeLast<N, Ar>;
-    export function takeLast<E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): NonEmptyArray<E>;
-    export function takeLast(num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => NonEmptyArray<E>;
-    export function takeLast<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-    export function takeLast(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
+    export function takeLast<Ar extends readonly unknown[], N extends SizeType.ArgArr>(array: Ar, num: N): N extends SmallUint ? List.TakeLast<N, Ar> : N extends SizeType.ArgArrPositive ? Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][] : readonly Ar[number][];
+    export function takeLast<N extends SizeType.ArgArr>(num: N): <Ar extends readonly unknown[]>(array: Ar) => N extends SmallUint ? List.TakeLast<N, Ar> : N extends SizeType.ArgArrPositive ? Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][] : readonly Ar[number][];
     /**
      * Skips the first N elements of an array.
      *
@@ -1161,12 +1105,8 @@ export declare namespace Arr {
      * console.log(result); // [3, 4, 5]
      * ```
      */
-    export function skip<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.Skip<N, Ar>;
-    export function skip<E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): readonly E[];
-    export function skip<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-    export function skip<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.Skip<N, Ar>;
-    export function skip(num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => readonly E[];
-    export function skip(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
+    export function skip<Ar extends readonly unknown[], N extends SizeType.ArgArr>(array: Ar, num: N): N extends SmallUint ? List.Skip<N, Ar> : readonly Ar[number][];
+    export function skip<N extends SizeType.ArgArr>(num: N): <Ar extends readonly unknown[]>(array: Ar) => N extends SmallUint ? List.Skip<N, Ar> : readonly Ar[number][];
     /**
      * Skips the last N elements of an array.
      *
@@ -1190,10 +1130,49 @@ export declare namespace Arr {
      * console.log(result); // [1, 2, 3]
      * ```
      */
-    export function skipLast<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.SkipLast<N, Ar>;
-    export function skipLast<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.SkipLast<N, Ar>;
-    export function skipLast<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-    export function skipLast(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
+    export function skipLast<Ar extends readonly unknown[], N extends SizeType.ArgArr>(array: Ar, num: N): N extends SmallUint ? List.SkipLast<N, Ar> : readonly Ar[number][];
+    export function skipLast<N extends SizeType.ArgArr>(num: N): <Ar extends readonly unknown[]>(array: Ar) => N extends SmallUint ? List.SkipLast<N, Ar> : readonly Ar[number][];
+    /**
+     * Returns a new tuple with the element at the specified index replaced.
+     *
+     * This operation is type-safe with compile-time index validation.
+     * The resulting tuple type reflects that the element at the given index
+     * may be either the new type or the original type.
+     *
+     * @template T - The type of the input tuple
+     * @template N - The type of the new value to set
+     * @param tpl - The input tuple
+     * @param index - The index to update (must be valid for the tuple length)
+     * @param newValue - The new value to place at the index
+     * @returns A new tuple with the updated element
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const tpl = ['a', 'b', 'c'] as const;
+     * const updated = Arr.set(tpl, 1, 'B'); // readonly ['a', 'B', 'c']
+     *
+     * // Type changes are reflected
+     * const mixed = [1, 'hello', true] as const;
+     * const withNumber = Arr.set(mixed, 1, 42);
+     * // readonly [1, 42 | 'hello', true]
+     *
+     * // Compile-time index validation
+     * const short = [1, 2] as const;
+     * // Arr.set(short, 2, 3); // Error: index 2 is out of bounds
+     *
+     * // Different value types
+     * const nums = [1, 2, 3] as const;
+     * const withString = Arr.set(nums, 0, 'first');
+     * // readonly ['first' | 1, 2, 3]
+     * ```
+     */
+    export function set<const Ar extends readonly unknown[], const V = Ar[number]>(array: Ar, index: ArgArrayIndex<Ar>, newValue: V): IsFixedLengthList<Ar> extends true ? Readonly<{
+        [K in keyof Ar]: Ar[K] | V;
+    }> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
+    export function set<const V>(index: SizeType.ArgArr, newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? Readonly<{
+        [K in keyof Ar]: Ar[K] | V;
+    }> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
     /**
      * Returns a new array with the element at the specified index updated by a function.
      *
@@ -1215,9 +1194,9 @@ export declare namespace Arr {
      * 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.
+     * @template V 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}.
+     * @param index The index of the element to update. Must be a non-negative {@link SizeType.ArgArr}.
      *   - **Valid range:** `0 <= index < array.length`
      *   - **Out of bounds:** Returns original array unchanged
      *   - **Negative values:** Not allowed by type system (non-negative constraint)
@@ -1345,11 +1324,15 @@ export declare namespace Arr {
      * ```
      *
      * @see {@link Array.prototype.with} for the native method with different error handling
-     * @see {@link SizeType.ArgArrNonNegative} for the index type constraint
+     * @see {@link SizeType.ArgArr} for the index type constraint
      * @see Immutable update patterns for functional programming approaches
      */
-    export function toUpdated<E, U>(array: readonly E[], index: SizeType.ArgArrNonNegative, updater: (prev: E) => U): readonly (E | U)[];
-    export function toUpdated<E, U>(index: SizeType.ArgArrNonNegative, updater: (prev: E) => U): (array: readonly E[]) => readonly (E | U)[];
+    export function toUpdated<const Ar extends readonly unknown[], const V = Ar[number]>(array: Ar, index: ArgArrayIndex<Ar>, updater: (prev: Ar[number]) => V): IsFixedLengthList<Ar> extends true ? Readonly<{
+        [K in keyof Ar]: Ar[K] | V;
+    }> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
+    export function toUpdated<E, const V = E>(index: SizeType.ArgArr, updater: (prev: E) => V): <const Ar extends readonly E[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? Readonly<{
+        [K in keyof Ar]: Ar[K] | V;
+    }> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
     /**
      * 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.
@@ -1369,8 +1352,9 @@ export declare namespace Arr {
      * console.log(result); // [99, 1, 2, 3]
      * ```
      */
-    export function toInserted<E, const V = E>(array: readonly E[], index: SizeType.ArgArrNonNegative, newValue: V): NonEmptyArray<E | V>;
-    export function toInserted<E, const V = E>(index: SizeType.ArgArrNonNegative, newValue: V): (array: readonly E[]) => NonEmptyArray<E | V>;
+    export function toInserted<Ar extends readonly unknown[], const V = Ar[number]>(array: Ar, index: ArgArrayIndexWithNegative<Ar>, newValue: V): IsFixedLengthList<Ar> extends true ? ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V> : NonEmptyArray<Ar[number] | V>;
+    export function toInserted<const V>(index: SizeType.ArgArrWithNegative, newValue: V): <Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V> : NonEmptyArray<Ar[number] | V>;
+    type CastToNumber<T> = T extends number ? T : never;
     /**
      * 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).
@@ -1389,8 +1373,8 @@ export declare namespace Arr {
      * console.log(result); // [20, 30]
      * ```
      */
-    export function toRemoved<E>(array: readonly E[], index: SizeType.ArgArrNonNegative): readonly E[];
-    export function toRemoved(index: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
+    export function toRemoved<Ar extends readonly unknown[]>(array: Ar, index: ArgArrayIndexWithNegative<Ar>): readonly Ar[number][];
+    export function toRemoved(index: SizeType.ArgArrWithNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * Returns a new array with a value added to the end.
      * @template E The type of the input array (can be a tuple).
@@ -1432,29 +1416,75 @@ export declare namespace Arr {
     export function toUnshifted<Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [V, ...Ar];
     export function toUnshifted<const V>(newValue: V): <Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];
     /**
-     * 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.
+     * Creates a new array of the same length filled with a specified value.
+     *
+     * This function replaces all elements in the array with the provided value,
+     * maintaining the original array's length and structure. It provides type-safe
+     * array filling with precise return types.
+     *
+     * @template Ar The exact type of the input array.
+     * @template V The type of the fill value.
+     * @param array The array to fill.
+     * @param value The value to fill the array with.
+     * @returns A new array of the same length filled with the specified value:
+     *   - For fixed-length arrays: returns `ArrayOfLength<Ar['length'], V>`
+     *   - For non-empty arrays: returns `NonEmptyArray<V>`
+     *   - For general arrays: returns `readonly V[]`
+     *
+     * @example
+     * ```typescript
+     * // Regular usage
+     * const numbers = [1, 2, 3, 4, 5];
+     * const zeros = Arr.toFilled(numbers, 0); // [0, 0, 0, 0, 0]
+     *
+     * // Curried usage for pipe composition
+     * const fillWithX = Arr.toFilled('X');
+     * const result = pipe(['a', 'b', 'c']).map(fillWithX).value; // ['X', 'X', 'X']
+     * ```
+     *
+     * @see {@link toRangeFilled} for filling only a specific range
+     * @see {@link create} for creating new arrays filled with a value
+     */
+    export function toFilled<Ar extends readonly unknown[], const V>(array: Ar, value: V): IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar['length'], V> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<V> : readonly V[];
+    export function toFilled<const V>(value: V): <Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar['length'], V> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<V> : readonly V[];
+    /**
+     * Creates a new array with a specific range filled with a specified value.
+     *
+     * This function fills only the specified range of indices with the provided value,
+     * leaving other elements unchanged. It provides type-safe range filling with
+     * precise return types.
+     *
+     * @template Ar The exact type of the input array.
+     * @template V The type of the fill value.
+     * @param array The array to fill a range of.
+     * @param value The value to fill the range with.
+     * @param fillRange A tuple containing [start, end] indices for the range to fill.
+     * @returns A new array with the specified range filled:
+     *   - For fixed-length arrays: returns `ArrayOfLength<Ar['length'], V | Ar[number]>`
+     *   - For non-empty arrays: returns `NonEmptyArray<V | Ar[number]>`
+     *   - For general arrays: returns `readonly (V | Ar[number])[]`
+     *
      * @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]
+     * const numbers = [1, 2, 3, 4, 5];
+     * const result = Arr.toRangeFilled(numbers, 0, [1, 4]); // [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]
+     * const fillMiddleWithX = Arr.toRangeFilled('X', [1, 3]);
+     * const result2 = pipe(['a', 'b', 'c', 'd']).map(fillMiddleWithX).value; // ['a', 'X', 'X', 'd']
      * ```
+     *
+     * @see {@link toFilled} for filling the entire array
      */
-    export function toFilled<E>(array: readonly E[], value: E): readonly E[];
-    export function toFilled<E>(value: E): (array: readonly E[]) => readonly E[];
-    export function toRangeFilled<E>(array: readonly E[], value: E, fillRange: readonly [start: SizeType.ArgArr, end: SizeType.ArgArr]): readonly E[];
-    export function toRangeFilled<E>(value: E, fillRange: readonly [start: SizeType.ArgArr, end: SizeType.ArgArr]): (array: readonly E[]) => readonly E[];
+    export function toRangeFilled<Ar extends readonly unknown[], const V>(array: Ar, value: V, fillRange: readonly [
+        start: ArgArrayIndexWithNegative<Ar>,
+        end: ArgArrayIndexWithNegative<Ar>
+    ]): IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar['length'], V | Ar[number]> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<V | Ar[number]> : readonly (V | Ar[number])[];
+    export function toRangeFilled<const V>(value: V, fillRange: readonly [
+        start: SizeType.ArgArrWithNegative,
+        end: SizeType.ArgArrWithNegative
+    ]): <Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar['length'], V | Ar[number]> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<V | Ar[number]> : readonly (V | Ar[number])[];
     /**
      * Safely finds the first element in an array that satisfies a predicate function.
      *
@@ -1492,8 +1522,39 @@ export declare namespace Arr {
      * @see {@link indexOf} for finding elements by equality
      * @see {@link Optional} for working with the returned Optional values
      */
-    export function find<E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): Optional<E>;
+    export function find<E, F extends E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F): Optional<F>;
+    export function find<Ar extends readonly unknown[]>(array: Ar, predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean): Optional<Ar[number]>;
     export function find<E>(predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): (array: readonly E[]) => Optional<E>;
+    /**
+     * Returns the last element in an array that satisfies a predicate function.
+     *
+     * This function searches from the end of the array and returns an Optional containing
+     * the first element found that satisfies the predicate, or None if no such element exists.
+     *
+     * @template Ar The exact type of the input array.
+     * @template E The type of elements in the array.
+     * @param array The array to search.
+     * @param predicate A function that tests each element.
+     * @returns An Optional containing the found element, or None if no element satisfies the predicate.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const numbers = [1, 2, 3, 4, 5];
+     * const lastEven = Arr.findLast(numbers, n => n % 2 === 0); // Optional.some(4)
+     *
+     * // Curried usage
+     * const isPositive = (n: number) => n > 0;
+     * const findLastPositive = Arr.findLast(isPositive);
+     * const result = findLastPositive([-1, 2, -3, 4]); // Optional.some(4)
+     *
+     * // No match
+     * const noMatch = Arr.findLast([1, 3, 5], n => n % 2 === 0); // Optional.none
+     * ```
+     */
+    export function findLast<E, F extends E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F): Optional<F>;
+    export function findLast<Ar extends readonly unknown[]>(array: Ar, predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean): Optional<Ar[number]>;
+    export function findLast<E>(predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): (array: readonly E[]) => Optional<E>;
     /**
      * Safely finds the index of the first element in an array that satisfies a predicate function.
      *
@@ -1599,8 +1660,100 @@ export declare namespace Arr {
      * @see {@link lastIndexOf} for finding the last occurrence
      * @see {@link Optional} for working with the returned Optional values
      */
-    export function findIndex<E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr) => boolean): SizeType.Arr | -1;
-    export function findIndex<E>(predicate: (value: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => SizeType.Arr | -1;
+    export function findIndex<Ar extends readonly unknown[]>(array: Ar, predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean): ArrayIndex<Ar> | -1;
+    export function findIndex<E>(predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): (array: readonly E[]) => SizeType.Arr | -1;
+    /**
+     * Safely finds the index of the last element in an array that satisfies a predicate function.
+     *
+     * This function provides type-safe index searching with no risk of runtime errors. It searches
+     * from the end of the array backwards and returns the index of the last element that matches
+     * the predicate, or -1 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 Ar The exact type of the input array, used for precise return type inference.
+     * @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 array being searched
+     * @returns The index of the last matching element as `SizeType.Arr`, or -1 if no element satisfies the predicate.
+     *
+     * @example
+     * ```typescript
+     * // Basic last index finding
+     * const fruits = ['apple', 'banana', 'cherry', 'banana'];
+     * const lastBananaIndex = Arr.findLastIndex(fruits, fruit => fruit === 'banana');
+     * console.log(lastBananaIndex); // 3 - index of last 'banana'
+     *
+     * // Finding with complex conditions
+     * const numbers = [1, 5, 10, 15, 20, 10, 5];
+     * const lastLargeIndex = Arr.findLastIndex(numbers, (value, index) =>
+     *   value > 8 && index < 5
+     * );
+     * console.log(lastLargeIndex); // 3 - index of last value > 8 before index 5 (15)
+     *
+     * // Finding objects by property
+     * const users = [
+     *   { id: 1, active: true },
+     *   { id: 2, active: false },
+     *   { id: 3, active: true },
+     *   { id: 4, active: false }
+     * ];
+     *
+     * const lastActiveIndex = Arr.findLastIndex(users, user => user.active);
+     * console.log(lastActiveIndex); // 2 - index of last active user
+     *
+     * const lastInactiveIndex = Arr.findLastIndex(users, user => !user.active);
+     * console.log(lastInactiveIndex); // 3 - index of last inactive user
+     *
+     * // Empty array handling
+     * const emptyResult = Arr.findLastIndex([], (x: number) => x > 0); // -1
+     *
+     * // Curried usage for functional composition
+     * const findLastNegativeIndex = Arr.findLastIndex((x: number) => x < 0);
+     * const findLastLongStringIndex = Arr.findLastIndex((s: string) => s.length > 5);
+     *
+     * const datasets = [
+     *   [1, 2, -3, 4, -5],    // last negative at index 4
+     *   [5, 6, 7, 8],         // no negative
+     *   [-1, 0, 1, -2]        // last negative at index 3
+     * ];
+     *
+     * const lastNegativeIndices = datasets.map(findLastNegativeIndex);
+     * // [4, -1, 3]
+     *
+     * // Functional composition
+     * const data = ['short', 'medium', 'very long string', 'tiny', 'another long one'];
+     * const lastLongIndex = Arr.findLastIndex(data, s => s.length > 8);
+     * console.log(lastLongIndex); // 4 - index of 'another long one'
+     *
+     * // Using with pipe
+     * const result = pipe(['a', 'bb', 'ccc', 'bb'])
+     *   .map(Arr.findLastIndex((s: string) => s.length === 2))
+     *   .value; // 3 (last occurrence of 'bb')
+     *
+     * // Comparing with findIndex
+     * const values = [1, 2, 3, 2, 4];
+     * const firstTwo = Arr.findIndex(values, x => x === 2);   // 1
+     * const lastTwo = Arr.findLastIndex(values, x => x === 2); // 3
+     *
+     * // Type safety with tuples
+     * const tuple = [10, 20, 30, 20] as const;
+     * const lastTwentyIndex = Arr.findLastIndex(tuple, x => x === 20);
+     * // Type: ArrayIndex<readonly [10, 20, 30, 20]> | -1
+     * // Value: 3
+     * ```
+     *
+     * @see {@link findLast} for finding the element instead of its index
+     * @see {@link findIndex} for finding the first occurrence
+     * @see {@link lastIndexOf} for finding elements by equality (not predicate)
+     */
+    export function findLastIndex<Ar extends readonly unknown[]>(array: Ar, predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean): ArrayIndex<Ar> | -1;
+    export function findLastIndex<E>(predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): (array: readonly E[]) => SizeType.Arr | -1;
     /**
      * Gets the index of a value in an array.
      * @param array The array to search.
@@ -1622,10 +1775,10 @@ export declare namespace Arr {
      * console.log(Optional.unwrapOr(result2, -1)); // 1
      * ```
      */
-    export function indexOf<E>(array: readonly E[], searchElement: E): SizeType.Arr | -1;
+    export function indexOf<Ar extends readonly unknown[]>(array: Ar, searchElement: Ar[number]): ArrayIndex<Ar> | -1;
     export function indexOf<E>(searchElement: E): (array: readonly E[]) => SizeType.Arr | -1;
-    export function indexOfFrom<E>(array: readonly E[], searchElement: E, fromIndex: SizeType.ArgArr): SizeType.Arr | -1;
-    export function indexOfFrom<E>(searchElement: E, fromIndex: SizeType.ArgArr): (array: readonly E[]) => SizeType.Arr | -1;
+    export function indexOfFrom<Ar extends readonly unknown[]>(array: Ar, searchElement: Ar[number], fromIndex: ArgArrayIndexWithNegative<Ar>): ArrayIndex<Ar> | -1;
+    export function indexOfFrom<E>(searchElement: E, fromIndex: SizeType.ArgArrWithNegative): (array: readonly E[]) => SizeType.Arr | -1;
     /**
      * Gets the last index of a value in an array.
      * @param array The array to search.
@@ -1647,10 +1800,85 @@ export declare namespace Arr {
      * console.log(Optional.unwrapOr(result2, -1)); // 3
      * ```
      */
-    export function lastIndexOf<E>(array: readonly E[], searchElement: E): SizeType.Arr | -1;
+    export function lastIndexOf<Ar extends readonly unknown[]>(array: Ar, searchElement: Ar[number]): ArrayIndex<Ar> | -1;
     export function lastIndexOf<E>(searchElement: E): (array: readonly E[]) => SizeType.Arr | -1;
-    export function lastIndexOfFrom<E>(array: readonly E[], searchElement: E, fromIndex: SizeType.ArgArr): SizeType.Arr | -1;
-    export function lastIndexOfFrom<E>(searchElement: E, fromIndex: SizeType.ArgArr): (array: readonly E[]) => SizeType.Arr | -1;
+    export function lastIndexOfFrom<Ar extends readonly unknown[]>(array: Ar, searchElement: Ar[number], fromIndex: ArgArrayIndexWithNegative<Ar>): ArrayIndex<Ar> | -1;
+    export function lastIndexOfFrom<E>(searchElement: E, fromIndex: SizeType.ArgArrWithNegative): (array: readonly E[]) => SizeType.Arr | -1;
+    /**
+     * Tests whether all elements in an array pass a test implemented by a predicate function.
+     *
+     * This function returns `true` if all elements satisfy the predicate, `false` otherwise.
+     * For empty arrays, it returns `true` (vacuous truth).
+     * Supports type guard predicates for type narrowing of the entire array.
+     *
+     * @template Ar The exact type of the input array.
+     * @template E The type of elements in the array.
+     * @template S The narrowed type when using type guard predicates.
+     * @param array The array to test.
+     * @param predicate A function that tests each element.
+     * @returns `true` if all elements pass the test, `false` otherwise.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const numbers = [2, 4, 6, 8];
+     * const allEven = Arr.every(numbers, n => n % 2 === 0); // true
+     *
+     * // Type guard usage - narrows entire array type
+     * const mixed: (string | number)[] = ['hello', 'world'];
+     * if (Arr.every(mixed, (x): x is string => typeof x === 'string')) {
+     *   // TypeScript knows mixed is string[] here
+     *   console.log(mixed.map(s => s.toUpperCase()));
+     * }
+     *
+     * // Curried usage with type guards
+     * const isString = (x: unknown): x is string => typeof x === 'string';
+     * const allStrings = Arr.every(isString);
+     * const data: unknown[] = ['a', 'b', 'c'];
+     * if (allStrings(data)) {
+     *   // TypeScript knows data is string[] here
+     *   console.log(data.join(''));
+     * }
+     *
+     * // Empty array
+     * const empty: number[] = [];
+     * const result2 = Arr.every(empty, n => n > 0); // true
+     * ```
+     */
+    export function every<E, S extends E>(array: readonly E[], predicate: (a: E, index: SizeType.Arr) => a is S): array is readonly S[];
+    export function every<E, S extends E>(predicate: (a: E, index: SizeType.Arr) => a is S): (array: readonly E[]) => array is readonly S[];
+    export function every<Ar extends readonly unknown[]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean): boolean;
+    export function every<E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => boolean;
+    /**
+     * Tests whether at least one element in an array passes a test implemented by a predicate function.
+     *
+     * This function returns `true` if at least one element satisfies the predicate, `false` otherwise.
+     * For empty arrays, it returns `false`.
+     *
+     * @template Ar The exact type of the input array.
+     * @template E The type of elements in the array.
+     * @param array The array to test.
+     * @param predicate A function that tests each element.
+     * @returns `true` if at least one element passes the test, `false` otherwise.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const numbers = [1, 3, 5, 8];
+     * const hasEven = Arr.some(numbers, n => n % 2 === 0); // true
+     *
+     * // Curried usage
+     * const isNegative = (n: number) => n < 0;
+     * const hasNegative = Arr.some(isNegative);
+     * const result = hasNegative([1, 2, -3]); // true
+     *
+     * // Empty array
+     * const empty: number[] = [];
+     * const result2 = Arr.some(empty, n => n > 0); // false
+     * ```
+     */
+    export function some<Ar extends readonly unknown[]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean): boolean;
+    export function some<E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => boolean;
     /**
      * 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`.
@@ -1666,7 +1894,7 @@ export declare namespace Arr {
      * Arr.foldl(['a', 'b', 'c'], (acc, str) => acc + str.toUpperCase(), ''); // 'ABC'
      * ```
      */
-    export function foldl<E, P>(array: readonly E[], callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): P;
+    export function foldl<Ar extends readonly unknown[], P>(array: Ar, callbackfn: (previousValue: P, currentValue: Ar[number], currentIndex: ArrayIndex<Ar>) => P, initialValue: P): P;
     export function foldl<E, P>(callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): (array: readonly E[]) => P;
     /**
      * Applies a function against an accumulator and each element in the array (from right to left) to reduce it to a single value.
@@ -1688,7 +1916,7 @@ export declare namespace Arr {
      * console.log(result); // "abc"
      * ```
      */
-    export function foldr<E, P>(array: readonly E[], callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): P;
+    export function foldr<Ar extends readonly unknown[], P>(array: Ar, callbackfn: (previousValue: P, currentValue: Ar[number], currentIndex: ArrayIndex<Ar>) => P, initialValue: P): P;
     export function foldr<E, P>(callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): (array: readonly E[]) => P;
     /**
      * Finds the minimum value in an array.
@@ -1703,10 +1931,8 @@ export declare namespace Arr {
      * Arr.min([]); // Optional.none
      * ```
      */
-    export function min<E extends number>(array: NonEmptyArray<E>, comparator?: (x: E, y: E) => number): Optional.Some<E>;
-    export function min<E extends number>(array: readonly E[], comparator?: (x: E, y: E) => number): Optional<E>;
-    export function min<E>(array: NonEmptyArray<E>, comparator: (x: E, y: E) => number): Optional.Some<E>;
-    export function min<E>(array: readonly E[], comparator: (x: E, y: E) => number): Optional<E>;
+    export function min<Ar extends readonly number[]>(array: Ar, comparator?: (x: Ar[number], y: Ar[number]) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
+    export function min<Ar extends readonly unknown[]>(array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
     /**
      * Finds the maximum value in an array.
      *
@@ -1725,10 +1951,8 @@ export declare namespace Arr {
      * Arr.max([]); // Optional.none
      * ```
      */
-    export function max<E extends number>(array: NonEmptyArray<E>, comparator?: (x: E, y: E) => number): Optional.Some<E>;
-    export function max<E extends number>(array: readonly E[], comparator?: (x: E, y: E) => number): Optional<E>;
-    export function max<E>(array: NonEmptyArray<E>, comparator: (x: E, y: E) => number): Optional.Some<E>;
-    export function max<E>(array: readonly E[], comparator: (x: E, y: E) => number): Optional<E>;
+    export function max<Ar extends readonly number[]>(array: Ar, comparator?: (x: Ar[number], y: Ar[number]) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
+    export function max<Ar extends readonly unknown[]>(array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
     /**
      * Finds the element with the minimum value according to a mapped numeric value.
      *
@@ -1749,10 +1973,8 @@ export declare namespace Arr {
      * Arr.minBy([], p => p.age); // Optional.none
      * ```
      */
-    export function minBy<E>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => number): Optional.Some<E>;
-    export function minBy<E>(array: readonly E[], comparatorValueMapper: (value: E) => number): Optional<E>;
-    export function minBy<E, V>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional.Some<E>;
-    export function minBy<E, V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional<E>;
+    export function minBy<Ar extends readonly unknown[]>(array: Ar, comparatorValueMapper: (value: Ar[number]) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
+    export function minBy<Ar extends readonly unknown[], V>(array: Ar, comparatorValueMapper: (value: Ar[number]) => V, comparator: (x: V, y: V) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
     /**
      * Finds the element with the maximum value according to a mapped numeric value.
      *
@@ -1773,10 +1995,8 @@ export declare namespace Arr {
      * Arr.maxBy([], p => p.age); // Optional.none
      * ```
      */
-    export function maxBy<E>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => number): Optional.Some<E>;
-    export function maxBy<E>(array: readonly E[], comparatorValueMapper: (value: E) => number): Optional<E>;
-    export function maxBy<E, V>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional.Some<E>;
-    export function maxBy<E, V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional<E>;
+    export function maxBy<Ar extends readonly unknown[]>(array: Ar, comparatorValueMapper: (value: Ar[number]) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
+    export function maxBy<Ar extends readonly unknown[], V>(array: Ar, comparatorValueMapper: (value: Ar[number]) => V, comparator: (x: V, y: V) => number): Ar extends NonEmptyArray<unknown> ? Optional.Some<Ar[number]> : Optional<Ar[number]>;
     /**
      * Counts the number of elements in an array that satisfy a predicate.
      * @template E The type of elements in the array.
@@ -1794,7 +2014,7 @@ export declare namespace Arr {
      * console.log(result); // 3
      * ```
      */
-    export function count<E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr) => boolean): SizeType.Arr;
+    export function count<Ar extends readonly unknown[]>(array: Ar, predicate: (value: Ar[number], index: ArrayIndex<Ar>) => boolean): SizeType.Arr;
     export function count<E>(predicate: (value: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => SizeType.Arr;
     /**
      * Groups elements of an array by a key derived from each element and counts the elements in each group.
@@ -1816,7 +2036,7 @@ export declare namespace Arr {
      * // IMap { 'a' => 2, 'b' => 1 }
      * ```
      */
-    export function countBy<E, G extends MapSetKeyType>(array: readonly E[], grouper: (value: E, index: SizeType.Arr) => G): IMap<G, SizeType.Arr>;
+    export function countBy<Ar extends readonly unknown[], G extends MapSetKeyType>(array: Ar, grouper: (value: Ar[number], index: ArrayIndex<Ar>) => G): IMap<G, ArrayIndex<Ar>>;
     export function countBy<E, G extends MapSetKeyType>(grouper: (value: E, index: SizeType.Arr) => G): (array: readonly E[]) => IMap<G, SizeType.Arr>;
     /**
      * Calculates the sum of numbers in an array.
@@ -1873,6 +2093,87 @@ export declare namespace Arr {
      * ```
      */
     export const zip: <Ar1 extends readonly unknown[], Ar2 extends readonly unknown[]>(array1: Ar1, array2: Ar2) => List.Zip<Ar1, Ar2>;
+    /**
+     * Creates a new tuple by transforming each element with a mapping function.
+     *
+     * Preserves the tuple's length while allowing element type transformation.
+     * The resulting tuple has the same structure but with transformed element types.
+     *
+     * @template T - The type of the input tuple
+     * @template B - The type that elements will be transformed to
+     * @param array - The input tuple
+     * @param mapFn - Function that transforms each element (receives element and index)
+     * @returns A new tuple with transformed elements, preserving the original length
+     *
+     * @example
+     * ```typescript
+     * // Basic transformation
+     * const nums = [1, 2, 3] as const;
+     * const doubled = Arr.map(nums, (x) => x * 2); // readonly [2, 4, 6]
+     * const strings = Arr.map(nums, (x) => String(x)); // readonly ['1', '2', '3']
+     *
+     * // With index
+     * const indexed = Arr.map(nums, (x, i) => `${i}:${x}`);
+     * // readonly ['0:1', '1:2', '2:3']
+     *
+     * // Mixed type tuples
+     * const mixed = [1, 'hello', true] as const;
+     * const descriptions = Arr.map(mixed, (x) => `Value: ${x}`);
+     * // readonly ['Value: 1', 'Value: hello', 'Value: true']
+     * ```
+     */
+    export function map<const Ar extends readonly unknown[], B>(array: Ar, mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B): Readonly<{
+        [K in keyof Ar]: B;
+    }>;
+    export function map<A, B>(mapFn: (a: A, index: SizeType.Arr) => B): <Ar extends readonly A[]>(array: Ar) => Readonly<{
+        [K in keyof Ar]: B;
+    }>;
+    /**
+     * Filters an array based on a predicate function.
+     *
+     * This function returns a new array containing only the elements that satisfy the predicate.
+     * It provides both direct usage and curried versions for functional composition.
+     * Supports type guard predicates for type narrowing.
+     *
+     * @template Ar The exact type of the input array, used for precise return type inference.
+     * @template E The type of elements in the array.
+     * @template S The narrowed type when using type guard predicates.
+     * @param array The array to filter.
+     * @param predicate A function that tests each element. Returns `true` to keep the element, `false` to filter it out.
+     * @returns A new array containing only the elements that satisfy the predicate.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const numbers = [1, 2, 3, 4, 5];
+     * const evens = Arr.filter(numbers, n => n % 2 === 0); // [2, 4]
+     *
+     * // Type guard usage
+     * const mixed: (string | number | null)[] = ['hello', 42, null, 'world'];
+     * const strings = Arr.filter(mixed, (x): x is string => typeof x === 'string'); // string[]
+     * const notNull = Arr.filter(mixed, (x): x is NonNullable<typeof x> => x != null); // (string | number)[]
+     *
+     * // Curried usage with type guards
+     * const isString = (x: unknown): x is string => typeof x === 'string';
+     * const filterStrings = Arr.filter(isString);
+     * const result = filterStrings(['a', 1, 'b', 2]); // string[]
+     *
+     * // Functional composition
+     * const processNumbers = pipe(
+     *   Arr.filter((n: number) => n > 0),
+     *   Arr.map(n => n * 2)
+     * );
+     * ```
+     *
+     * @see {@link filterNot} for filtering with negated predicate
+     * @see {@link every} for testing if all elements satisfy a predicate
+     * @see {@link some} for testing if any elements satisfy a predicate
+     * @see {@link find} for finding the first element that satisfies a predicate
+     */
+    export function filter<Ar extends readonly unknown[], S extends Ar[number]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S): readonly S[];
+    export function filter<E, S extends E>(predicate: (a: E, index: SizeType.Arr) => a is S): (array: readonly E[]) => readonly S[];
+    export function filter<Ar extends readonly unknown[]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean): readonly Ar[number][];
+    export function filter<E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => readonly E[];
     /**
      * Filters an array by excluding elements for which the predicate returns true.
      * This is the opposite of `Array.prototype.filter`.
@@ -1891,8 +2192,68 @@ export declare namespace Arr {
      * console.log(result); // [1, 3, 5]
      * ```
      */
-    export function filterNot<E>(array: readonly E[], predicate: (a: E, index: SizeType.Arr) => boolean): readonly E[];
+    export function filterNot<Ar extends readonly unknown[]>(array: Ar, predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean): readonly Ar[number][];
     export function filterNot<E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => readonly E[];
+    /**
+     * Creates a new array with all sub-array elements concatenated into it recursively up to the specified depth.
+     *
+     * This function flattens nested arrays to the specified depth level.
+     * A depth of 1 flattens one level, Number.POSITIVE_INFINITY flattens all levels.
+     *
+     * @template Ar The exact type of the input array.
+     * @template D The depth of flattening.
+     * @param array The array to flatten.
+     * @param depth The depth level specifying how deep a nested array structure should be flattened.
+     * @returns A new array with the sub-array elements concatenated.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const nested = [1, [2, [3, 4]], 5];
+     * const flat1 = Arr.flat(nested, 1); // [1, 2, [3, 4], 5]
+     * const flat2 = Arr.flat(nested, 2); // [1, 2, 3, 4, 5]
+     *
+     * // Curried usage
+     * const flattenOnceLevel = Arr.flat(1);
+     * const result = flattenOnceLevel([[1, 2], [3, 4]]); // [1, 2, 3, 4]
+     *
+     * // Flatten all levels
+     * const deepNested = [1, [2, [3, [4, 5]]]];
+     * const allFlat = Arr.flat(deepNested, SafeUint.MAX_VALUE); // [1, 2, 3, 4, 5]
+     * ```
+     */
+    export function flat<Ar extends readonly unknown[], D extends SafeUintWithSmallInt = 1>(array: Ar, depth?: D): readonly FlatArray<Ar, D>[];
+    export function flat<D extends SafeUintWithSmallInt = 1>(depth?: number): <Ar extends readonly unknown[]>(array: Ar) => readonly FlatArray<Ar, D>[];
+    /**
+     * Creates a new array with all sub-array elements concatenated into it recursively up to the specified depth,
+     * after first mapping each element using a mapping function.
+     *
+     * This function is equivalent to calling `map` followed by `flat` with depth 1.
+     *
+     * @template Ar The exact type of the input array.
+     * @template E The type of elements in the array.
+     * @template B The type of elements returned by the mapping function.
+     * @param array The array to map and flatten.
+     * @param mapFn A function that produces new elements for the new array.
+     * @returns A new array with mapped elements flattened.
+     *
+     * @example
+     * ```typescript
+     * // Direct usage
+     * const words = ['hello', 'world'];
+     * const chars = Arr.flatMap(words, word => word.split('')); // ['h','e','l','l','o','w','o','r','l','d']
+     *
+     * // Curried usage
+     * const splitWords = Arr.flatMap((word: string) => word.split(''));
+     * const result = splitWords(['foo', 'bar']); // ['f','o','o','b','a','r']
+     *
+     * // With numbers
+     * const numbers = [1, 2, 3];
+     * const doubled = Arr.flatMap(numbers, n => [n, n * 2]); // [1, 2, 2, 4, 3, 6]
+     * ```
+     */
+    export function flatMap<const Ar extends readonly unknown[], B>(array: Ar, mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => readonly B[]): readonly B[];
+    export function flatMap<A, B>(mapFn: (a: A, index: SizeType.Arr) => readonly B[]): (array: readonly A[]) => readonly B[];
     /**
      * Concatenates two arrays.
      * @template E1 The type of the first array (can be a tuple).
@@ -1925,6 +2286,53 @@ export declare namespace Arr {
      */
     export function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>, E>(array: readonly E[], chunkSize: N): readonly (readonly E[])[];
     export function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(chunkSize: N): <E>(array: readonly E[]) => readonly (readonly E[])[];
+    /**
+     * 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]
+     * ```
+     */
+    export const toReversed: <const Ar extends readonly unknown[]>(array: Ar) => List.Reverse<Ar>;
+    /**
+     * Sorts an array by a value derived from its elements, using a numeric mapping.
+     * @template E The type of elements in the array.
+     * @param array The input array.
+     * @param comparatorValueMapper A function `(value: A) => number` that maps an element to a number for comparison.
+     * @param comparator An optional custom comparator function `(x: number, y: number) => number` for the mapped numbers. Defaults to ascending sort (x - y).
+     * @returns A new array sorted by the mapped values.
+     * @example
+     * ```ts
+     * const items = [{ name: 'Eve', score: 70 }, { name: 'Adam', score: 90 }, { name: 'Bob', score: 80 }];
+     * Arr.toSortedBy(items, item => item.score);
+     * // [{ name: 'Eve', score: 70 }, { name: 'Bob', score: 80 }, { name: 'Adam', score: 90 }]
+     * Arr.toSortedBy(items, item => item.score, (a, b) => b - a); // Sort descending
+     * // [{ name: 'Adam', score: 90 }, { name: 'Bob', score: 80 }, { name: 'Eve', score: 70 }]
+     * ```
+     */
+    export const toSorted: <Ar extends readonly unknown[]>(...[array, comparator]: Ar extends readonly number[] ? readonly [array: Ar, comparator?: (x: Ar[number], y: Ar[number]) => number] : readonly [array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number]) => IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar["length"], Ar[number]> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][];
     /**
      * Sorts an array by a value derived from its elements, using a numeric mapping.
      * @template E The type of elements in the array.
@@ -1941,8 +2349,8 @@ export declare namespace Arr {
      * // [{ name: 'Adam', score: 90 }, { name: 'Bob', score: 80 }, { name: 'Eve', score: 70 }]
      * ```
      */
-    export function toSortedBy<E>(array: readonly E[], comparatorValueMapper: (value: E) => number, comparator?: (x: number, y: number) => number): readonly E[];
-    export function toSortedBy<E, const V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): readonly E[];
+    export function toSortedBy<Ar extends readonly unknown[]>(array: Ar, comparatorValueMapper: (value: Ar[number]) => number, comparator?: (x: number, y: number) => number): IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar['length'], Ar[number]> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][];
+    export function toSortedBy<Ar extends readonly unknown[], const V>(array: Ar, comparatorValueMapper: (value: Ar[number]) => V, comparator: (x: V, y: V) => number): IsFixedLengthList<Ar> extends true ? ArrayOfLength<Ar['length'], Ar[number]> : Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][];
     /**
      * Returns an array of successively reduced values from an array, starting with an initial value.
      *
@@ -2000,8 +2408,8 @@ export declare namespace Arr {
      *
      * // 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]
+     * const runningMax = Arr.scan(temperatures, (max, temp) => Math.max(max, temp), Number.NEGATIVE_INFINITY);
+     * // [Number.NEGATIVE_INFINITY, 20, 25, 25, 30, 30]
      *
      * // Building strings incrementally
      * const words = ['Hello', 'beautiful', 'world'];
@@ -2099,7 +2507,7 @@ export declare namespace Arr {
      * @see {@link SizeType.Arr} for the index parameter type
      * @see Array.prototype.reduce for the standard reduce function
      */
-    export function scan<E, S>(array: readonly E[], reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S, init: S): NonEmptyArray<S>;
+    export function scan<Ar extends readonly unknown[], S>(array: Ar, reducer: (accumulator: S, currentValue: Ar[number], currentIndex: ArrayIndex<Ar>) => S, init: S): NonEmptyArray<S>;
     export function scan<E, S>(reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S, init: S): (array: readonly E[]) => NonEmptyArray<S>;
     /**
      * Groups elements of an array by a key derived from each element, returning an immutable {@link IMap}.
@@ -2250,7 +2658,7 @@ export declare namespace Arr {
      * @see {@link IMap.map} for transforming grouped data
      * @see {@link Optional} for handling potentially missing groups
      */
-    export function groupBy<E, G extends MapSetKeyType>(array: readonly E[], grouper: (value: E, index: SizeType.Arr) => G): IMap<G, readonly E[]>;
+    export function groupBy<Ar extends readonly unknown[], G extends MapSetKeyType>(array: Ar, grouper: (value: Ar[number], index: ArrayIndex<Ar>) => G): IMap<G, readonly Ar[number][]>;
     export function groupBy<E, G extends MapSetKeyType>(grouper: (value: E, index: SizeType.Arr) => G): (array: readonly E[]) => IMap<G, readonly E[]>;
     /**
      * Creates a new array with unique elements from the input array. Order is preserved from the first occurrence.
@@ -2263,7 +2671,7 @@ export declare namespace Arr {
      * Arr.uniq([1, 2, 2, 3, 1, 4]); // [1, 2, 3, 4]
      * ```
      */
-    export const uniq: <P extends Primitive>(array: readonly P[]) => readonly P[];
+    export const uniq: <Ar extends readonly Primitive[]>(array: Ar) => Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][];
     /**
      * Creates a new array with unique elements from the input array, based on the values returned by `mapFn`.
      *
@@ -2285,8 +2693,7 @@ export declare namespace Arr {
      * Arr.uniqBy(users, user => user.id); // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
      * ```
      */
-    export function uniqBy<E, P extends Primitive>(array: NonEmptyArray<E>, mapFn: (value: E) => P): NonEmptyArray<E>;
-    export function uniqBy<E, P extends Primitive>(array: readonly E[], mapFn: (value: E) => P): readonly E[];
+    export const uniqBy: <Ar extends readonly unknown[], P extends Primitive>(array: Ar, mapFn: (value: Ar[number]) => P) => Ar extends NonEmptyArray<unknown> ? NonEmptyArray<Ar[number]> : readonly Ar[number][];
     /**
      * Checks if two arrays are equal by performing a shallow comparison of their elements.
      * @template E The type of elements in the arrays.
@@ -2393,11 +2800,84 @@ export declare namespace Arr {
      * ```
      */
     export const sortedNumSetDifference: <E extends number>(sortedList1: readonly E[], sortedList2: readonly E[]) => readonly E[];
+    /**
+     * 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]]
+     * ```
+     */
+    export function entries<E>(array: readonly E[]): ArrayIterator<readonly [SizeType.Arr, E]>;
+    /**
+     * 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']
+     * ```
+     */
+    export function values<E>(array: readonly E[]): ArrayIterator<E>;
+    /**
+     * 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); // []
+     * ```
+     */
+    export function indices<E>(array: readonly E[]): ArrayIterator<SizeType.Arr>;
     /**
      * Alias for `head`. Returns the first element of an array.
      * @see {@link head}
      */
-    export const first: typeof head;
+    export const first: <Ar extends readonly unknown[]>(array: Ar) => Ar extends readonly [] ? Optional.None : Ar extends readonly [infer E, ...unknown[]] ? Optional.Some<E> : Ar extends NonEmptyArray<infer E> ? Optional.Some<E> : Optional<Ar[number]>;
     /**
      * Alias for `tail`. Returns all elements of an array except the first one.
      * @see {@link tail}
@@ -2423,6 +2903,21 @@ export declare namespace Arr {
      * @see {@link partition}
      */
     export const chunk: typeof partition;
+    /**
+     * Alias for `create`. Creates a new array of the specified length, with each position filled with the provided initial value.
+     * @see {@link create}
+     */
+    export const newArray: <const V, N extends SizeType.ArgArr>(len: N, init: V) => N extends SmallUint ? ArrayOfLength<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
+    /**
+     * Alias for `size`. Returns the length of an array.
+     * @see {@link size}
+     */
+    export const length: <Ar extends readonly unknown[]>(array: Ar) => Ar extends NonEmptyArray<unknown> ? IntersectBrand<PositiveNumber, SizeType.Arr> : SizeType.Arr;
+    /**
+     * Alias for `indices`. Returns an iterable of keys in the array.
+     * @see {@link indices}
+     */
+    export const keys: typeof indices;
     export {};
 }
 //# sourceMappingURL=array-utils.d.mts.map