ts-data-forge 5.0.1 → 5.1.0

package/src/collections/iset.test.mts

@@ -15,6 +15,7 @@ describe('ISet.create', () => {
     const set = ISet.create<string>([]);
 
     expect(set.size).toBe(0);
+
     expect(set.isEmpty).toBe(true);
   });
 
@@ -22,28 +23,39 @@ describe('ISet.create', () => {
     const set = ISet.create([1, 2, 3, 2, 1]);
 
     expect(set.size).toBe(3);
+
     expect(set.has(1)).toBe(true);
+
     expect(set.has(2)).toBe(true);
+
     expect(set.has(3)).toBe(true);
   });
 
   test('should create set from JavaScript Set', () => {
     const jsSet = new Set(['a', 'b', 'c']);
+
     const set = ISet.create(jsSet);
 
     expect(set.size).toBe(3);
+
     expect(set.has('a')).toBe(true);
+
     expect(set.has('b')).toBe(true);
+
     expect(set.has('c')).toBe(true);
   });
 
   test('should create set from another ISet', () => {
     const original = ISet.create([1, 2, 3]);
+
     const copy = ISet.create(original);
 
     expect(copy.size).toBe(3);
+
     expect(copy.has(1)).toBe(true);
+
     expect(copy.has(2)).toBe(true);
+
     expect(copy.has(3)).toBe(true);
   });
 });
@@ -109,6 +121,7 @@ describe('ISet.has', () => {
     const set = ISet.create([true, false]);
 
     expect(set.has(true)).toBe(true);
+
     expect(set.has(false)).toBe(true);
   });
 
@@ -116,6 +129,7 @@ describe('ISet.has', () => {
     const set = ISet.create([null, undefined]);
 
     expect(set.has(null)).toBe(true);
+
     expect(set.has(undefined)).toBe(true);
   });
 });
@@ -166,9 +180,11 @@ describe('ISet.every', () => {
 describe('every method as type guard', () => {
   test('should narrow type when used as type guard', () => {
     const set = ISet.create<string | number>(['hello', 'world']);
+
     if (set.every((value): value is string => typeof value === 'string')) {
       // Type should be narrowed to ISet<string>
       const values = set.toArray();
+
       for (const value of values) {
         expect(isString(value)).toBe(true);
       }
@@ -230,6 +246,7 @@ describe('ISet.some', () => {
     const set = ISet.create(['hello', 'world', 'test']);
 
     expect(set.some((str) => str.includes('o'))).toBe(true);
+
     expect(set.some((str) => str.includes('z'))).toBe(false);
   });
 });
@@ -239,9 +256,11 @@ describe('ISet.add', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
 
     expectType<typeof s0.add, (value: number) => ISet<number>>('<=');
+
     const s1 = ISet.create<number>([1, 2, 3, 4]);
 
     assert.deepStrictEqual(s0.add(4), s1);
+
     assert.deepStrictEqual(s0, ISet.create<number>([1, 2, 3]));
   });
 
@@ -249,6 +268,7 @@ describe('ISet.add', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
 
     assert.deepStrictEqual(s0.add(2), ISet.create([1, 2, 3]));
+
     assert.deepStrictEqual(s0, ISet.create([1, 2, 3]));
   });
 
@@ -256,21 +276,27 @@ describe('ISet.add', () => {
     const s0 = ISet.create<number>([]);
 
     assert.deepStrictEqual(s0.add(1), ISet.create([1]));
+
     assert.deepStrictEqual(s0, ISet.create<number>([]));
   });
 
   test('should add new elements and maintain immutability', () => {
     const original = ISet.create<number>([1, 2, 3]);
+
     const modified = original.add(4);
 
     expect(original.size).toBe(3);
+
     expect(modified.size).toBe(4);
+
     expect(original.has(4)).toBe(false);
+
     expect(modified.has(4)).toBe(true);
   });
 
   test('should return same instance when adding existing element', () => {
     const set = ISet.create([1, 2, 3]);
+
     const result = set.add(2);
 
     expect(result).toBe(set);
@@ -278,12 +304,17 @@ describe('ISet.add', () => {
 
   test('should handle special values', () => {
     const set = ISet.create<number | null | undefined>([]);
+
     const withNull = set.add(null);
+
     const withUndefined = withNull.add(undefined);
+
     const withNaN = withUndefined.add(Number.NaN);
 
     expect(withNaN.has(null)).toBe(true);
+
     expect(withNaN.has(undefined)).toBe(true);
+
     expect(withNaN.has(Number.NaN)).toBe(true);
   });
 });
@@ -295,6 +326,7 @@ describe('ISet.delete', () => {
     expectType<typeof s0.delete, (value: number) => ISet<number>>('<=');
 
     assert.deepStrictEqual(s0.delete(4), ISet.create<number>([1, 2, 3]));
+
     assert.deepStrictEqual(s0, ISet.create<number>([1, 2, 3]));
   });
 
@@ -302,6 +334,7 @@ describe('ISet.delete', () => {
     const s0 = ISet.create([1, 2, 3]);
 
     assert.deepStrictEqual(s0.delete(2), ISet.create<1 | 2 | 3>([1, 3]));
+
     assert.deepStrictEqual(s0, ISet.create([1, 2, 3]));
   });
 
@@ -309,21 +342,27 @@ describe('ISet.delete', () => {
     const s0 = ISet.create<number>([]);
 
     assert.deepStrictEqual(s0.delete(1), ISet.create<number>([]));
+
     assert.deepStrictEqual(s0, ISet.create<number>([]));
   });
 
   test('should delete existing elements and maintain immutability', () => {
     const original = ISet.create([1, 2, 3, 4]);
+
     const modified = original.delete(2);
 
     expect(original.size).toBe(4);
+
     expect(modified.size).toBe(3);
+
     expect(original.has(2)).toBe(true);
+
     expect(modified.has(2)).toBe(false);
   });
 
   test('should return same instance when deleting non-existent element', () => {
     const set = ISet.create<number>([1, 2, 3]);
+
     const result = set.delete(4);
 
     expect(result).toBe(set);
@@ -356,6 +395,7 @@ describe('ISet.map', () => {
 
   test('should transform all elements', () => {
     const set = ISet.create([1, 2, 3]);
+
     const doubled = set.map((x) => x * 2);
 
     assert.deepStrictEqual(
@@ -366,10 +406,13 @@ describe('ISet.map', () => {
 
   test('should handle type transformations', () => {
     const set = ISet.create([1, 2, 3]);
+
     const strings = set.map((x) => x.toString());
 
     expect(strings.has('1')).toBe(true);
+
     expect(strings.has('2')).toBe(true);
+
     expect(strings.has('3')).toBe(true);
   });
 });
@@ -402,30 +445,39 @@ describe('ISet.filter', () => {
 
   test('should filter elements based on predicate', () => {
     const set = ISet.create([1, 2, 3, 4, 5, 6]);
+
     const evens = set.filter((x) => x % 2 === 0);
 
     expect(evens.size).toBe(3);
+
     expect(evens.has(2)).toBe(true);
+
     expect(evens.has(4)).toBe(true);
+
     expect(evens.has(6)).toBe(true);
   });
 
   test('should work as type guard', () => {
     const set = ISet.create<string | number>(['hello', 42, 'world', 123]);
+
     const strings = set.filter(
       (value): value is string => typeof value === 'string',
     );
 
     expect(strings.size).toBe(2);
+
     expect(strings.has('hello')).toBe(true);
+
     expect(strings.has('world')).toBe(true);
   });
 
   test('should return empty set when no elements match', () => {
     const set = ISet.create([1, 3, 5]);
+
     const evens = set.filter((x) => x % 2 === 0);
 
     expect(evens.size).toBe(0);
+
     expect(evens.isEmpty).toBe(true);
   });
 });
@@ -433,24 +485,31 @@ describe('ISet.filter', () => {
 describe('ISet.filterNot', () => {
   test('should filter out elements that satisfy predicate', () => {
     const set = ISet.create([1, 2, 3, 4, 5, 6]);
+
     const odds = set.filterNot((x) => x % 2 === 0);
 
     expect(odds.size).toBe(3);
+
     expect(odds.has(1)).toBe(true);
+
     expect(odds.has(3)).toBe(true);
+
     expect(odds.has(5)).toBe(true);
   });
 
   test('should return same set when no elements satisfy predicate', () => {
     const set = ISet.create([1, 3, 5]);
+
     const nonEvens = set.filterNot((x) => x % 2 === 0);
 
     expect(nonEvens.size).toBe(3);
+
     expect(ISet.equal(set, nonEvens)).toBe(true);
   });
 
   test('should return empty set when all elements satisfy predicate', () => {
     const set = ISet.create([2, 4, 6]);
+
     const nonEvens = set.filterNot((x) => x % 2 === 0);
 
     expect(nonEvens.isEmpty).toBe(true);
@@ -460,6 +519,7 @@ describe('ISet.filterNot', () => {
 describe('ISet.isSubsetOf', () => {
   test('case 1', () => {
     const s0 = ISet.create<number>([1, 2]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     expectType<typeof s0.isSubsetOf, (other: ISet<number>) => boolean>('<=');
@@ -469,6 +529,7 @@ describe('ISet.isSubsetOf', () => {
 
   test('case 2', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([1, 2]);
 
     expect(s0.isSubsetOf(s1)).toBe(false);
@@ -476,6 +537,7 @@ describe('ISet.isSubsetOf', () => {
 
   test('case 3', () => {
     const s0 = ISet.create<number>([]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     expect(s0.isSubsetOf(s1)).toBe(true);
@@ -483,6 +545,7 @@ describe('ISet.isSubsetOf', () => {
 
   test('should return true for subset relationship', () => {
     const subset = ISet.create<number>([1, 2]);
+
     const superset = ISet.create<number>([1, 2, 3, 4]);
 
     expect(subset.isSubsetOf(superset)).toBe(true);
@@ -490,6 +553,7 @@ describe('ISet.isSubsetOf', () => {
 
   test('should return true for equal sets', () => {
     const set1 = ISet.create<number>([1, 2, 3]);
+
     const set2 = ISet.create<number>([1, 2, 3]);
 
     expect(set1.isSubsetOf(set2)).toBe(true);
@@ -497,6 +561,7 @@ describe('ISet.isSubsetOf', () => {
 
   test('should return false for non-subset', () => {
     const set1 = ISet.create<number>([1, 2, 5]);
+
     const set2 = ISet.create<number>([1, 2, 3, 4]);
 
     expect(set1.isSubsetOf(set2)).toBe(false);
@@ -506,6 +571,7 @@ describe('ISet.isSubsetOf', () => {
 describe('ISet.isSupersetOf', () => {
   test('case 1', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([1, 2]);
 
     expectType<typeof s0.isSupersetOf, (other: ISet<number>) => boolean>('<=');
@@ -515,6 +581,7 @@ describe('ISet.isSupersetOf', () => {
 
   test('case 2', () => {
     const s0 = ISet.create<number>([1, 2]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     expect(s0.isSupersetOf(s1)).toBe(false);
@@ -522,6 +589,7 @@ describe('ISet.isSupersetOf', () => {
 
   test('case 3', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([]);
 
     expect(s0.isSupersetOf(s1)).toBe(true);
@@ -529,6 +597,7 @@ describe('ISet.isSupersetOf', () => {
 
   test('should return true for superset relationship', () => {
     const superset = ISet.create<number>([1, 2, 3, 4]);
+
     const subset = ISet.create<number>([1, 2]);
 
     expect(superset.isSupersetOf(subset)).toBe(true);
@@ -536,6 +605,7 @@ describe('ISet.isSupersetOf', () => {
 
   test('should return true for equal sets', () => {
     const set1 = ISet.create<number>([1, 2, 3]);
+
     const set2 = ISet.create<number>([1, 2, 3]);
 
     expect(set1.isSupersetOf(set2)).toBe(true);
@@ -543,6 +613,7 @@ describe('ISet.isSupersetOf', () => {
 
   test('should return false for non-superset', () => {
     const set1 = ISet.create<number>([1, 2, 3]);
+
     const set2 = ISet.create<number>([1, 2, 3, 4]);
 
     expect(set1.isSupersetOf(set2)).toBe(false);
@@ -552,6 +623,7 @@ describe('ISet.isSupersetOf', () => {
 describe('ISet.subtract', () => {
   test('case 1', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([2, 4]);
 
     expectType<typeof s0.subtract, (other: ISet<number>) => ISet<number>>('<=');
@@ -561,6 +633,7 @@ describe('ISet.subtract', () => {
 
   test('case 2', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([]);
 
     assert.deepStrictEqual(s0.subtract(s1), ISet.create<number>([1, 2, 3]));
@@ -568,6 +641,7 @@ describe('ISet.subtract', () => {
 
   test('case 3', () => {
     const s0 = ISet.create<number>([]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     assert.deepStrictEqual(s0.subtract(s1), ISet.create<number>([]));
@@ -575,17 +649,23 @@ describe('ISet.subtract', () => {
 
   test('should return elements in first set but not in second', () => {
     const set1 = ISet.create<number>([1, 2, 3, 4, 5]);
+
     const set2 = ISet.create<number>([3, 4, 5, 6, 7]);
+
     const result = set1.subtract(set2);
 
     expect(result.size).toBe(2);
+
     expect(result.has(1)).toBe(true);
+
     expect(result.has(2)).toBe(true);
   });
 
   test('should return empty set when all elements are removed', () => {
     const set1 = ISet.create<number>([1, 2, 3]);
+
     const set2 = ISet.create<number>([1, 2, 3, 4, 5]);
+
     const result = set1.subtract(set2);
 
     expect(result.isEmpty).toBe(true);
@@ -595,6 +675,7 @@ describe('ISet.subtract', () => {
 describe('ISet.intersection', () => {
   test('case 1', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([2, 3, 4]);
 
     expectType<
@@ -610,6 +691,7 @@ describe('ISet.intersection', () => {
 
   test('case 2', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([]);
 
     assert.deepStrictEqual(ISet.intersection(s0, s1), ISet.create<number>([]));
@@ -617,6 +699,7 @@ describe('ISet.intersection', () => {
 
   test('case 3', () => {
     const s0 = ISet.create<number>([]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     assert.deepStrictEqual(ISet.intersection(s0, s1), ISet.create<number>([]));
@@ -624,17 +707,23 @@ describe('ISet.intersection', () => {
 
   test('should return common elements', () => {
     const set1 = ISet.create<number>([1, 2, 3, 4]);
+
     const set2 = ISet.create<number>([3, 4, 5, 6]);
+
     const result = ISet.intersection(set1, set2);
 
     expect(result.size).toBe(2);
+
     expect(result.has(3)).toBe(true);
+
     expect(result.has(4)).toBe(true);
   });
 
   test('should return empty set when no common elements', () => {
     const set1 = ISet.create<number>([1, 2]);
+
     const set2 = ISet.create<number>([3, 4]);
+
     const result = ISet.intersection(set1, set2);
 
     expect(result.isEmpty).toBe(true);
@@ -644,6 +733,7 @@ describe('ISet.intersection', () => {
 describe('ISet.intersect', () => {
   test('case 1', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([2, 3, 4]);
 
     expectType<typeof s0.intersect, (other: ISet<number>) => ISet<number>>(
@@ -655,6 +745,7 @@ describe('ISet.intersect', () => {
 
   test('case 2', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([]);
 
     assert.deepStrictEqual(s0.intersect(s1), ISet.create<number>([]));
@@ -662,6 +753,7 @@ describe('ISet.intersect', () => {
 
   test('case 3', () => {
     const s0 = ISet.create<number>([]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     assert.deepStrictEqual(s0.intersect(s1), ISet.create<number>([]));
@@ -669,11 +761,15 @@ describe('ISet.intersect', () => {
 
   test('should return common elements using instance method', () => {
     const set1 = ISet.create<number>([1, 2, 3, 4]);
+
     const set2 = ISet.create<number>([3, 4, 5, 6]);
+
     const result = set1.intersect(set2);
 
     expect(result.size).toBe(2);
+
     expect(result.has(3)).toBe(true);
+
     expect(result.has(4)).toBe(true);
   });
 });
@@ -681,6 +777,7 @@ describe('ISet.intersect', () => {
 describe('ISet.union', () => {
   test('case 1', () => {
     const s0 = ISet.create<number>([1, 2, 3]);
+
     const s1 = ISet.create<number>([3, 4, 5]);
 
     expectType<
@@ -696,6 +793,7 @@ describe('ISet.union', () => {
 
   test('case 2', () => {
     const s0 = ISet.create([1, 2, 3]);
+
     const s1 = ISet.create<number>([]);
 
     assert.deepStrictEqual(ISet.union(s0, s1), ISet.create<number>([1, 2, 3]));
@@ -703,6 +801,7 @@ describe('ISet.union', () => {
 
   test('case 3', () => {
     const s0 = ISet.create<number>([]);
+
     const s1 = ISet.create<number>([1, 2, 3]);
 
     assert.deepStrictEqual(ISet.union(s0, s1), ISet.create<number>([1, 2, 3]));
@@ -710,20 +809,28 @@ describe('ISet.union', () => {
 
   test('should return combined elements using static method', () => {
     const set1 = ISet.create<number>([1, 2, 3]);
+
     const set2 = ISet.create<number>([3, 4, 5]);
+
     const result = ISet.union(set1, set2);
 
     expect(result.size).toBe(5);
+
     expect(result.has(1)).toBe(true);
+
     expect(result.has(2)).toBe(true);
+
     expect(result.has(3)).toBe(true);
+
     expect(result.has(4)).toBe(true);
+
     expect(result.has(5)).toBe(true);
   });
 
   describe('instance method', () => {
     test('case 1', () => {
       const s0 = ISet.create([1, 2, 3] as const);
+
       const s1 = ISet.create([3, 4, 5] as const);
 
       expectType<typeof s0.union, (other: ISet<number>) => ISet<number>>('<=');
@@ -736,6 +843,7 @@ describe('ISet.union', () => {
 
     test('case 2', () => {
       const s0 = ISet.create<number>([1, 2, 3]);
+
       const s1 = ISet.create<number>([]);
 
       assert.deepStrictEqual(s0.union(s1), ISet.create<number>([1, 2, 3]));
@@ -743,6 +851,7 @@ describe('ISet.union', () => {
 
     test('case 3', () => {
       const s0 = ISet.create<number>([]);
+
       const s1 = ISet.create<number>([1, 2, 3]);
 
       assert.deepStrictEqual(s0.union(s1), ISet.create<number>([1, 2, 3]));
@@ -750,14 +859,21 @@ describe('ISet.union', () => {
 
     test('should return combined elements using instance method', () => {
       const set1 = ISet.create<number>([1, 2, 3]);
+
       const set2 = ISet.create<number>([3, 4, 5]);
+
       const result = set1.union(set2);
 
       expect(result.size).toBe(5);
+
       expect(result.has(1)).toBe(true);
+
       expect(result.has(2)).toBe(true);
+
       expect(result.has(3)).toBe(true);
+
       expect(result.has(4)).toBe(true);
+
       expect(result.has(5)).toBe(true);
     });
   });
@@ -773,6 +889,7 @@ describe('ISet.forEach', () => {
     >('<=');
 
     const mut_result: (1 | 2 | 3)[] = [];
+
     for (const x of s0) {
       mut_result.push(x);
     }
@@ -785,6 +902,7 @@ describe('ISet.forEach', () => {
 
   test('should execute callback for each element', () => {
     const set = ISet.create([1, 2, 3]);
+
     const mut_collected: number[] = [];
 
     for (const value of set) {
@@ -799,6 +917,7 @@ describe('ISet.forEach', () => {
 
   test('should not call callback for empty set', () => {
     const set = ISet.create<number>([]);
+
     let mut_callCount = 0;
 
     // eslint-disable-next-line unicorn/no-array-for-each
@@ -817,6 +936,7 @@ describe('ISet.keys', () => {
     expectType<typeof s0.keys, () => IterableIterator<1 | 2 | 3>>('<=');
 
     const mut_result: (1 | 2 | 3)[] = [];
+
     for (const x of s0.keys()) {
       mut_result.push(x);
     }
@@ -835,6 +955,7 @@ describe('ISet.values', () => {
     expectType<typeof s0.values, () => IterableIterator<1 | 2 | 3>>('<=');
 
     const mut_result: (1 | 2 | 3)[] = [];
+
     for (const x of s0.values()) {
       mut_result.push(x);
     }
@@ -856,6 +977,7 @@ describe('ISet.entries', () => {
     >('<=');
 
     const mut_result: [1 | 2 | 3, 1 | 2 | 3][] = [];
+
     for (const x of s0.entries()) {
       mut_result.push([x[0], x[1]]);
     }
@@ -891,6 +1013,7 @@ describe('ISet.toArray', () => {
 
   test('should convert set to array', () => {
     const set = ISet.create([1, 3, 2]);
+
     const array = set.toArray();
 
     expect(array).toHaveLength(3);
@@ -905,16 +1028,21 @@ describe('ISet.toArray', () => {
 describe('ISet.toRawSet', () => {
   test('should return underlying ReadonlySet', () => {
     const set = ISet.create([1, 2, 3]);
+
     const rawSet = set.toRawSet();
 
     expect(rawSet.size).toBe(3);
+
     expect(rawSet.has(1)).toBe(true);
+
     expect(rawSet.has(2)).toBe(true);
+
     expect(rawSet.has(3)).toBe(true);
   });
 
   test('should return empty ReadonlySet for empty ISet', () => {
     const set = ISet.create<number>([]);
+
     const rawSet = set.toRawSet();
 
     expect(rawSet.size).toBe(0);
@@ -924,6 +1052,7 @@ describe('ISet.toRawSet', () => {
 describe('ISet.equal', () => {
   test('should return true for equal sets', () => {
     const set1 = ISet.create([1, 2, 3]);
+
     const set2 = ISet.create([3, 2, 1]); // Different order
 
     expect(ISet.equal(set1, set2)).toBe(true);
@@ -931,6 +1060,7 @@ describe('ISet.equal', () => {
 
   test('should return false for sets with different sizes', () => {
     const set1 = ISet.create<'a' | 'b' | 'c' | 'd'>(['a', 'b']);
+
     const set2 = ISet.create<'a' | 'b' | 'c' | 'd'>(['a', 'b', 'c']);
 
     expect(ISet.equal(set1, set2)).toBe(false);
@@ -938,6 +1068,7 @@ describe('ISet.equal', () => {
 
   test('should return false for sets with different elements', () => {
     const set1 = ISet.create<'a' | 'b' | 'c' | 'd'>(['a', 'b', 'c']);
+
     const set2 = ISet.create<'a' | 'b' | 'c' | 'd'>(['a', 'b', 'd']);
 
     expect(ISet.equal(set1, set2)).toBe(false);
@@ -945,6 +1076,7 @@ describe('ISet.equal', () => {
 
   test('should return true for empty sets', () => {
     const set1 = ISet.create<string>([]);
+
     const set2 = ISet.create<string>([]);
 
     expect(ISet.equal(set1, set2)).toBe(true);
@@ -952,6 +1084,7 @@ describe('ISet.equal', () => {
 
   test('should handle sets with special values', () => {
     const set1 = ISet.create([Number.NaN, null, undefined]);
+
     const set2 = ISet.create([undefined, Number.NaN, null]);
 
     expect(ISet.equal(set1, set2)).toBe(true);
@@ -961,54 +1094,67 @@ describe('ISet.equal', () => {
 describe('ISet.diff', () => {
   test('should compute differences between sets', () => {
     const oldSet = ISet.create<'a' | 'b' | 'c' | 'd'>(['a', 'b', 'c']);
+
     const newSet = ISet.create<'a' | 'b' | 'c' | 'd'>(['b', 'c', 'd']);
 
     const diff = ISet.diff(oldSet, newSet);
 
     expect(diff.deleted.size).toBe(1);
+
     expect(diff.deleted.has('a')).toBe(true);
 
     expect(diff.added.size).toBe(1);
+
     expect(diff.added.has('d')).toBe(true);
   });
 
   test('should handle no changes', () => {
     const set1 = ISet.create(['a', 'b', 'c']);
+
     const set2 = ISet.create(['a', 'b', 'c']);
 
     const diff = ISet.diff(set1, set2);
 
     expect(diff.deleted.isEmpty).toBe(true);
+
     expect(diff.added.isEmpty).toBe(true);
   });
 
   test('should handle complete replacement', () => {
     const oldSet = ISet.create<'a' | 'b' | 'c' | 'd'>(['a', 'b']);
+
     const newSet = ISet.create<'a' | 'b' | 'c' | 'd'>(['c', 'd']);
 
     const diff = ISet.diff(oldSet, newSet);
 
     expect(diff.deleted.size).toBe(2);
+
     expect(diff.deleted.has('a')).toBe(true);
+
     expect(diff.deleted.has('b')).toBe(true);
 
     expect(diff.added.size).toBe(2);
+
     expect(diff.added.has('c')).toBe(true);
+
     expect(diff.added.has('d')).toBe(true);
   });
 
   test('should handle empty sets', () => {
     const emptySet = ISet.create<string>([]);
+
     const nonEmptySet = ISet.create<string>(['a', 'b']);
 
     const diff1 = ISet.diff(emptySet, nonEmptySet);
 
     expect(diff1.deleted.isEmpty).toBe(true);
+
     expect(diff1.added.size).toBe(2);
 
     const diff2 = ISet.diff(nonEmptySet, emptySet);
 
     expect(diff2.deleted.size).toBe(2);
+
     expect(diff2.added.isEmpty).toBe(true);
   });
 });
@@ -1024,22 +1170,29 @@ describe('ISet.withMutations', () => {
     ]);
 
     expect(updated.size).toBe(3);
+
     expect(updated.has('b')).toBe(true);
+
     expect(updated.has('c')).toBe(true);
+
     expect(updated.has('d')).toBe(true);
+
     expect(updated.has('a')).toBe(false);
   });
 
   test('should handle empty mutations array', () => {
     const set = ISet.create(['a', 'b', 'c']);
+
     const updated = set.withMutations([]);
 
     expect(updated.size).toBe(set.size);
+
     expect(ISet.equal(set, updated)).toBe(true);
   });
 
   test('should handle duplicate operations', () => {
     const set = ISet.create<'a' | 'b'>(['a']);
+
     const updated = set.withMutations([
       { type: 'add', key: 'a' }, // Already exists
       { type: 'delete', key: 'b' }, // Doesn't exist
@@ -1047,7 +1200,9 @@ describe('ISet.withMutations', () => {
     ]);
 
     expect(updated.size).toBe(2);
+
     expect(updated.has('a')).toBe(true);
+
     expect(updated.has('b')).toBe(true);
   });
 });
@@ -1055,6 +1210,7 @@ describe('ISet.withMutations', () => {
 describe('iterable functionality', () => {
   test('should work with for-of loops', () => {
     const set = ISet.create([1, 2, 3]);
+
     const mut_collected: number[] = [];
 
     for (const value of set) {
@@ -1069,6 +1225,7 @@ describe('iterable functionality', () => {
 
   test('should work with spread operator', () => {
     const set = ISet.create([1, 2, 3]);
+
     const array = Array.from(set);
 
     assert.deepStrictEqual(
@@ -1079,6 +1236,7 @@ describe('iterable functionality', () => {
 
   test('should work with Array.from', () => {
     const set = ISet.create([1, 2, 3]);
+
     const array = Array.from(set);
 
     assert.deepStrictEqual(
@@ -1089,6 +1247,7 @@ describe('iterable functionality', () => {
 
   test('should work with destructuring', () => {
     const set = ISet.create([1, 2]);
+
     const values = Array.from(set);
 
     assert.deepStrictEqual(
@@ -1103,6 +1262,7 @@ describe('edge cases', () => {
     const set = ISet.create([Number.NaN, 1, 2]);
 
     expect(set.has(Number.NaN)).toBe(true);
+
     expect(set.size).toBe(3);
   });
 
@@ -1110,7 +1270,9 @@ describe('edge cases', () => {
     const set = ISet.create([true, false, true]);
 
     expect(set.size).toBe(2);
+
     expect(set.has(true)).toBe(true);
+
     expect(set.has(false)).toBe(true);
   });
 
@@ -1118,18 +1280,25 @@ describe('edge cases', () => {
     const set = ISet.create([null, undefined, null]);
 
     expect(set.size).toBe(2);
+
     expect(set.has(null)).toBe(true);
+
     expect(set.has(undefined)).toBe(true);
   });
 
   test('should handle symbols by reference', () => {
     const sym1 = Symbol('test');
+
     const sym2 = Symbol('test'); // Different symbol, same description
+
     const set = ISet.create([sym1, sym2]);
 
     expect(set.size).toBe(2);
+
     expect(set.has(sym1)).toBe(true);
+
     expect(set.has(sym2)).toBe(true);
+
     expect(set.has(Symbol('test'))).toBe(false); // Different symbol
   });
 });
@@ -1137,57 +1306,81 @@ describe('edge cases', () => {
 describe('immutability', () => {
   test('should not modify original set when adding', () => {
     const original = ISet.create<number>([1, 2, 3]);
+
     const modified = original.add(4);
 
     expect(original.size).toBe(3);
+
     expect(modified.size).toBe(4);
+
     expect(original.has(4)).toBe(false);
+
     expect(modified.has(4)).toBe(true);
   });
 
   test('should not modify original set when deleting', () => {
     const original = ISet.create([1, 2, 3]);
+
     const modified = original.delete(2);
 
     expect(original.size).toBe(3);
+
     expect(modified.size).toBe(2);
+
     expect(original.has(2)).toBe(true);
+
     expect(modified.has(2)).toBe(false);
   });
 
   test('should not modify original set when filtering', () => {
     const original = ISet.create([1, 2, 3, 4, 5]);
+
     const filtered = original.filter((x) => x % 2 === 0);
 
     expect(original.size).toBe(5);
+
     expect(filtered.size).toBe(2);
+
     expect(original.has(1)).toBe(true);
+
     expect(filtered.has(1)).toBe(false);
   });
 
   test('should not modify original set when mapping', () => {
     const original = ISet.create([1, 2, 3]);
+
     const mapped = original.map((x) => x * 2);
 
     expect(original.size).toBe(3);
+
     expect(mapped.size).toBe(3);
+
     expect(original.has(1)).toBe(true);
+
     expect(mapped.has(1)).toBe(false);
+
     expect(mapped.has(2)).toBe(true);
   });
 
   test('should not modify original sets during set operations', () => {
     const set1 = ISet.create<number>([1, 2, 3]);
+
     const set2 = ISet.create<number>([3, 4, 5]);
 
     const union = set1.union(set2);
+
     const intersection = set1.intersect(set2);
+
     const difference = set1.subtract(set2);
 
     expect(set1.size).toBe(3);
+
     expect(set2.size).toBe(3);
+
     expect(union.size).toBe(5);
+
     expect(intersection.size).toBe(1);
+
     expect(difference.size).toBe(2);
   });
 });