ts-data-forge 14.0.0 → 14.1.0

package/src/number/branded-types/non-positive-finite-number.test.mts

@@ -13,17 +13,13 @@ describe('NonPositiveFiniteNumber test', () => {
 
       expect(() => asNonPositiveFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asNonPositiveFiniteNumber(-3.14)).not.toThrow();
+      expect(() => asNonPositiveFiniteNumber(-1.23)).not.toThrow();
 
       expect(() => asNonPositiveFiniteNumber(-0.5)).not.toThrow();
 
-      expect(() =>
-        asNonPositiveFiniteNumber(Number.MIN_VALUE * -1),
-      ).not.toThrow();
+      expect(() => asNonPositiveFiniteNumber(-Number.MIN_VALUE)).not.toThrow();
 
-      expect(() =>
-        asNonPositiveFiniteNumber(Number.MAX_VALUE * -1),
-      ).not.toThrow();
+      expect(() => asNonPositiveFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects positive numbers', () => {
@@ -63,11 +59,11 @@ describe('NonPositiveFiniteNumber test', () => {
 
       assert.isTrue(isNonPositiveFiniteNumber(-1));
 
-      assert.isTrue(isNonPositiveFiniteNumber(-3.14));
+      assert.isTrue(isNonPositiveFiniteNumber(-1.23));
 
       assert.isTrue(isNonPositiveFiniteNumber(-0.5));
 
-      assert.isTrue(isNonPositiveFiniteNumber(Number.MIN_VALUE * -1));
+      assert.isTrue(isNonPositiveFiniteNumber(-Number.MIN_VALUE));
     });
 
     test('correctly rejects positive numbers', () => {

package/src/number/branded-types/non-zero-finite-number.test.mts

@@ -13,7 +13,7 @@ describe('NonZeroFiniteNumber test', () => {
 
       expect(() => asNonZeroFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(3.14)).not.toThrow();
+      expect(() => asNonZeroFiniteNumber(1.23)).not.toThrow();
 
       expect(() => asNonZeroFiniteNumber(-2.5)).not.toThrow();
 
@@ -73,7 +73,7 @@ describe('NonZeroFiniteNumber test', () => {
 
       assert.isTrue(isNonZeroFiniteNumber(-1));
 
-      assert.isTrue(isNonZeroFiniteNumber(3.14));
+      assert.isTrue(isNonZeroFiniteNumber(1.23));
 
       assert.isTrue(isNonZeroFiniteNumber(-2.5));
 

package/src/number/branded-types/positive-finite-number.test.mts

@@ -11,7 +11,7 @@ describe('PositiveFiniteNumber test', () => {
     test('accepts valid positive finite numbers', () => {
       expect(() => asPositiveFiniteNumber(1)).not.toThrow();
 
-      expect(() => asPositiveFiniteNumber(3.14)).not.toThrow();
+      expect(() => asPositiveFiniteNumber(1.23)).not.toThrow();
 
       expect(() => asPositiveFiniteNumber(0.5)).not.toThrow();
 
@@ -75,7 +75,7 @@ describe('PositiveFiniteNumber test', () => {
     test('correctly identifies positive finite numbers', () => {
       assert.isTrue(isPositiveFiniteNumber(1));
 
-      assert.isTrue(isPositiveFiniteNumber(3.14));
+      assert.isTrue(isPositiveFiniteNumber(1.23));
 
       assert.isTrue(isPositiveFiniteNumber(0.5));
 

package/src/number/enum/int8.mts

@@ -1,6 +1,7 @@
 import {
   type AbsoluteValue,
   type Int16,
+  type StrictExclude,
   type Int8 as TtfImported_Int8,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
@@ -54,7 +55,7 @@ const sub = (x: Int8, y: Int8): Int8 => fromNumber(x - y);
 
 const mul = (x: Int8, y: Int8): Int8 => fromNumber(x * y);
 
-const div = (x: Int8, y: Exclude<Int8, 0>): Int8 =>
+const div = (x: Int8, y: StrictExclude<Int8, 0>): Int8 =>
   fromNumber(Math.floor(x / y));
 
 const random = (min: Int8, max: Int8): Int8 =>

package/src/number/enum/uint8.mts

@@ -1,4 +1,8 @@
-import { type Uint8 as TtfImported_Uint8, type Uint16 } from 'ts-type-forge';
+import {
+  type StrictExclude,
+  type Uint8 as TtfImported_Uint8,
+  type Uint16,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
@@ -44,7 +48,7 @@ const sub = (x: Uint8, y: Uint8): Uint8 => fromNumber(x - y);
 
 const mul = (x: Uint8, y: Uint8): Uint8 => fromNumber(x * y);
 
-const div = (x: Uint8, y: Exclude<Uint8, 0>): Uint8 =>
+const div = (x: Uint8, y: StrictExclude<Uint8, 0>): Uint8 =>
   fromNumber(Math.floor(x / y));
 
 const random = (min: Uint8, max: Uint8): Uint8 =>

package/src/number/num-arithmetic-types.mts

@@ -1,4 +1,6 @@
 import {
+  type BoolAnd,
+  type BoolOr,
   type FiniteNumber,
   type Int,
   type NegativeFiniteNumber,
@@ -6,6 +8,7 @@ import {
   type NegativeNumber,
   type NegativeSafeInt,
   type NonNegativeFiniteNumber,
+  type NonNegativeInt,
   type NonNegativeNumber,
   type NonPositiveFiniteNumber,
   type NonPositiveInt,
@@ -23,6 +26,7 @@ import {
   type SafeUint,
   type Uint,
 } from 'ts-type-forge';
+import { expectType } from '../expect-type.mjs';
 
 /**
  * Internal type-level arithmetic for {@link Num}'s `add`/`sub`/`mul`/`div`.
@@ -75,14 +79,6 @@ export type LevelOf<N> = [N] extends [SafeInt]
 
 // --- boolean fact algebra over a sign ----------------------------------------
 
-type And<A extends boolean, B extends boolean> = [A, B] extends [true, true]
-  ? true
-  : false;
-
-type Or<A extends boolean, B extends boolean> = true extends A | B
-  ? true
-  : false;
-
 /** Whether the value is guaranteed `>= 0`. */
 type Ge0<S extends Sign> = S extends 'pos' | 'nonneg' ? true : false;
 
@@ -93,7 +89,7 @@ type Le0<S extends Sign> = S extends 'neg' | 'nonpos' ? true : false;
 type Ne0<S extends Sign> = S extends 'pos' | 'neg' | 'nonzero' ? true : false;
 
 /** Rebuilds a {@link Sign} from the three facts. */
-type FromFacts<
+type SignFromFacts<
   ge0 extends boolean,
   le0 extends boolean,
   ne0 extends boolean,
@@ -109,16 +105,16 @@ type FromFacts<
       ? 'nonzero'
       : 'any';
 
-type NegateSign<S extends Sign> = FromFacts<Le0<S>, Ge0<S>, Ne0<S>>;
+type NegateSign<S extends Sign> = SignFromFacts<Le0<S>, Ge0<S>, Ne0<S>>;
 
 // --- sign combination per operation ------------------------------------------
 
-type AddSign<A extends Sign, B extends Sign> = FromFacts<
-  And<Ge0<A>, Ge0<B>>,
-  And<Le0<A>, Le0<B>>,
-  Or<
-    And<And<Ge0<A>, Ge0<B>>, Or<Ne0<A>, Ne0<B>>>,
-    And<And<Le0<A>, Le0<B>>, Or<Ne0<A>, Ne0<B>>>
+type AddSign<A extends Sign, B extends Sign> = SignFromFacts<
+  BoolAnd<Ge0<A>, Ge0<B>>,
+  BoolAnd<Le0<A>, Le0<B>>,
+  BoolOr<
+    BoolAnd<BoolAnd<Ge0<A>, Ge0<B>>, BoolOr<Ne0<A>, Ne0<B>>>,
+    BoolAnd<BoolAnd<Le0<A>, Le0<B>>, BoolOr<Ne0<A>, Ne0<B>>>
   >
 >;
 
@@ -129,16 +125,16 @@ type MulSignWithNe0<
   A extends Sign,
   B extends Sign,
   ne0 extends boolean,
-> = FromFacts<
-  Or<And<Ge0<A>, Ge0<B>>, And<Le0<A>, Le0<B>>>,
-  Or<And<Ge0<A>, Le0<B>>, And<Le0<A>, Ge0<B>>>,
+> = SignFromFacts<
+  BoolOr<BoolAnd<Ge0<A>, Ge0<B>>, BoolAnd<Le0<A>, Le0<B>>>,
+  BoolOr<BoolAnd<Ge0<A>, Le0<B>>, BoolAnd<Le0<A>, Ge0<B>>>,
   ne0
 >;
 
 type MulSign<A extends Sign, B extends Sign> = MulSignWithNe0<
   A,
   B,
-  And<Ne0<A>, Ne0<B>>
+  BoolAnd<Ne0<A>, Ne0<B>>
 >;
 
 /** Exact division: nonzero dividend over nonzero divisor stays nonzero. */
@@ -158,9 +154,12 @@ type LooserLevel<LA extends Level, LB extends Level> = 'number' extends LA | LB
       ? 'int'
       : 'safeint';
 
+type WidenSafeIntToInt<T> = T extends 'safeint' ? 'int' : T;
+
 /** `+`/`-`/`*`: looser level, widening `safeint -> int` (overflow may occur). */
-type AddMulLevel<LA extends Level, LB extends Level> =
-  LooserLevel<LA, LB> extends 'safeint' ? 'int' : LooserLevel<LA, LB>;
+type AddMulLevel<LA extends Level, LB extends Level> = WidenSafeIntToInt<
+  LooserLevel<LA, LB>
+>;
 
 /** Exact division yields a (possibly fractional) finite number. */
 type DivLevel<LA extends Level, LB extends Level> = 'number' extends LA | LB
@@ -170,8 +169,10 @@ type DivLevel<LA extends Level, LB extends Level> = 'number' extends LA | LB
 /** Floor division yields an integer; the safe range is preserved. */
 type DivIntLevel<LA extends Level, LB extends Level> = 'number' extends LA | LB
   ? 'number'
-  : [LA, LB] extends ['safeint', 'safeint']
-    ? 'safeint'
+  : [LA] extends ['safeint']
+    ? [LB] extends ['safeint']
+      ? 'safeint'
+      : 'int'
     : 'int';
 
 // --- reconstruction (sign, level) -> canonical brand -------------------------
@@ -263,3 +264,107 @@ export type DivIntResult<A, B> = Reconstruct<
   DivIntSign<SignOf<A>, SignOf<B>>,
   DivIntLevel<LevelOf<A>, LevelOf<B>>
 >;
+
+// #region type tests
+{
+  type A = NonPositiveInt;
+
+  type B = NonPositiveInt;
+
+  expectType<MulResult<A, B>, Uint>('=');
+
+  type SignA = SignOf<A>;
+
+  type SignB = SignOf<B>;
+
+  expectType<SignA, 'nonpos'>('=');
+
+  expectType<MulSign<SignA, SignB>, 'nonneg'>('=');
+
+  expectType<BoolAnd<Ne0<SignA>, Ne0<SignB>>, false>('=');
+
+  expectType<MulSignWithNe0<SignA, SignB, false>, 'nonneg'>('=');
+
+  expectType<
+    BoolOr<BoolAnd<Ge0<SignA>, Ge0<SignB>>, BoolAnd<Le0<SignA>, Le0<SignB>>>,
+    true
+  >('=');
+
+  expectType<Ge0<SignA>, false>('=');
+
+  expectType<Ge0<SignB>, false>('=');
+
+  expectType<Le0<SignA>, true>('=');
+
+  expectType<Le0<SignB>, true>('=');
+
+  expectType<BoolAnd<Ge0<SignA>, Ge0<SignB>>, false>('=');
+
+  expectType<BoolAnd<true, true>, true>('=');
+
+  expectType<
+    BoolOr<BoolAnd<Ge0<SignA>, Le0<SignB>>, BoolAnd<Le0<SignA>, Ge0<SignB>>>,
+    false
+  >('=');
+
+  expectType<SignFromFacts<true, false, false>, 'nonneg'>('=');
+
+  expectType<AddMulLevel<LevelOf<A>, LevelOf<B>>, 'int'>('=');
+
+  type LA = LevelOf<A>;
+
+  type LB = LevelOf<B>;
+
+  expectType<LA, 'int'>('=');
+
+  expectType<LooserLevel<LA, LB>, 'int'>('=');
+
+  {
+    type MulResult2<X, Y> = Reconstruct<
+      MulSign<SignOf<X>, SignOf<Y>>,
+      AddMulLevel<LevelOf<X>, LevelOf<Y>>
+    >;
+
+    expectType<MulResult<A, B>, MulResult2<A, B>>('=');
+
+    expectType<
+      MulResult<A, B>,
+      Reconstruct<
+        MulSign<SignOf<A>, SignOf<B>>,
+        AddMulLevel<LevelOf<A>, LevelOf<B>>
+      >
+    >('=');
+
+    expectType<
+      Reconstruct<
+        MulSign<SignOf<A>, SignOf<B>>,
+        AddMulLevel<LevelOf<A>, LevelOf<B>>
+      >,
+      NonNegativeInt
+    >('=');
+
+    expectType<
+      Reconstruct<MulSign<SignA, SignB>, AddMulLevel<LA, LB>>,
+      NonNegativeInt
+    >('=');
+
+    expectType<Reconstruct<'nonneg', 'int'>, NonNegativeInt>('=');
+
+    expectType<MulResult<A, B>, NonNegativeInt>('=');
+
+    // type Reconstruct<S extends Sign, L extends Level> = L extends 'safeint'
+    //   ? ReconstructSafeInt<S>
+    //   : L extends 'int'
+    //     ? ReconstructInt<S>
+    //     : L extends 'finite'
+    //       ? ReconstructFinite<S>
+    //       : ReconstructNumber<S>;
+  }
+
+  // FromFacts<
+  //   BoolOr<BoolAnd<Ge0<A>, Ge0<B>>, BoolAnd<Le0<A>, Le0<B>>>,
+  //   BoolOr<BoolAnd<Ge0<A>, Le0<B>>, BoolAnd<Le0<A>, Ge0<B>>>,
+  //   ne0
+  // >;
+}
+// #endregion

package/src/number/num.test.mts

@@ -1,11 +1,11 @@
-import { type NonZeroNumber } from 'ts-type-forge';
+import { type FixedLengthTuple, type NonZeroNumber } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe, Result } from '../functional/index.mjs';
 import { asNonZeroFiniteNumber } from './branded-types/index.mjs';
 import { Num } from './num.mjs';
 
 const testClamp = (
-  [a, b]: readonly [number, number],
+  [a, b]: FixedLengthTuple<2, number>,
   target: number,
   expected: number,
 ): void => {
@@ -244,8 +244,8 @@ describe('Num test', () => {
     });
 
     test('composes with Result.unwrapOk + nullish fallback', () => {
-      expect(Result.unwrapOk(Num.safeParseFloat('3.14')) ?? Number.NaN).toBe(
-        3.14,
+      expect(Result.unwrapOk(Num.safeParseFloat('1.23')) ?? Number.NaN).toBe(
+        1.23,
       );
 
       expect(Result.unwrapOk(Num.safeParseFloat('')) ?? Number.NaN).toBeNaN();
@@ -360,9 +360,9 @@ describe('Num test', () => {
 
   describe('roundAt', () => {
     test('rounds to specified decimal places', () => {
-      expect(Num.roundAt(3.141_59, 2)).toBe(3.14);
+      expect(Num.roundAt(1.234_56, 2)).toBe(1.23);
 
-      expect(Num.roundAt(3.141_59, 3)).toBe(3.142);
+      expect(Num.roundAt(1.234_56, 3)).toBe(1.235);
 
       expect(Num.roundAt(2.555, 2)).toBe(2.56);
 
@@ -388,21 +388,21 @@ describe('Num test', () => {
     test('creates rounding function with specified precision', () => {
       const round2 = Num.round(2);
 
-      expect(round2(3.141_59)).toBe(3.14);
+      expect(round2(1.234_56)).toBe(1.23);
 
       expect(round2(2.556)).toBe(2.56);
 
       const round1 = Num.round(1);
 
-      expect(round1(3.141_59)).toBe(3.1);
+      expect(round1(1.234_56)).toBe(1.2);
 
       expect(round1(2.56)).toBe(2.6);
 
       const round3 = Num.round(3);
 
-      expect(round3(3.1416)).toBe(3.142);
+      expect(round3(1.2346)).toBe(1.235);
 
-      expect(round3(2.7182)).toBe(2.718);
+      expect(round3(4.5678)).toBe(4.568);
     });
   });
 
@@ -412,7 +412,7 @@ describe('Num test', () => {
 
       expect(Num.mapNaN2Undefined(0)).toBe(0);
 
-      expect(Num.mapNaN2Undefined(-3.14)).toBe(-3.14);
+      expect(Num.mapNaN2Undefined(-1.23)).toBe(-1.23);
 
       expect(Num.mapNaN2Undefined(Number.NaN)).toBeUndefined();
     });

package/src/number/refined-number-utils.mts

@@ -8,6 +8,7 @@ import {
   type NonZeroNumber,
   type PositiveNumber,
   type RelaxedExclude,
+  type StrictPick,
   type TypeEq,
   type UnknownBrand,
   type UnwrapBrandFalseKeys,
@@ -167,7 +168,7 @@ export namespace TsDataForgeInternals {
             fromNumber: (a: number) => N;
           }>
         : unknown) &
-      Pick<
+      StrictPick<
         Readonly<{
           add: (x: N, y: N) => N;
           sub: (x: N, y: N) => N;

package/src/object/object.mts

@@ -7,7 +7,11 @@ import {
   type IsUnion,
   type List,
   type ReadonlyRecord,
+  type RelaxedExclude,
+  type RelaxedOmit,
   type RelaxedPick,
+  type StrictOmit,
+  type StrictPick,
   type TypeEq,
   type UnknownRecord,
 } from 'ts-type-forge';
@@ -125,7 +129,7 @@ export namespace Obj {
   export function pick<
     const R extends UnknownRecord,
     const Keys extends readonly (keyof R)[],
-  >(record: R, keys: Keys): Pick<R, ArrayElement<Keys>>;
+  >(record: R, keys: Keys): StrictPick<R, ArrayElement<Keys>>;
 
   // Curried version
   export function pick<const Keys extends readonly PropertyKey[]>(
@@ -140,7 +144,7 @@ export namespace Obj {
   >(
     ...args: readonly [record: R, keys: Keys] | readonly [keys: Keys]
   ):
-    | Pick<R, ArrayElement<Keys>>
+    | StrictPick<R, ArrayElement<Keys>>
     | ((record: R) => RelaxedPick<R, ArrayElement<Keys>>) {
     switch (args.length) {
       case 2: {
@@ -212,12 +216,14 @@ export namespace Obj {
   export function omit<
     const R extends UnknownRecord,
     const Keys extends readonly (keyof R)[],
-  >(record: R, keys: Keys): Omit<R, ArrayElement<Keys>>;
+  >(record: R, keys: Keys): StrictOmit<R, ArrayElement<Keys>>;
 
   // Curried version
   export function omit<const Keys extends readonly PropertyKey[]>(
     keys: Keys,
-  ): <const R extends UnknownRecord>(record: R) => Omit<R, ArrayElement<Keys>>;
+  ): <const R extends UnknownRecord>(
+    record: R,
+  ) => RelaxedOmit<R, ArrayElement<Keys>>;
 
   export function omit<
     const R extends UnknownRecord,
@@ -226,7 +232,8 @@ export namespace Obj {
     ...args:
       readonly [record: R, keys: Keys] | readonly [keys: readonly PropertyKey[]]
   ):
-    Omit<R, ArrayElement<Keys>> | ((record: R) => Omit<R, ArrayElement<Keys>>) {
+    | StrictOmit<R, ArrayElement<Keys>>
+    | ((record: R) => StrictOmit<R, ArrayElement<Keys>>) {
     switch (args.length) {
       case 2: {
         const [record, keys] = args;
@@ -246,10 +253,11 @@ export namespace Obj {
 
         return <R2 extends UnknownRecord>(record: R2) => {
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          const result = omit(record, keys as readonly (keyof R2)[]) as Omit<
-            R2,
-            ArrayElement<Keys>
-          >;
+          const result = omit(
+            record,
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            keys as readonly (keyof R2)[],
+          ) as RelaxedOmit<R2, ArrayElement<Keys>>;
 
           return result;
         };
@@ -544,7 +552,7 @@ declare namespace TsDataForgeInternals {
     TypeEq<Entries['length'], 0> extends true
       ? R
       : EntriesToObjectImpl<
-          R & Readonly<Record<Entries[0][0], Entries[0][1]>>,
+          R & ReadonlyRecord<Entries[0][0], Entries[0][1]>,
           List.Tail<Entries>
         >;
 
@@ -639,12 +647,12 @@ declare namespace TsDataForgeInternals {
   type MergeTwo<A extends UnknownRecord, B extends UnknownRecord> = {
     // 1. Required properties from B (override A completely)
     // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in keyof B as {} extends Pick<B, K> ? never : K]: B[K];
+    readonly [K in keyof B as {} extends StrictPick<B, K> ? never : K]: B[K];
   } & {
     // 2. Optional properties from B that are NOT in A
     readonly [
       // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      K in keyof B as {} extends Pick<B, K>
+      K in keyof B as {} extends StrictPick<B, K>
         ? K extends keyof A
           ? never
           : K
@@ -654,7 +662,7 @@ declare namespace TsDataForgeInternals {
     // 3. Optional properties from B that ARE in A (create union)
     readonly [
       // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      K in keyof B as {} extends Pick<B, K>
+      K in keyof B as {} extends StrictPick<B, K>
         ? K extends keyof A
           ? K
           : never
@@ -664,22 +672,26 @@ declare namespace TsDataForgeInternals {
     // 4. Required properties only in A (not overridden by B)
     readonly [
       // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      K in Exclude<keyof A, keyof B> as {} extends Pick<A, K> ? never : K
+      K in RelaxedExclude<keyof A, keyof B> as {} extends StrictPick<A, K>
+        ? never
+        : K
     ]: A[K];
   } & {
     // 5. Optional properties only in A (not overridden by B)
     readonly [
       // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      K in Exclude<keyof A, keyof B> as {} extends Pick<A, K> ? K : never
+      K in RelaxedExclude<keyof A, keyof B> as {} extends StrictPick<A, K>
+        ? K
+        : never
     ]?: A[K];
   } extends infer O
     ? Readonly<
         {
           // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-          [K in keyof O as {} extends Pick<O, K> ? never : K]: O[K];
+          [K in keyof O as {} extends StrictPick<O, K> ? never : K]: O[K];
         } & {
           // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-          [K in keyof O as {} extends Pick<O, K> ? K : never]?: O[K];
+          [K in keyof O as {} extends StrictPick<O, K> ? K : never]?: O[K];
         }
       >
     : never;

package/src/object/object.test.mts

@@ -1,6 +1,7 @@
 import {
   type DeepReadonly,
   type FixedLengthTuple,
+  type ReadonlyRecord,
   type UnknownRecord,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
@@ -180,7 +181,7 @@ describe('fromEntries', () => {
     ] as const;
 
     const result = Obj.fromEntries(dynamicEntries) satisfies Partial<
-      Readonly<Record<'name' | 'email', string>>
+      ReadonlyRecord<'name' | 'email', string>
     >;
 
     assert.deepStrictEqual(result, { name: 'Alice' });

package/src/others/fast-deep-equal.mts

@@ -39,9 +39,11 @@ export const fastDeepEqual = <T,>(a: T, b: T): boolean => {
       return (
         isMap(b) &&
         a.size === b.size &&
-        Array.from(a.entries()).every(
-          ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),
-        )
+        a
+          .entries()
+          .every(
+            ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),
+          )
       );
     }
 
@@ -49,7 +51,7 @@ export const fastDeepEqual = <T,>(a: T, b: T): boolean => {
       return (
         isSet(b) &&
         a.size === b.size &&
-        Array.from(a.entries()).every(([value]) => b.has(value))
+        a.entries().every(([value]) => b.has(value))
       );
     }