ts-data-forge 14.7.0 → 14.8.0

package/src/array/impl/array-utils-length-bounded-array-guard.test.mts

@@ -1,8 +1,8 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type MaxLengthArray,
-  type MinLengthArray,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  MaxLengthArray,
+  MinLengthArray,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -32,39 +32,43 @@ describe(isMinLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [0, 1, 2, 3] as const;
 
-    if (isMinLengthArray(3, value)) {
-      expectType<typeof value, MinLengthArray<3, number>>('<=');
+    if (!isMinLengthArray(3, value)) {
+      return;
+    }
 
-      expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
+    expectType<typeof value, MinLengthArray<3, number>>('<=');
 
-      expectType<typeof value, MinLengthArray<5, number>>('!<=');
+    expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
 
-      // indexed access below the minimum length does not include `undefined`
-      // (even under `noUncheckedIndexedAccess`)
-      const _first = value[0];
+    expectType<typeof value, MinLengthArray<5, number>>('!<=');
 
-      expectType<typeof _first, number>('=');
+    // indexed access below the minimum length does not include `undefined`
+    // (even under `noUncheckedIndexedAccess`)
+    const _first = value[0];
 
-      const _third = value[2];
+    expectType<typeof _first, number>('=');
 
-      expectType<typeof _third, number>('=');
+    const _third = value[2];
 
-      const _fourth = value[3];
+    expectType<typeof _third, number>('=');
 
-      expectType<typeof _fourth, number | undefined>('=');
+    const _fourth = value[3];
 
-      expect(value.length).toBeGreaterThanOrEqual(3);
-    }
+    expectType<typeof _fourth, number | undefined>('=');
+
+    expect(value.length).toBeGreaterThanOrEqual(3);
   });
 
   test('should preserve the original array type', () => {
     const tuple = [1, 2, 3] as const;
 
-    if (isMinLengthArray(2, tuple)) {
-      expectType<typeof tuple, readonly [1, 2, 3]>('<=');
-
-      expectType<typeof tuple, MinLengthArray<2, 1 | 2 | 3>>('<=');
+    if (!isMinLengthArray(2, tuple)) {
+      return;
     }
+
+    expectType<typeof tuple, readonly [1, 2, 3]>('<=');
+
+    expectType<typeof tuple, MinLengthArray<2, 1 | 2 | 3>>('<=');
   });
 });
 
@@ -86,15 +90,17 @@ describe(isMaxLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [0, 1, 2] as const;
 
-    if (isMaxLengthArray(8, value)) {
-      expectType<typeof value, MaxLengthArray<8, number>>('<=');
+    if (!isMaxLengthArray(8, value)) {
+      return;
+    }
 
-      expectType<typeof value, MaxLengthArray<16, number>>('<='); // 8 <= 16
+    expectType<typeof value, MaxLengthArray<8, number>>('<=');
 
-      expectType<typeof value, MaxLengthArray<2, number>>('!<=');
+    expectType<typeof value, MaxLengthArray<16, number>>('<='); // 8 <= 16
 
-      expect(value.length).toBeLessThanOrEqual(8);
-    }
+    expectType<typeof value, MaxLengthArray<2, number>>('!<=');
+
+    expect(value.length).toBeLessThanOrEqual(8);
   });
 });
 
@@ -116,17 +122,19 @@ describe(isBoundedLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [1, 2, 3] as const;
 
-    if (isBoundedLengthArray(1, 5, value)) {
-      expectType<typeof value, BoundedLengthArray<1, 5, number>>('<=');
+    if (!isBoundedLengthArray(1, 5, value)) {
+      return;
+    }
 
-      expectType<typeof value, BoundedLengthArray<0, 100, number>>('<=');
+    expectType<typeof value, BoundedLengthArray<1, 5, number>>('<=');
 
-      expectType<typeof value, MinLengthArray<1, number>>('<=');
+    expectType<typeof value, BoundedLengthArray<0, 100, number>>('<=');
 
-      expectType<typeof value, MaxLengthArray<5, number>>('<=');
+    expectType<typeof value, MinLengthArray<1, number>>('<=');
 
-      expectType<typeof value, BoundedLengthArray<2, 5, number>>('!<=');
-    }
+    expectType<typeof value, MaxLengthArray<5, number>>('<=');
+
+    expectType<typeof value, BoundedLengthArray<2, 5, number>>('!<=');
   });
 });
 
@@ -146,27 +154,29 @@ describe(isFixedLengthArray, () => {
   test('should act as a type guard', () => {
     const value: readonly number[] = [255, 128, 0] as const;
 
-    if (isFixedLengthArray(3, value)) {
-      expectType<typeof value, FixedLengthArray<3, number>>('<=');
+    if (!isFixedLengthArray(3, value)) {
+      return;
+    }
 
-      expectType<typeof value, MaxLengthArray<5, number>>('<='); // 3 <= 5
+    expectType<typeof value, FixedLengthArray<3, number>>('<=');
 
-      expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
+    expectType<typeof value, MaxLengthArray<5, number>>('<='); // 3 <= 5
 
-      expectType<typeof value, FixedLengthArray<4, number>>('!<=');
+    expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
 
-      // `length` is narrowed to the literal and in-range indexed access does
-      // not include `undefined` (even under `noUncheckedIndexedAccess`)
-      const _len = value.length;
+    expectType<typeof value, FixedLengthArray<4, number>>('!<=');
 
-      expectType<typeof _len, 3>('=');
+    // `length` is narrowed to the literal and in-range indexed access does
+    // not include `undefined` (even under `noUncheckedIndexedAccess`)
+    const _len = value.length;
 
-      const _second = value[1];
+    expectType<typeof _len, 3>('=');
 
-      expectType<typeof _second, number>('=');
+    const _second = value[1];
 
-      expect(value).toHaveLength(3);
-    }
+    expectType<typeof _second, number>('=');
+
+    expect(value).toHaveLength(3);
   });
 });
 
@@ -182,13 +192,15 @@ describe('curried length guards', () => {
 
     assert.isTrue(hasThree(value));
 
-    if (hasThree(value)) {
-      expectType<typeof value, MinLengthArray<3, number>>('<=');
+    if (!hasThree(value)) {
+      return;
+    }
 
-      const _first = value[0];
+    expectType<typeof value, MinLengthArray<3, number>>('<=');
 
-      expectType<typeof _first, number>('=');
-    }
+    const _first = value[0];
+
+    expectType<typeof _first, number>('=');
   });
 
   test('isMaxLengthArray narrows when applied later', () => {

package/src/array/impl/array-utils-length-bounded-tuple-cast.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import {
   isBoundedLengthTuple,
   isEmptyTuple,
@@ -36,7 +36,11 @@ import {
  * // curried version
  * const asRgb = Arr.asFixedLengthTuple(3);
  *
- * // Arr.asFixedLengthTuple(3, [255, 128]); // throws TypeError
+ * assert.strictEqual(red, 255);
+ *
+ * assert.deepStrictEqual(asRgb([0, 255, 0]), [0, 255, 0]);
+ *
+ * assert.throws(() => Arr.asFixedLengthTuple(3, [255, 128]), TypeError);
  * ```
  *
  * @template Length - The exact number of elements.
@@ -104,7 +108,11 @@ const asFixedLengthTupleImpl = (
  * // curried version
  * const asHistory = Arr.asMinLengthTuple(3);
  *
- * // Arr.asMinLengthTuple(3, [0, 1]); // throws TypeError
+ * assert.strictEqual(first, 0);
+ *
+ * assert.deepStrictEqual(asHistory([4, 5, 6]), [4, 5, 6]);
+ *
+ * assert.throws(() => Arr.asMinLengthTuple(3, [0, 1]), TypeError);
  * ```
  *
  * @template MinLength - The minimum number of elements (inclusive).
@@ -170,7 +178,11 @@ const asMinLengthTupleImpl = (
  * // curried version
  * const asTags = Arr.asMaxLengthTuple(8);
  *
- * // Arr.asMaxLengthTuple(2, ['a', 'b', 'c']); // throws TypeError
+ * assert.deepStrictEqual(tags, ['a', 'b', 'c']);
+ *
+ * assert.deepStrictEqual(asTags(['d', 'e']), ['d', 'e']);
+ *
+ * assert.throws(() => Arr.asMaxLengthTuple(2, ['a', 'b', 'c']), TypeError);
  * ```
  *
  * @template MaxLength - The maximum number of elements (inclusive).
@@ -236,7 +248,11 @@ const asMaxLengthTupleImpl = (
  * // curried version
  * const asSelection = Arr.asBoundedLengthTuple(1, 5);
  *
- * // Arr.asBoundedLengthTuple(1, 2, [1, 2, 3]); // throws TypeError
+ * assert.deepStrictEqual(selection, [1, 2, 3]);
+ *
+ * assert.deepStrictEqual(asSelection([4, 5]), [4, 5]);
+ *
+ * assert.throws(() => Arr.asBoundedLengthTuple(1, 2, [1, 2, 3]), TypeError);
  * ```
  *
  * @template Min - The minimum number of elements (inclusive).
@@ -311,7 +327,9 @@ const asBoundedLengthTupleImpl = (
  * ```ts
  * const nothing = Arr.asEmptyTuple([]);
  *
- * // Arr.asEmptyTuple([1]); // throws TypeError
+ * assert.deepStrictEqual(nothing, []);
+ *
+ * assert.throws(() => Arr.asEmptyTuple([1]), TypeError);
  * ```
  *
  * @template Xs - The input array type (tuple types are preserved).
@@ -345,7 +363,9 @@ export const asEmptyTuple = <Xs extends readonly unknown[]>(
  *
  * const first: number = values[0]; // OK — no `undefined`
  *
- * // Arr.asNonEmptyTuple([]); // throws TypeError
+ * assert.strictEqual(first, 1);
+ *
+ * assert.throws(() => Arr.asNonEmptyTuple([]), TypeError);
  * ```
  *
  * @template Xs - The input array type (tuple types are preserved).

package/src/array/impl/array-utils-length-bounded-tuple-cast.test.mts

@@ -1,8 +1,8 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -24,7 +24,7 @@ describe(asFixedLengthTuple, () => {
 
     const red: number = casted[0];
 
-    assert.deepStrictEqual(red, 255);
+    assert.strictEqual(red, 255);
   });
 
   test('is the same value it was handed', () => {
@@ -69,7 +69,7 @@ describe(asMinLengthTuple, () => {
 
     const first: number = casted[0];
 
-    assert.deepStrictEqual(first, 0);
+    assert.strictEqual(first, 0);
   });
 
   test('throws when the array is too short', () => {
@@ -168,7 +168,7 @@ describe(asNonEmptyTuple, () => {
 
     const first: number = casted[0];
 
-    assert.deepStrictEqual(first, 1);
+    assert.strictEqual(first, 1);
   });
 
   test('throws when the array is empty', () => {
@@ -190,7 +190,7 @@ describe('tuple casts preserve the input type, like their branded counterparts',
 
     const length: 5 = casted.length;
 
-    assert.deepStrictEqual(length, 5);
+    assert.strictEqual(length, 5);
 
     assert.deepStrictEqual<readonly number[]>(casted, [1, 2, 3, 4, 5]);
   });
@@ -202,6 +202,6 @@ describe('tuple casts preserve the input type, like their branded counterparts',
 
     const first: 1 = casted[0];
 
-    assert.deepStrictEqual(first, 1);
+    assert.strictEqual(first, 1);
   });
 });

package/src/array/impl/array-utils-length-bounded-tuple-guard.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 
 /**
  * Type guard that checks if an array is empty, narrowing it to the structural
@@ -218,7 +218,7 @@ const hasMaxLength = (
  * assert.isFalse(Arr.isBoundedLengthTuple(1, 3, quad));
  *
  * if (Arr.isBoundedLengthTuple(1, 3, pair)) {
- *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ *   assert.isTrue(1 <= pair.length && pair.length <= 3);
  * }
  * ```
  */
@@ -263,4 +263,4 @@ const isWithinBounds = (
   min: SizeType.ArgArr,
   max: SizeType.ArgArr,
   array: readonly unknown[],
-): boolean => array.length >= min && array.length <= max;
+): boolean => min <= array.length && array.length <= max;

package/src/array/impl/array-utils-length-bounded-tuple-guard.test.mts

@@ -1,8 +1,8 @@
-import {
-  type BoundedLengthTuple,
-  type FixedLengthTuple,
-  type MaxLengthTuple,
-  type MinLengthTuple,
+import type {
+  BoundedLengthTuple,
+  FixedLengthTuple,
+  MaxLengthTuple,
+  MinLengthTuple,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -92,11 +92,13 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard with exact length (additional)', () => {
       const array: readonly number[] = [1, 2, 3] as const;
 
-      if (isFixedLengthTuple(3, array)) {
-        expectType<typeof array, FixedLengthTuple<3, number>>('=');
-
-        expect(array).toHaveLength(3);
+      if (!isFixedLengthTuple(3, array)) {
+        return;
       }
+
+      expectType<typeof array, FixedLengthTuple<3, number>>('=');
+
+      expect(array).toHaveLength(3);
     });
   });
 
@@ -180,11 +182,13 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard for at least length (additional)', () => {
       const array: readonly number[] = [1, 2, 3] as const;
 
-      if (isMinLengthTuple(2, array)) {
-        expectType<typeof array, MinLengthTuple<2, number>>('=');
-
-        expect(array.length).toBeGreaterThanOrEqual(2);
+      if (!isMinLengthTuple(2, array)) {
+        return;
       }
+
+      expectType<typeof array, MinLengthTuple<2, number>>('=');
+
+      expect(array.length).toBeGreaterThanOrEqual(2);
     });
   });
 
@@ -255,11 +259,13 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard for at most length (additional)', () => {
       const array: readonly number[] = [1, 2] as const;
 
-      if (isMaxLengthTuple(3, array)) {
-        expectType<typeof array, MaxLengthTuple<3, number>>('=');
-
-        expect(array.length).toBeLessThanOrEqual(3);
+      if (!isMaxLengthTuple(3, array)) {
+        return;
       }
+
+      expectType<typeof array, MaxLengthTuple<3, number>>('=');
+
+      expect(array.length).toBeLessThanOrEqual(3);
     });
   });
 
@@ -332,13 +338,15 @@ describe('Arr structural tuple length guards', () => {
     test('should work as type guard for bounded length (additional)', () => {
       const array: readonly number[] = [1, 2] as const;
 
-      if (isBoundedLengthTuple(1, 3, array)) {
-        expectType<typeof array, BoundedLengthTuple<1, 3, number>>('=');
+      if (!isBoundedLengthTuple(1, 3, array)) {
+        return;
+      }
 
-        expect(array.length).toBeGreaterThanOrEqual(1);
+      expectType<typeof array, BoundedLengthTuple<1, 3, number>>('=');
 
-        expect(array.length).toBeLessThanOrEqual(3);
-      }
+      expect(array.length).toBeGreaterThanOrEqual(1);
+
+      expect(array.length).toBeLessThanOrEqual(3);
     });
   });
 
@@ -364,14 +372,16 @@ describe('Arr structural tuple length guards', () => {
 
       assert.isTrue(isNonEmptyTuple(values));
 
-      if (isNonEmptyTuple(values)) {
-        expectType<typeof values, MinLengthTuple<1, number>>('=');
+      if (!isNonEmptyTuple(values)) {
+        return;
+      }
+
+      expectType<typeof values, MinLengthTuple<1, number>>('=');
 
-        // The structural prefix makes the first element defined.
-        const first: number = values[0];
+      // The structural prefix makes the first element defined.
+      const first: number = values[0];
 
-        assert.deepStrictEqual(first, 1);
-      }
+      assert.strictEqual(first, 1);
     });
 
     test('rejects an empty array', () => {

package/src/array/impl/array-utils-length-constraint-preservation.test.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type FixedLengthTuple,
-  type MaxLengthArray,
-  type MinLengthArray,
-  type Seq,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  FixedLengthTuple,
+  MaxLengthArray,
+  MinLengthArray,
+  Seq,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { copy, create, seq, zeros } from './array-utils-creation.mjs';
@@ -39,7 +39,7 @@ describe('map preserves length constraints', () => {
     // The structural prefix survives, so in-range access is not `undefined`.
     const first: string = result[0];
 
-    assert.deepStrictEqual(first, '#0');
+    assert.strictEqual(first, '#0');
 
     assert.deepStrictEqual<readonly string[]>(result, ['#0', '#1', '#2', '#3']);
   });
@@ -56,7 +56,7 @@ describe('map preserves length constraints', () => {
 
     const length: 3 = result.length;
 
-    assert.deepStrictEqual(length, 3);
+    assert.strictEqual(length, 3);
   });
 
   test('a minimum above the structural prefix cap survives, clamped like MinLengthArray itself', () => {
@@ -199,7 +199,7 @@ describe('other length-preserving utilities preserve length constraints', () =>
     // The structural prefix survives the reversal too.
     const first: number = result[0];
 
-    assert.deepStrictEqual(first, 4);
+    assert.strictEqual(first, 4);
 
     assert.deepStrictEqual<readonly number[]>(result, [4, 3, 2, 1]);
   });
@@ -242,7 +242,7 @@ describe('partition reports the bounds of each chunk', () => {
 
     const first: 1 | 2 | 3 | 4 | 5 = firstChunk[0];
 
-    assert.deepStrictEqual(first, 1);
+    assert.strictEqual(first, 1);
 
     assert.deepStrictEqual<readonly (readonly number[])[]>(result, [
       [1, 2],
@@ -262,7 +262,7 @@ describe('creation utilities report an exact length past their tuple range', ()
 
     expectType<typeof result, FixedLengthArray<12, 'x'>>('~=');
 
-    assert.deepStrictEqual(result.length, 12);
+    assert.strictEqual(result.length, 12);
   });
 
   test('a length still inside the tuple range keeps its exact tuple type', () => {
@@ -280,8 +280,8 @@ describe('creation utilities report an exact length past their tuple range', ()
 
     expectType<typeof seq12, Seq<12>>('=');
 
-    assert.deepStrictEqual(zeros12.length, 12);
+    assert.strictEqual(zeros12.length, 12);
 
-    assert.deepStrictEqual(seq12.length, 12);
+    assert.strictEqual(seq12.length, 12);
   });
 });

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

@@ -1,18 +1,18 @@
-import {
-  type ChangeArrayElement,
-  type ConstrainedList,
-  type FixedLengthTuple,
-  type Increment,
-  type IsFixedLengthList,
-  type NonEmptyArray,
-  type UnknownBrand,
+import type {
+  ChangeArrayElement,
+  ConstrainedList,
+  FixedLengthTuple,
+  Increment,
+  IsFixedLengthList,
+  NonEmptyArray,
+  UnknownBrand,
 } from 'ts-type-forge';
 import { asPositiveUint32 } from '../../number/index.mjs';
 import { castMutable } from '../../others/index.mjs';
-import {
-  type ArgArrayIndex,
-  type ArgArrayIndexWithNegative,
-  type SizeType,
+import type {
+  ArgArrayIndex,
+  ArgArrayIndexWithNegative,
+  SizeType,
 } from '../../types.mjs';
 import { copy, create } from './array-utils-creation.mjs';
 

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

@@ -1,13 +1,13 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type FixedLengthTuple,
-  type MinLengthArray,
-  type NonEmptyArray,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  FixedLengthTuple,
+  MinLengthArray,
+  NonEmptyArray,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { asUint32 } from '../../number/index.mjs';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import {
   asBoundedLengthArray,
   asFixedLengthArray,

package/src/array/impl/array-utils-overload-type-error.test.mts

@@ -1,6 +1,6 @@
 import { expectType } from '../../expect-type.mjs';
 import { pipe } from '../../functional/index.mjs';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import { range } from './array-utils-creation.mjs';
 import { findIndex } from './array-utils-search.mjs';
 import { filterNot, partition } from './array-utils-transformation.mjs';

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

@@ -1,15 +1,15 @@
 import { isError } from '@sindresorhus/is';
-import { type Int, type NonEmptyTuple, type Uint } from 'ts-type-forge';
+import type { Int, NonEmptyTuple, 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';
 import { asUint32, Num, Uint32 } from '../../number/index.mjs';
 import { unknownToString } from '../../others/index.mjs';
-import {
-  type ArrayIndex,
-  type MapSetKeyType,
-  type SizeType,
-  type Some,
+import type {
+  ArrayIndex,
+  MapSetKeyType,
+  SizeType,
+  Some,
 } from '../../types.mjs';
 import { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
 
@@ -605,11 +605,9 @@ export function join(
     case 1: {
       const [arg] = args;
 
-      if (isString(arg) || isUndefined(arg)) {
-        return (array) => joinImpl(array, arg);
-      }
-
-      return joinImpl(arg, undefined);
+      return isString(arg) || isUndefined(arg)
+        ? (array) => joinImpl(array, arg)
+        : joinImpl(arg, undefined);
     }
 
     case 2: {

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

@@ -1,8 +1,8 @@
-import { type Uint32 } from 'ts-type-forge';
+import type { Uint32 } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { expectType } from '../../expect-type.mjs';
 import { Optional, Result } from '../../functional/index.mjs';
-import { type Some } from '../../types.mjs';
+import type { Some } from '../../types.mjs';
 import {
   count,
   countBy,