ts-data-forge 10.0.0 → 11.0.0

package/src/{guard/as-length-bounded-array.mts → array/impl/array-utils-length-bounded-array-cast.mts}

@@ -10,7 +10,7 @@ import {
   isFixedLengthArray,
   isMaxLengthArray,
   isMinLengthArray,
-} from './is-length-bounded-array.mjs';
+} from './array-utils-length-bounded-array-guard.mjs';
 
 /**
  * Casts an array to `FixedLengthArray<Length, E>` after checking that it has
@@ -25,12 +25,12 @@ import {
  * @example
  *
  * ```ts
- * const rgb = asFixedLengthArray([255, 128, 0], 3);
+ * const rgb = Arr.asFixedLengthArray([255, 128, 0], 3);
  *
  * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)
  * const red: number = rgb[0]; // OK — no `undefined`
  *
- * // asFixedLengthArray([255, 128], 3); // throws TypeError
+ * // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError
  * ```
  *
  * @template Xs - The input array type (tuple types are preserved).
@@ -69,12 +69,12 @@ export const asFixedLengthArray = <
  * @example
  *
  * ```ts
- * const history = asMinLengthArray([0, 1, 2, 3], 3);
+ * const history = Arr.asMinLengthArray([0, 1, 2, 3], 3);
  *
  * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)
  * const first: number = history[0]; // OK — no `undefined`
  *
- * // asMinLengthArray([0], 3); // throws TypeError
+ * // Arr.asMinLengthArray([0], 3); // throws TypeError
  * ```
  *
  * @template Xs - The input array type (tuple types are preserved).
@@ -111,11 +111,11 @@ export const asMinLengthArray = <
  * @example
  *
  * ```ts
- * const tags = asMaxLengthArray(['a', 'b', 'c'], 8);
+ * const tags = Arr.asMaxLengthArray(['a', 'b', 'c'], 8);
  *
  * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)
  *
- * // asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError
+ * // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError
  * ```
  *
  * @template Xs - The input array type (tuple types are preserved).
@@ -154,11 +154,11 @@ export const asMaxLengthArray = <
  * @example
  *
  * ```ts
- * const selection = asBoundedLengthArray([1, 2, 3], 1, 5);
+ * const selection = Arr.asBoundedLengthArray([1, 2, 3], 1, 5);
  *
  * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK
  *
- * // asBoundedLengthArray([], 1, 5); // throws TypeError
+ * // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError
  * ```
  *
  * @template Xs - The input array type (tuple types are preserved).

package/src/{guard/as-length-bounded-array.test.mts → array/impl/array-utils-length-bounded-array-cast.test.mts}

@@ -4,13 +4,13 @@ import {
   type MaxLengthArray,
   type MinLengthArray,
 } from 'ts-type-forge';
-import { expectType } from '../expect-type.mjs';
+import { expectType } from '../../expect-type.mjs';
 import {
   asBoundedLengthArray,
   asFixedLengthArray,
   asMaxLengthArray,
   asMinLengthArray,
-} from './as-length-bounded-array.mjs';
+} from './array-utils-length-bounded-array-cast.mjs';
 
 describe(asFixedLengthArray, () => {
   test('should return the input when the length matches exactly', () => {

package/src/{guard/is-length-bounded-array.mts → array/impl/array-utils-length-bounded-array-guard.mts}

@@ -25,11 +25,11 @@ import {
  * ```ts
  * const input: readonly number[] = [0, 1, 2, 3];
  *
- * assert.isTrue(isMinLengthArray(input, 3));
+ * assert.isTrue(Arr.isMinLengthArray(input, 3));
  *
- * assert.isFalse(isMinLengthArray([0], 3));
+ * assert.isFalse(Arr.isMinLengthArray([0], 3));
  *
- * if (isMinLengthArray(input, 3)) {
+ * if (Arr.isMinLengthArray(input, 3)) {
  *   const history: MinLengthArray<3, number> = input;
  *
  *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)
@@ -70,11 +70,11 @@ export const isMinLengthArray = <
  * ```ts
  * const input: readonly string[] = ['a', 'b', 'c'];
  *
- * assert.isTrue(isMaxLengthArray(input, 8));
+ * assert.isTrue(Arr.isMaxLengthArray(input, 8));
  *
- * assert.isFalse(isMaxLengthArray(input, 2));
+ * assert.isFalse(Arr.isMaxLengthArray(input, 2));
  *
- * if (isMaxLengthArray(input, 8)) {
+ * if (Arr.isMaxLengthArray(input, 8)) {
  *   const tags: MaxLengthArray<8, string> = input;
  *
  *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)
@@ -116,11 +116,11 @@ export const isMaxLengthArray = <
  * ```ts
  * const input: readonly number[] = [1, 2, 3];
  *
- * assert.isTrue(isBoundedLengthArray(input, 1, 5));
+ * assert.isTrue(Arr.isBoundedLengthArray(input, 1, 5));
  *
- * assert.isFalse(isBoundedLengthArray([], 1, 5));
+ * assert.isFalse(Arr.isBoundedLengthArray([], 1, 5));
  *
- * if (isBoundedLengthArray(input, 1, 5)) {
+ * if (Arr.isBoundedLengthArray(input, 1, 5)) {
  *   const selection: BoundedLengthArray<1, 5, number> = input;
  *
  *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])
@@ -168,11 +168,11 @@ export const isBoundedLengthArray = <
  * ```ts
  * const input: readonly number[] = [255, 128, 0];
  *
- * assert.isTrue(isFixedLengthArray(input, 3));
+ * assert.isTrue(Arr.isFixedLengthArray(input, 3));
  *
- * assert.isFalse(isFixedLengthArray(input, 4));
+ * assert.isFalse(Arr.isFixedLengthArray(input, 4));
  *
- * if (isFixedLengthArray(input, 3)) {
+ * if (Arr.isFixedLengthArray(input, 3)) {
  *   const rgb: FixedLengthArray<3, number> = input;
  *
  *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)

package/src/{guard/is-length-bounded-array.test.mts → array/impl/array-utils-length-bounded-array-guard.test.mts}

@@ -4,13 +4,13 @@ import {
   type MaxLengthArray,
   type MinLengthArray,
 } from 'ts-type-forge';
-import { expectType } from '../expect-type.mjs';
+import { expectType } from '../../expect-type.mjs';
 import {
   isBoundedLengthArray,
   isFixedLengthArray,
   isMaxLengthArray,
   isMinLengthArray,
-} from './is-length-bounded-array.mjs';
+} from './array-utils-length-bounded-array-guard.mjs';
 
 describe(isMinLengthArray, () => {
   test('should return true when the array is long enough', () => {

package/src/array/impl/array-utils-modification.mts

@@ -3,6 +3,7 @@ import {
   type Increment,
   type IsFixedLengthList,
   type NonEmptyArray,
+  type NonEmptyTuple,
 } from 'ts-type-forge';
 import { asPositiveUint32 } from '../../number/index.mjs';
 import { castMutable } from '../../others/index.mjs';
@@ -32,7 +33,7 @@ export function set<const Ar extends readonly unknown[], const V = Ar[number]>(
   newValue: V,
 ): IsFixedLengthList<Ar> extends true
   ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number] | V>
     : readonly (Ar[number] | V)[];
 
@@ -44,7 +45,7 @@ export function set<const V>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
   ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number] | V>
     : readonly (Ar[number] | V)[];
 
@@ -97,7 +98,7 @@ export function toUpdated<
   updater: (prev: Ar[number]) => V,
 ): IsFixedLengthList<Ar> extends true
   ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number] | V>
     : readonly (Ar[number] | V)[];
 
@@ -109,7 +110,7 @@ export function toUpdated<E, const V = E>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
   ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number] | V>
     : readonly (Ar[number] | V)[];
 
@@ -368,7 +369,7 @@ export function toFilled<const Ar extends readonly unknown[], const V>(
   value: V,
 ): IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], V>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<V>
     : readonly V[];
 
@@ -379,7 +380,7 @@ export function toFilled<const V>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], V>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<V>
     : readonly V[];
 
@@ -427,7 +428,7 @@ export function toRangeFilled<const Ar extends readonly unknown[], const V>(
   ],
 ): IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], V | Ar[number]>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<V | Ar[number]>
     : readonly (V | Ar[number])[];
 
@@ -442,7 +443,7 @@ export function toRangeFilled<const V>(
   array: Ar,
 ) => IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], V | Ar[number]>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<V | Ar[number]>
     : readonly (V | Ar[number])[];
 

package/src/array/impl/array-utils-modification.test.mts

@@ -61,7 +61,12 @@ describe('Arr modifications', () => {
 
       expectType<typeof result, NonEmptyArray<string | 5>>('=');
 
-      assert.deepStrictEqual(result, ['a', 'b', 'c', 5]);
+      assert.deepStrictEqual<readonly (5 | string)[]>(result, [
+        'a',
+        'b',
+        'c',
+        5,
+      ]);
     });
 
     test('should work with curried version', () => {

package/src/array/impl/array-utils-reducing-value.mts

@@ -1,5 +1,5 @@
 import { isError } from '@sindresorhus/is';
-import { type Int, type NonEmptyArray, type Uint } from 'ts-type-forge';
+import { type Int, type NonEmptyTuple, type Uint } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { Optional, Result } from '../../functional/index.mjs';
 import { isString, isUndefined } from '../../guard/index.mjs';
@@ -40,12 +40,12 @@ export function min<const Ar extends readonly number[]>(
   array: Ar,
   // If the array elements are numbers, comparator is optional.
   comparator?: (x: Ar[number], y: Ar[number]) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function min<const Ar extends readonly unknown[]>(
   array: Ar,
   comparator: (x: Ar[number], y: Ar[number]) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function min<E extends number>(
   array: readonly E[],
@@ -86,12 +86,12 @@ export function max<const Ar extends readonly number[]>(
   array: Ar,
   // If the array elements are numbers, comparator is optional.
   comparator?: (x: Ar[number], y: Ar[number]) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function max<const Ar extends readonly unknown[]>(
   array: Ar,
   comparator: (x: Ar[number], y: Ar[number]) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function max<E extends number>(
   array: readonly E[],
@@ -132,13 +132,13 @@ export function minBy<const Ar extends readonly unknown[]>(
   array: Ar,
   // If the array elements are mapped to numbers, comparator is optional.
   comparatorValueMapper: (value: Ar[number]) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function minBy<const Ar extends readonly unknown[], V>(
   array: Ar,
   comparatorValueMapper: (value: Ar[number]) => V,
   comparator: (x: V, y: V) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function minBy<E, V>(
   array: readonly E[],
@@ -184,13 +184,13 @@ export function maxBy<const Ar extends readonly unknown[]>(
   array: Ar,
   // If the array elements are mapped to numbers, comparator is optional.
   comparatorValueMapper: (value: Ar[number]) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function maxBy<const Ar extends readonly unknown[], V>(
   array: Ar,
   comparatorValueMapper: (value: Ar[number]) => V,
   comparator: (x: V, y: V) => number,
-): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
+): Ar extends NonEmptyTuple<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;
 
 export function maxBy<E, V>(
   array: readonly E[],

package/src/array/impl/array-utils-size.mts

@@ -1,6 +1,6 @@
 import {
   type IntersectBrand,
-  type NonEmptyArray,
+  type NonEmptyTuple,
   type PositiveNumber,
 } from 'ts-type-forge';
 /**
@@ -26,7 +26,7 @@ import { type SizeType } from '../../types.mjs';
 
 export const size = <const Ar extends readonly unknown[]>(
   array: Ar,
-): Ar extends NonEmptyArray<unknown>
+): Ar extends NonEmptyTuple<unknown>
   ? IntersectBrand<PositiveNumber, SizeType.Arr>
   : SizeType.Arr =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion

package/src/array/impl/array-utils-slicing.mts

@@ -1,4 +1,9 @@
-import { type List, type NonEmptyArray, type SmallUint } from 'ts-type-forge';
+import {
+  type List,
+  type NonEmptyArray,
+  type NonEmptyTuple,
+  type StructuralPrefixLength,
+} from 'ts-type-forge';
 import { Uint32 } from '../../number/index.mjs';
 import { type SizeType } from '../../types.mjs';
 import { size } from './array-utils-size.mjs';
@@ -84,10 +89,10 @@ export function take<
 >(
   array: Ar,
   num: N,
-): N extends SmallUint
+): N extends StructuralPrefixLength
   ? List.Take<N, Ar>
   : N extends SizeType.ArgArrPositive
-    ? Ar extends NonEmptyArray<unknown>
+    ? Ar extends NonEmptyTuple<unknown>
       ? NonEmptyArray<Ar[number]>
       : readonly Ar[number][]
     : readonly Ar[number][];
@@ -96,10 +101,10 @@ export function take<N extends SizeType.ArgArr>(
   num: N,
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
-) => N extends SmallUint
+) => N extends StructuralPrefixLength
   ? List.Take<N, Ar>
   : N extends SizeType.ArgArrPositive
-    ? Ar extends NonEmptyArray<unknown>
+    ? Ar extends NonEmptyTuple<unknown>
       ? NonEmptyArray<Ar[number]>
       : readonly Ar[number][]
     : readonly Ar[number][];
@@ -147,10 +152,10 @@ export function takeLast<
 >(
   array: Ar,
   num: N,
-): N extends SmallUint
+): N extends StructuralPrefixLength
   ? List.TakeLast<N, Ar>
   : N extends SizeType.ArgArrPositive
-    ? Ar extends NonEmptyArray<unknown>
+    ? Ar extends NonEmptyTuple<unknown>
       ? NonEmptyArray<Ar[number]>
       : readonly Ar[number][]
     : readonly Ar[number][];
@@ -159,10 +164,10 @@ export function takeLast<N extends SizeType.ArgArr>(
   num: N,
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
-) => N extends SmallUint
+) => N extends StructuralPrefixLength
   ? List.TakeLast<N, Ar>
   : N extends SizeType.ArgArrPositive
-    ? Ar extends NonEmptyArray<unknown>
+    ? Ar extends NonEmptyTuple<unknown>
       ? NonEmptyArray<Ar[number]>
       : readonly Ar[number][]
     : readonly Ar[number][];
@@ -210,14 +215,16 @@ export function skip<
 >(
   array: Ar,
   num: N,
-): N extends SmallUint ? List.Skip<N, Ar> : readonly Ar[number][];
+): N extends StructuralPrefixLength ? List.Skip<N, Ar> : readonly Ar[number][];
 
 // curried version
 export function skip<N extends SizeType.ArgArr>(
   num: N,
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
-) => N extends SmallUint ? List.Skip<N, Ar> : readonly Ar[number][];
+) => N extends StructuralPrefixLength
+  ? List.Skip<N, Ar>
+  : readonly Ar[number][];
 
 export function skip<E>(
   ...args: readonly [readonly E[], SizeType.ArgArr] | readonly [SizeType.ArgArr]
@@ -260,14 +267,18 @@ export function skipLast<
 >(
   array: Ar,
   num: N,
-): N extends SmallUint ? List.SkipLast<N, Ar> : readonly Ar[number][];
+): N extends StructuralPrefixLength
+  ? List.SkipLast<N, Ar>
+  : readonly Ar[number][];
 
 // curried version
 export function skipLast<N extends SizeType.ArgArr>(
   num: N,
 ): <const Ar extends readonly unknown[]>(
   array: Ar,
-) => N extends SmallUint ? List.SkipLast<N, Ar> : readonly Ar[number][];
+) => N extends StructuralPrefixLength
+  ? List.SkipLast<N, Ar>
+  : readonly Ar[number][];
 
 export function skipLast<E>(
   ...args:

package/src/array/impl/array-utils-transformation.mts

@@ -2,8 +2,8 @@ import {
   type FixedLengthTuple,
   type IsFixedLengthList,
   type List,
-  type MutableNonEmptyArray,
   type NonEmptyArray,
+  type NonEmptyTuple,
   type PositiveInt,
   type PositiveUint32,
   type Primitive,
@@ -98,9 +98,12 @@ export function map<A, B>(
  *
  * const expectedCurriedTotals = [10, 5, 20] as const;
  *
- * assert.deepStrictEqual(runningTotals, expectedTotals);
+ * assert.deepStrictEqual<readonly number[]>(runningTotals, expectedTotals);
  *
- * assert.deepStrictEqual(runningTotalsFromCurried, expectedCurriedTotals);
+ * assert.deepStrictEqual<readonly number[]>(
+ *   runningTotalsFromCurried,
+ *   expectedCurriedTotals,
+ * );
  * ```
  */
 export function scan<const Ar extends readonly unknown[], S>(
@@ -137,12 +140,12 @@ export function scan<E, S>(
         ) => S,
         init: S,
       ]
-): NonEmptyArray<S> | ((array: readonly E[]) => NonEmptyArray<S>) {
+): NonEmptyTuple<S> | ((array: readonly E[]) => NonEmptyTuple<S>) {
   switch (args.length) {
     case 3: {
       const [array, reducer, init] = args;
 
-      const mut_result: MutableNonEmptyArray<S> = castMutable(
+      const mut_result = castMutable<NonEmptyTuple<S>>(
         newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),
       );
 
@@ -221,7 +224,7 @@ export const toSorted = <const Ar extends readonly unknown[]>(
     : readonly [array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number]
 ): IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], Ar[number]>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number]>
     : readonly Ar[number][] =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -279,7 +282,7 @@ export function toSortedBy<const Ar extends readonly unknown[]>(
   comparator?: (x: number, y: number) => number,
 ): IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], Ar[number]>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number]>
     : readonly Ar[number][];
 
@@ -289,7 +292,7 @@ export function toSortedBy<const Ar extends readonly unknown[], const V>(
   comparator: (x: V, y: V) => number,
 ): IsFixedLengthList<Ar> extends true
   ? FixedLengthTuple<Ar['length'], Ar[number]>
-  : Ar extends NonEmptyArray<unknown>
+  : Ar extends NonEmptyTuple<unknown>
     ? NonEmptyArray<Ar[number]>
     : readonly Ar[number][];
 
@@ -434,12 +437,12 @@ export function filterNot<E>(
  *
  * const expected = ['a', 'b', 'c'] as const;
  *
- * assert.deepStrictEqual(uniqueLetters, expected);
+ * assert.deepStrictEqual<readonly string[]>(uniqueLetters, expected);
  * ```
  */
 export const uniq = <const Ar extends readonly Primitive[]>(
   array: Ar,
-): Ar extends NonEmptyArray<unknown>
+): Ar extends NonEmptyTuple<unknown>
   ? NonEmptyArray<Ar[number]>
   : readonly Ar[number][] =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -466,7 +469,10 @@ export const uniq = <const Ar extends readonly Primitive[]>(
  *   { id: 3, name: 'Grace' },
  * ] as const;
  *
- * assert.deepStrictEqual(uniqueById, expected);
+ * assert.deepStrictEqual<readonly Readonly<{ id: number; name: string }>[]>(
+ *   uniqueById,
+ *   expected,
+ * );
  * ```
  */
 export const uniqBy = <
@@ -475,7 +481,7 @@ export const uniqBy = <
 >(
   array: Ar,
   mapFn: (value: Ar[number]) => P,
-): Ar extends NonEmptyArray<unknown>
+): Ar extends NonEmptyTuple<unknown>
   ? NonEmptyArray<Ar[number]>
   : readonly Ar[number][] => {
   const mut_mappedValues = new Set<P>();

package/src/array/impl/array-utils-transformation.test.mts

@@ -73,7 +73,7 @@ describe('Arr transformations', () => {
 
       expectType<typeof runningSum, readonly [number, ...number[]]>('<=');
 
-      assert.deepStrictEqual(runningSum, [0, 1, 3, 6, 10]);
+      assert.deepStrictEqual<readonly number[]>(runningSum, [0, 1, 3, 6, 10]);
     });
 
     test('should include initial value as first element', () => {
@@ -81,7 +81,7 @@ describe('Arr transformations', () => {
 
       const result = scan(numbers, (acc, curr) => acc + curr, 100);
 
-      assert.deepStrictEqual(result, [100, 110, 130, 160]);
+      assert.deepStrictEqual<readonly number[]>(result, [100, 110, 130, 160]);
 
       expect(result).toHaveLength(4); // original length + 1
     });
@@ -93,9 +93,9 @@ describe('Arr transformations', () => {
 
       const result2 = scanSum([5, 10]);
 
-      assert.deepStrictEqual(result1, [0, 1, 3, 6]);
+      assert.deepStrictEqual<readonly number[]>(result1, [0, 1, 3, 6]);
 
-      assert.deepStrictEqual(result2, [0, 5, 15]);
+      assert.deepStrictEqual<readonly number[]>(result2, [0, 5, 15]);
     });
 
     test('should provide index to reducer', () => {
@@ -121,7 +121,7 @@ describe('Arr transformations', () => {
 
       const result = scan(empty, (acc, curr) => acc + curr, 42);
 
-      assert.deepStrictEqual(result, [42]);
+      assert.deepStrictEqual<readonly number[]>(result, [42]);
     });
 
     test('should work with different accumulator and element types', () => {
@@ -131,7 +131,7 @@ describe('Arr transformations', () => {
 
       expectType<typeof result, readonly [number, ...number[]]>('<=');
 
-      assert.deepStrictEqual(result, [0, 1, 2, 3]);
+      assert.deepStrictEqual<readonly number[]>(result, [0, 1, 2, 3]);
     });
 
     test('should compute running product', () => {
@@ -139,7 +139,7 @@ describe('Arr transformations', () => {
 
       const runningProduct = scan(numbers, (acc, curr) => acc * curr, 1);
 
-      assert.deepStrictEqual(runningProduct, [1, 2, 6, 24]);
+      assert.deepStrictEqual<readonly number[]>(runningProduct, [1, 2, 6, 24]);
     });
 
     test('should work with objects', () => {
@@ -147,7 +147,7 @@ describe('Arr transformations', () => {
 
       const result = scan(items, (acc, curr) => acc + curr.value, 0);
 
-      assert.deepStrictEqual(result, [0, 10, 30, 60]);
+      assert.deepStrictEqual<readonly number[]>(result, [0, 10, 30, 60]);
     });
 
     test('should preserve all intermediate values', () => {
@@ -156,7 +156,7 @@ describe('Arr transformations', () => {
       const result = scan(numbers, (acc, curr) => acc - curr, 10);
 
       // 10 -> 10-1=9 -> 9-2=7 -> 7-3=4
-      assert.deepStrictEqual(result, [10, 9, 7, 4]);
+      assert.deepStrictEqual<readonly number[]>(result, [10, 9, 7, 4]);
     });
   });
 
@@ -429,7 +429,7 @@ describe('Arr transformations', () => {
 
       const result = uniq(array);
 
-      assert.deepStrictEqual(result, [1, 2, 3, 4]);
+      assert.deepStrictEqual<readonly number[]>(result, [1, 2, 3, 4]);
     });
 
     test('should work with strings', () => {
@@ -437,7 +437,7 @@ describe('Arr transformations', () => {
 
       const result = uniq(array);
 
-      assert.deepStrictEqual(result, ['a', 'b', 'c']);
+      assert.deepStrictEqual<readonly string[]>(result, ['a', 'b', 'c']);
     });
 
     test('should work with empty array', () => {
@@ -453,7 +453,7 @@ describe('Arr transformations', () => {
 
       const result = uniq(array);
 
-      assert.deepStrictEqual(result, [3, 1, 2]);
+      assert.deepStrictEqual<readonly number[]>(result, [3, 1, 2]);
     });
   });
 

package/src/array/impl/index.mts

@@ -1,6 +1,8 @@
 export * from './array-utils-creation.mjs';
 export * from './array-utils-element-access.mjs';
 export * from './array-utils-iterators.mjs';
+export * from './array-utils-length-bounded-array-cast.mjs';
+export * from './array-utils-length-bounded-array-guard.mjs';
 export * from './array-utils-modification.mjs';
 export * from './array-utils-reducing-value.mjs';
 export * from './array-utils-search.mjs';

package/src/guard/index.mts

@@ -1,7 +1,4 @@
-export * from './as-length-bounded-array.mjs';
 export * from './has-key.mjs';
-export * from './is-length-bounded-array.mjs';
-export * from './is-length-bounded-string.mjs';
 export * from './is-non-empty-string.mjs';
 export * from './is-non-null-object.mjs';
 export * from './is-primitive.mjs';

package/src/index.mts

@@ -7,4 +7,5 @@ export * from './number/index.mjs';
 export * from './object/index.mjs';
 export * from './others/index.mjs';
 export * from './promise/index.mjs';
+export * from './string/index.mjs';
 export * from './types.mjs';

package/src/string/index.mts

@@ -0,0 +1 @@
+export * from './str.mjs';