ts-data-forge 5.1.0 → 5.1.1

package/src/json/json.mts

@@ -28,13 +28,13 @@ export namespace Json {
    *
    * const failed = Json.parse(invalidJson);
    *
-   * assert.ok(Result.isOk(parsed));
+   * assert.isTrue(Result.isOk(parsed));
    *
    * if (Result.isOk(parsed)) {
    *   assert.deepStrictEqual(parsed.value, { name: 'Alice', age: 30 });
    * }
    *
-   * assert.ok(Result.isErr(failed));
+   * assert.isTrue(Result.isErr(failed));
    *
    * // With reviver
    * const jsonWithDate = '{"created": "2024-01-01T00:00:00.000Z"}';
@@ -47,7 +47,7 @@ export namespace Json {
    *   return value;
    * });
    *
-   * assert.ok(Result.isOk(withReviver));
+   * assert.isTrue(Result.isOk(withReviver));
    * ```
    *
    * @param text - A valid JSON string to parse. Can contain any valid JSON data
@@ -98,16 +98,16 @@ export namespace Json {
    * // Basic stringify
    * const basic = Json.stringify(data);
    *
-   * assert.ok(Result.isOk(basic));
+   * assert.isTrue(Result.isOk(basic));
    *
    * if (Result.isOk(basic)) {
-   *   assert(basic.value === '{"name":"Bob","age":25,"active":true}');
+   *   assert.isTrue(basic.value === '{"name":"Bob","age":25,"active":true}');
    * }
    *
    * // With formatting
    * const formatted = Json.stringify(data, undefined, 2);
    *
-   * assert.ok(Result.isOk(formatted));
+   * assert.isTrue(Result.isOk(formatted));
    *
    * // With replacer
    * const filtered = Json.stringify(data, (key, value) => {
@@ -116,12 +116,12 @@ export namespace Json {
    *   return value;
    * });
    *
-   * assert.ok(Result.isOk(filtered));
+   * assert.isTrue(Result.isOk(filtered));
    *
    * if (Result.isOk(filtered)) {
-   *   assert(isString(filtered.value));
+   *   assert.isTrue(isString(filtered.value));
    *
-   *   assert.ok(!filtered.value.includes('age'));
+   *   assert.isFalse(filtered.value.includes('age'));
    * }
    * ```
    *
@@ -182,10 +182,10 @@ export namespace Json {
    * // Select only safe properties to serialize
    * const safeJson = Json.stringifySelected(user, ['id', 'name', 'role']);
    *
-   * assert.ok(Result.isOk(safeJson));
+   * assert.isTrue(Result.isOk(safeJson));
    *
    * if (Result.isOk(safeJson)) {
-   *   assert(isString(safeJson.value));
+   *   assert.isTrue(isString(safeJson.value));
    *
    *   const parsed: unknown = JSON.parse(safeJson.value);
    *
@@ -195,15 +195,15 @@ export namespace Json {
    *     role: 'admin',
    *   });
    *
-   *   assert.ok(!safeJson.value.includes('password'));
+   *   assert.isFalse(safeJson.value.includes('password'));
    *
-   *   assert.ok(!safeJson.value.includes('email'));
+   *   assert.isFalse(safeJson.value.includes('email'));
    * }
    *
    * // With formatting
    * const formatted = Json.stringifySelected(user, ['id', 'name'], 2);
    *
-   * assert.ok(Result.isOk(formatted));
+   * assert.isTrue(Result.isOk(formatted));
    * ```
    *
    * @param value - The JavaScript value to serialize. While any value is
@@ -267,34 +267,34 @@ export namespace Json {
    * // Keys will be sorted alphabetically at all levels
    * const sorted = Json.stringifySortedKey(unorderedData);
    *
-   * assert.ok(Result.isOk(sorted));
+   * assert.isTrue(Result.isOk(sorted));
    *
    * if (Result.isOk(sorted)) {
    *   // Keys should appear in alphabetical order
    *   const expected =
    *     '{"apple":2,"mango":3,"nested":{"alpha":"a","beta":"b","zulu":"z"},"zebra":1}';
    *
-   *   assert(sorted.value === expected);
+   *   assert.isTrue(sorted.value === expected);
    * }
    *
    * // With formatting
    * const formatted = Json.stringifySortedKey(unorderedData, 2);
    *
-   * assert.ok(Result.isOk(formatted));
+   * assert.isTrue(Result.isOk(formatted));
    *
    * if (Result.isOk(formatted)) {
-   *   assert(isString(formatted.value));
+   *   assert.isTrue(isString(formatted.value));
    *
    *   // Check that keys are in order (first key should be "apple")
-   *   assert.ok(
+   *   assert.isTrue(
    *     formatted.value.indexOf('"apple"') < formatted.value.indexOf('"mango"'),
    *   );
    *
-   *   assert.ok(
+   *   assert.isTrue(
    *     formatted.value.indexOf('"mango"') < formatted.value.indexOf('"nested"'),
    *   );
    *
-   *   assert.ok(
+   *   assert.isTrue(
    *     formatted.value.indexOf('"nested"') < formatted.value.indexOf('"zebra"'),
    *   );
    * }

package/src/json/json.test.mts

@@ -72,13 +72,13 @@ describe('parse', () => {
   });
 
   test('should return error for invalid JSON', () => {
-    expect(Result.isErr(Json.parse('invalid'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('invalid')));
 
-    expect(Result.isErr(Json.parse('{missing quotes: true}'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('{missing quotes: true}')));
 
-    expect(Result.isErr(Json.parse('[1,2,]'))).toBe(true); // Trailing comma
+    assert.isTrue(Result.isErr(Json.parse('[1,2,]'))); // Trailing comma
 
-    expect(Result.isErr(Json.parse('undefined'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('undefined')));
   });
 
   test('should return parsed value for valid JSON', () => {
@@ -96,15 +96,15 @@ describe('parse', () => {
   });
 
   test('should return error for invalid JSON cases', () => {
-    expect(Result.isErr(Json.parse('invalid'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('invalid')));
 
-    expect(Result.isErr(Json.parse('{bad json}'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('{bad json}')));
 
-    expect(Result.isErr(Json.parse('[1,2,]'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('[1,2,]')));
 
-    expect(Result.isErr(Json.parse('undefined'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('undefined')));
 
-    expect(Result.isErr(Json.parse(''))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('')));
   });
 
   test('should handle edge cases', () => {
@@ -138,10 +138,9 @@ describe('parse', () => {
 
     const result = Json.parse(jsonString, dateReviver);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
     if (
-      Result.isOk(result) &&
       isRecord(result.value) &&
       hasKey(result.value, 'name') &&
       hasKey(result.value, 'created')
@@ -166,22 +165,20 @@ describe('parse', () => {
       transformReviver,
     );
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toHaveProperty('number');
+    expect(result.value).toHaveProperty('number');
 
-      expect(result.value).toHaveProperty('text');
+    expect(result.value).toHaveProperty('text');
 
-      if (
-        isRecord(result.value) &&
-        hasKey(result.value, 'number') &&
-        hasKey(result.value, 'text')
-      ) {
-        expect(result.value.number).toBe(42);
+    if (
+      isRecord(result.value) &&
+      hasKey(result.value, 'number') &&
+      hasKey(result.value, 'text')
+    ) {
+      expect(result.value.number).toBe(42);
 
-        expect(result.value.text).toBe('hello');
-      }
+      expect(result.value.text).toBe('hello');
     }
   });
 });
@@ -289,7 +286,7 @@ describe('stringify', () => {
     );
 
     // BigInt should cause an error
-    expect(Result.isErr(Json.stringify(123n))).toBe(true);
+    assert.isTrue(Result.isErr(Json.stringify(123n)));
   });
 
   test('should handle circular references', () => {
@@ -298,7 +295,7 @@ describe('stringify', () => {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
     mut_obj.circular = mut_obj;
 
-    expect(Result.isErr(Json.stringify(mut_obj))).toBe(true);
+    assert.isTrue(Result.isErr(Json.stringify(mut_obj)));
   });
 
   test('should handle objects with toJSON method', () => {
@@ -346,13 +343,11 @@ describe('stringify', () => {
 
     const result = Json.stringify(data, secureReplacer);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('[REDACTED]');
+    expect(result.value).toContain('[REDACTED]');
 
-      expect(result.value).not.toContain('secret123');
-    }
+    expect(result.value).not.toContain('secret123');
   });
 
   test('should format output with space parameter (number)', () => {
@@ -360,13 +355,11 @@ describe('stringify', () => {
 
     const result = Json.stringify(data, undefined, 2);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
+    expect(result.value).toContain('\n');
 
-      expect(result.value).toContain('  '); // 2 spaces indentation
-    }
+    expect(result.value).toContain('  '); // 2 spaces indentation
   });
 
   test('should format output with space parameter (string)', () => {
@@ -374,13 +367,11 @@ describe('stringify', () => {
 
     const result = Json.stringify(data, undefined, '\t');
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
+    expect(result.value).toContain('\n');
 
-      expect(result.value).toContain('\t'); // tab indentation
-    }
+    expect(result.value).toContain('\t'); // tab indentation
   });
 });
 
@@ -396,23 +387,21 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(user, ['id', 'name', 'email']);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      assert.deepStrictEqual(parsed, {
-        id: 1,
-        name: 'Alice',
-        email: 'alice@example.com',
-      });
+    assert.deepStrictEqual(parsed, {
+      id: 1,
+      name: 'Alice',
+      email: 'alice@example.com',
+    });
 
-      expect(parsed).not.toHaveProperty('password');
+    expect(parsed).not.toHaveProperty('password');
 
-      expect(parsed).not.toHaveProperty('lastLogin');
-    }
+    expect(parsed).not.toHaveProperty('lastLogin');
   });
 
   test('should work with nested objects', () => {
@@ -432,31 +421,29 @@ describe('stringifySelected', () => {
       'total',
     ]);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      if (isRecord(parsed) && hasKey(parsed, 'users')) {
-        expect(isRecord(parsed.users)).toBe(false);
+    if (isRecord(parsed) && hasKey(parsed, 'users')) {
+      assert.isTrue(Arr.isArray(parsed.users));
 
-        expect(parsed.users).toHaveLength(2);
+      expect(parsed.users).toHaveLength(2);
 
-        if (Arr.isArray(parsed.users)) {
-          assert.deepStrictEqual(parsed.users[0], { id: 1, name: 'Alice' });
+      if (Arr.isArray(parsed.users)) {
+        assert.deepStrictEqual(parsed.users[0], { id: 1, name: 'Alice' });
 
-          expect(parsed.users[0]).not.toHaveProperty('secret');
-        }
+        expect(parsed.users[0]).not.toHaveProperty('secret');
+      }
 
-        if (isRecord(parsed) && hasKey(parsed, 'metadata')) {
-          assert.deepStrictEqual(parsed.metadata, { total: 2 });
+      if (isRecord(parsed) && hasKey(parsed, 'metadata')) {
+        assert.deepStrictEqual(parsed.metadata, { total: 2 });
 
-          expect(parsed.metadata).not.toHaveProperty('page');
+        expect(parsed.metadata).not.toHaveProperty('page');
 
-          expect(parsed.metadata).not.toHaveProperty('internal');
-        }
+        expect(parsed.metadata).not.toHaveProperty('internal');
       }
     }
   });
@@ -470,19 +457,17 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(matrix, [0, 1]);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      // Note: stringifySelected works with JSON.stringify's replacer parameter
-      // which may not work as expected with arrays
-      expect(Array.isArray(parsed)).toBe(true);
+    // Note: stringifySelected works with JSON.stringify's replacer parameter
+    // which may not work as expected with arrays
+    assert.isTrue(Array.isArray(parsed));
 
-      expect(parsed).toHaveLength(3);
-    }
+    expect(parsed).toHaveLength(3);
   });
 
   test('should handle formatting with space parameter', () => {
@@ -490,13 +475,11 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(data, ['a', 'b', 'c'], 2);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
+    expect(result.value).toContain('\n');
 
-      expect(result.value).toContain('  ');
-    }
+    expect(result.value).toContain('  ');
   });
 
   test('should handle empty selection array', () => {
@@ -504,11 +487,9 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(data, []);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('{}');
-    }
+    expect(result.value).toBe('{}');
   });
 
   test('should handle undefined properties parameter', () => {
@@ -516,15 +497,13 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(data, undefined);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      assert.deepStrictEqual(parsed, { a: 1, b: 2 });
-    }
+    assert.deepStrictEqual(parsed, { a: 1, b: 2 });
   });
 
   test('should handle circular references with error', () => {
@@ -537,7 +516,7 @@ describe('stringifySelected', () => {
     const result = Json.stringifySelected(mut_circular, ['name', 'self']);
 
     // Note: JSON.stringify may handle circular references differently depending on the replacer
-    expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
+    assert.isTrue(Result.isOk(result) || Result.isErr(result));
 
     if (Result.isErr(result)) {
       expectTypeOf(result.value).toBeString();
@@ -556,13 +535,11 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(unsortedObj);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe(
-        '{"aardvark":"animal","apple":"fruit","banana":"fruit","zebra":"animal"}',
-      );
-    }
+    expect(result.value).toBe(
+      '{"aardvark":"animal","apple":"fruit","banana":"fruit","zebra":"animal"}',
+    );
   });
 
   test('should sort nested object keys', () => {
@@ -584,28 +561,26 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(nestedObj);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      if (isRecord(parsed)) {
-        const keys = Object.keys(parsed);
+    if (isRecord(parsed)) {
+      const keys = Object.keys(parsed);
 
-        assert.deepStrictEqual(keys, ['settings', 'user']); // sorted top-level keys
+      assert.deepStrictEqual(keys, ['settings', 'user']); // sorted top-level keys
 
-        if (hasKey(parsed, 'user') && isRecord(parsed.user)) {
-          const userKeys = Object.keys(parsed.user);
+      if (hasKey(parsed, 'user') && isRecord(parsed.user)) {
+        const userKeys = Object.keys(parsed.user);
 
-          assert.deepStrictEqual(userKeys, ['address', 'age', 'name']); // sorted nested keys
+        assert.deepStrictEqual(userKeys, ['address', 'age', 'name']); // sorted nested keys
 
-          if (hasKey(parsed.user, 'address') && isRecord(parsed.user.address)) {
-            const addressKeys = Object.keys(parsed.user.address);
+        if (hasKey(parsed.user, 'address') && isRecord(parsed.user.address)) {
+          const addressKeys = Object.keys(parsed.user.address);
 
-            assert.deepStrictEqual(addressKeys, ['city', 'country', 'zip']); // sorted deeper nested keys
-          }
+          assert.deepStrictEqual(addressKeys, ['city', 'country', 'zip']); // sorted deeper nested keys
         }
       }
     }
@@ -626,43 +601,37 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(dataWithArrays);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      if (isRecord(parsed)) {
-        // Check top-level keys are sorted
-        const topKeys = Object.keys(parsed);
+    if (isRecord(parsed)) {
+      // Check top-level keys are sorted
+      const topKeys = Object.keys(parsed);
 
-        assert.deepStrictEqual(topKeys, ['metadata', 'users']);
+      assert.deepStrictEqual(topKeys, ['metadata', 'users']);
 
-        // Check metadata keys are sorted
-        if (hasKey(parsed, 'metadata') && isRecord(parsed.metadata)) {
-          const metadataKeys = Object.keys(parsed.metadata);
+      // Check metadata keys are sorted
+      if (hasKey(parsed, 'metadata') && isRecord(parsed.metadata)) {
+        const metadataKeys = Object.keys(parsed.metadata);
 
-          assert.deepStrictEqual(metadataKeys, [
-            'author',
-            'created',
-            'version',
-          ]);
-        }
+        assert.deepStrictEqual(metadataKeys, ['author', 'created', 'version']);
+      }
 
-        // Check user object keys are sorted
-        if (
-          hasKey(parsed, 'users') &&
-          Arr.isArray(parsed.users) &&
-          Arr.isNonEmpty(parsed.users)
-        ) {
-          const firstUser = parsed.users[0];
+      // Check user object keys are sorted
+      if (
+        hasKey(parsed, 'users') &&
+        Arr.isArray(parsed.users) &&
+        Arr.isNonEmpty(parsed.users)
+      ) {
+        const firstUser = parsed.users[0];
 
-          if (isRecord(firstUser)) {
-            const userKeys = Object.keys(firstUser);
+        if (isRecord(firstUser)) {
+          const userKeys = Object.keys(firstUser);
 
-            assert.deepStrictEqual(userKeys, ['active', 'id', 'name']);
-          }
+          assert.deepStrictEqual(userKeys, ['active', 'id', 'name']);
         }
       }
     }
@@ -673,15 +642,13 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(obj, 2);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
+    expect(result.value).toContain('\n');
 
-      expect(result.value).toContain('  ');
+    expect(result.value).toContain('  ');
 
-      expect(result.value).toMatch(/\{\s+"a": 1,\s+"b": 2\s+\}/u);
-    }
+    expect(result.value).toMatch(/\{\s+"a": 1,\s+"b": 2\s+\}/u);
   });
 
   test('should produce deterministic output', () => {
@@ -693,13 +660,11 @@ describe('stringifySortedKey', () => {
 
     const result2 = Json.stringifySortedKey(obj2);
 
-    expect(Result.isOk(result1)).toBe(true);
+    assert.isTrue(Result.isOk(result1));
 
-    expect(Result.isOk(result2)).toBe(true);
+    assert.isTrue(Result.isOk(result2));
 
-    if (Result.isOk(result1) && Result.isOk(result2)) {
-      expect(result1.value).toBe(result2.value);
-    }
+    expect(result1.value).toBe(result2.value);
   });
 
   test('should handle problematic objects', () => {
@@ -719,7 +684,7 @@ describe('stringifySortedKey', () => {
       const result = Json.stringifySortedKey(mut_problematicObj);
 
       // This may throw due to circular reference during key extraction
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
       if (Result.isErr(result)) {
         expectTypeOf(result.value).toBeString();
@@ -733,11 +698,9 @@ describe('stringifySortedKey', () => {
   test('should handle empty object', () => {
     const result = Json.stringifySortedKey({});
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('{}');
-    }
+    expect(result.value).toBe('{}');
   });
 
   test('should handle deeply nested structures', () => {
@@ -755,29 +718,27 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(deep);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      if (isRecord(parsed) && hasKey(parsed, 'level1')) {
-        const level1 = parsed.level1;
+    if (isRecord(parsed) && hasKey(parsed, 'level1')) {
+      const level1 = parsed.level1;
 
-        if (isRecord(level1)) {
-          assert.deepStrictEqual(Object.keys(level1), ['a', 'z']);
+      if (isRecord(level1)) {
+        assert.deepStrictEqual(Object.keys(level1), ['a', 'z']);
 
-          if (
-            hasKey(level1, 'a') &&
-            isRecord(level1.a) &&
-            hasKey(level1.a, 'nested')
-          ) {
-            const nested = level1.a.nested;
+        if (
+          hasKey(level1, 'a') &&
+          isRecord(level1.a) &&
+          hasKey(level1.a, 'nested')
+        ) {
+          const nested = level1.a.nested;
 
-            if (isRecord(nested)) {
-              assert.deepStrictEqual(Object.keys(nested), ['x', 'y']);
-            }
+          if (isRecord(nested)) {
+            assert.deepStrictEqual(Object.keys(nested), ['x', 'y']);
           }
         }
       }