ts-data-forge 14.7.1 → 14.8.0

package/src/json/json.mts

@@ -1,7 +1,7 @@
-import {
-  type JsonValue,
-  type UintRangeInclusive,
-  type UnknownRecord,
+import type {
+  JsonValue,
+  UintRangeInclusive,
+  UnknownRecord,
 } from 'ts-type-forge';
 import { Arr } from '../array/index.mjs';
 import { pipe, Result } from '../functional/index.mjs';
@@ -44,13 +44,9 @@ export namespace Json {
    * // With reviver
    * const jsonWithDate = '{"created": "2024-01-01T00:00:00.000Z"}';
    *
-   * const withReviver = Json.parse(jsonWithDate, (key, value) => {
-   *   if (key === 'created' && typeof value === 'string') {
-   *     return new Date(value);
-   *   }
-   *
-   *   return value;
-   * });
+   * const withReviver = Json.parse(jsonWithDate, (key, value) =>
+   *   key === 'created' && typeof value === 'string' ? new Date(value) : value,
+   * );
    *
    * assert.isTrue(Result.isOk(withReviver));
    * ```
@@ -115,19 +111,20 @@ export namespace Json {
    * assert.isTrue(Result.isOk(formatted));
    *
    * // With replacer
-   * const filtered = Json.stringify(data, (key, value) => {
-   *   if (key === 'age') return undefined; // omit age field
-   *
-   *   return value;
-   * });
+   * const filtered = Json.stringify(data, (key, value) =>
+   *   // omit age field
+   *   key === 'age' ? undefined : value,
+   * );
    *
    * assert.isTrue(Result.isOk(filtered));
    *
-   * if (Result.isOk(filtered)) {
-   *   assert.isTrue(isString(filtered.value));
-   *
-   *   assert.isFalse(filtered.value.includes('age'));
+   * if (!Result.isOk(filtered)) {
+   *   return;
    * }
+   *
+   * assert.isTrue(isString(filtered.value));
+   *
+   * assert.isFalse(filtered.value.includes('age'));
    * ```
    *
    * @param value - The JavaScript value to serialize. Can be any value that
@@ -287,24 +284,24 @@ export namespace Json {
    *
    * assert.isTrue(Result.isOk(formatted));
    *
-   * if (Result.isOk(formatted)) {
-   *   assert.isTrue(isString(formatted.value));
+   * if (!Result.isOk(formatted)) {
+   *   return;
+   * }
+   *
+   * assert.isTrue(isString(formatted.value));
    *
-   *   // Check that keys are in order (first key should be "apple")
-   *   assert.isTrue(
-   *     formatted.value.indexOf('"apple"') < formatted.value.indexOf('"mango"'),
-   *   );
+   * // Check that keys are in order (first key should be "apple")
+   * assert.isTrue(
+   *   formatted.value.indexOf('"apple"') < formatted.value.indexOf('"mango"'),
+   * );
    *
-   *   assert.isTrue(
-   *     formatted.value.indexOf('"mango"') <
-   *       formatted.value.indexOf('"nested"'),
-   *   );
+   * assert.isTrue(
+   *   formatted.value.indexOf('"mango"') < formatted.value.indexOf('"nested"'),
+   * );
    *
-   *   assert.isTrue(
-   *     formatted.value.indexOf('"nested"') <
-   *       formatted.value.indexOf('"zebra"'),
-   *   );
-   * }
+   * assert.isTrue(
+   *   formatted.value.indexOf('"nested"') < formatted.value.indexOf('"zebra"'),
+   * );
    * ```
    *
    * @param value - An object (`UnknownRecord`) to serialize. Must be a plain

package/src/json/json.test.mts

@@ -127,13 +127,10 @@ describe('parse', () => {
   });
 
   test('should use reviver function to transform values', () => {
-    const dateReviver = (_key: string, value: unknown): unknown => {
-      if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/u.test(value)) {
-        return new Date(value);
-      }
-
-      return value;
-    };
+    const dateReviver = (_key: string, value: unknown): unknown =>
+      typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/u.test(value)
+        ? new Date(value)
+        : value;
 
     const jsonString = '{"name":"test","created":"2023-12-01T10:00:00.000Z"}';
 
@@ -141,25 +138,24 @@ describe('parse', () => {
 
     assert.isTrue(Result.isOk(result));
 
-    if (
+    if (!(
       isRecord(result.value) &&
       hasKey(result.value, 'name') &&
       hasKey(result.value, 'created')
-    ) {
-      expect(result.value.name).toBe('test');
-
-      expect(result.value.created).toBeInstanceOf(Date);
+    )) {
+      return;
     }
+
+    expect(result.value.name).toBe('test');
+
+    expect(result.value.created).toBeInstanceOf(Date);
   });
 
   test('should handle reviver returning different types', () => {
-    const transformReviver = (key: string, value: unknown): unknown => {
-      if (key === 'number' && typeof value === 'string') {
-        return Result.unwrapOkOr(Num.safeParseInt(value), Number.NaN);
-      }
-
-      return value;
-    };
+    const transformReviver = (key: string, value: unknown): unknown =>
+      key === 'number' && typeof value === 'string'
+        ? Result.unwrapOkOr(Num.safeParseInt(value), Number.NaN)
+        : value;
 
     const result = Json.parse(
       '{"number":"42","text":"hello"}',
@@ -172,15 +168,17 @@ describe('parse', () => {
 
     expect(result.value).toHaveProperty('text');
 
-    if (
+    if (!(
       isRecord(result.value) &&
       hasKey(result.value, 'number') &&
       hasKey(result.value, 'text')
-    ) {
-      expect(result.value.number).toBe(42);
-
-      expect(result.value.text).toBe('hello');
+    )) {
+      return;
     }
+
+    expect(result.value.number).toBe(42);
+
+    expect(result.value.text).toBe('hello');
   });
 });
 
@@ -336,11 +334,8 @@ describe('stringify', () => {
       email: 'john@example.com',
     } as const;
 
-    const secureReplacer = (key: string, value: unknown): unknown => {
-      if (key === 'password') return '[REDACTED]';
-
-      return value;
-    };
+    const secureReplacer = (key: string, value: unknown): unknown =>
+      key === 'password' ? '[REDACTED]' : value;
 
     const result = Json.stringify(data, secureReplacer);
 
@@ -428,25 +423,29 @@ describe('stringifySelected', () => {
 
     const parsed: unknown = JSON.parse(result.value);
 
-    if (isRecord(parsed) && hasKey(parsed, 'users')) {
-      assert.isTrue(Arr.isArray(parsed.users));
-
-      expect(parsed.users).toHaveLength(2);
+    if (!(isRecord(parsed) && hasKey(parsed, 'users'))) {
+      return;
+    }
 
-      if (Arr.isArray(parsed.users)) {
-        assert.deepStrictEqual(parsed.users[0], { id: 1, name: 'Alice' });
+    assert.isTrue(Arr.isArray(parsed.users));
 
-        expect(parsed.users[0]).not.toHaveProperty('secret');
-      }
+    expect(parsed.users).toHaveLength(2);
 
-      if (isRecord(parsed) && hasKey(parsed, 'metadata')) {
-        assert.deepStrictEqual(parsed.metadata, { total: 2 });
+    if (Arr.isArray(parsed.users)) {
+      assert.deepStrictEqual(parsed.users[0], { id: 1, name: 'Alice' });
 
-        expect(parsed.metadata).not.toHaveProperty('page');
+      expect(parsed.users[0]).not.toHaveProperty('secret');
+    }
 
-        expect(parsed.metadata).not.toHaveProperty('internal');
-      }
+    if (!(isRecord(parsed) && hasKey(parsed, 'metadata'))) {
+      return;
     }
+
+    assert.deepStrictEqual(parsed.metadata, { total: 2 });
+
+    expect(parsed.metadata).not.toHaveProperty('page');
+
+    expect(parsed.metadata).not.toHaveProperty('internal');
   });
 
   test('should work with array indices', () => {
@@ -569,23 +568,29 @@ describe('stringifySortedKey', () => {
 
     const parsed: unknown = JSON.parse(result.value);
 
-    if (isRecord(parsed)) {
-      const keys = Object.keys(parsed);
+    if (!isRecord(parsed)) {
+      return;
+    }
+
+    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)) {
+      return;
+    }
 
-        assert.deepStrictEqual(userKeys, ['address', 'age', 'name']); // sorted nested keys
+    const userKeys = Object.keys(parsed.user);
 
-        if (hasKey(parsed.user, 'address') && isRecord(parsed.user.address)) {
-          const addressKeys = Object.keys(parsed.user.address);
+    assert.deepStrictEqual(userKeys, ['address', 'age', 'name']); // sorted nested keys
 
-          assert.deepStrictEqual(addressKeys, ['city', 'country', 'zip']); // sorted deeper nested keys
-        }
-      }
+    if (!hasKey(parsed.user, 'address') || !isRecord(parsed.user.address)) {
+      return;
     }
+
+    const addressKeys = Object.keys(parsed.user.address);
+
+    assert.deepStrictEqual(addressKeys, ['city', 'country', 'zip']); // sorted deeper nested keys
   });
 
   test('should handle arrays with objects', () => {
@@ -609,34 +614,40 @@ describe('stringifySortedKey', () => {
 
     const parsed: unknown = JSON.parse(result.value);
 
-    if (isRecord(parsed)) {
-      // Check top-level keys are sorted
-      const topKeys = Object.keys(parsed);
+    if (!isRecord(parsed)) {
+      return;
+    }
 
-      assert.deepStrictEqual(topKeys, ['metadata', 'users']);
+    // Check top-level keys are sorted
+    const topKeys = Object.keys(parsed);
 
-      // Check metadata keys are sorted
-      if (hasKey(parsed, 'metadata') && isRecord(parsed.metadata)) {
-        const metadataKeys = Object.keys(parsed.metadata);
+    assert.deepStrictEqual(topKeys, ['metadata', 'users']);
 
-        assert.deepStrictEqual(metadataKeys, ['author', 'created', 'version']);
-      }
+    // Check metadata keys are sorted
+    if (hasKey(parsed, 'metadata') && isRecord(parsed.metadata)) {
+      const metadataKeys = Object.keys(parsed.metadata);
 
-      // Check user object keys are sorted
-      if (
-        hasKey(parsed, 'users') &&
-        Arr.isArray(parsed.users) &&
-        Arr.isNonEmpty(parsed.users)
-      ) {
-        const firstUser = parsed.users[0];
+      assert.deepStrictEqual(metadataKeys, ['author', 'created', 'version']);
+    }
 
-        if (isRecord(firstUser)) {
-          const userKeys = Object.keys(firstUser);
+    // Check user object keys are sorted
+    if (
+      !hasKey(parsed, 'users') ||
+      !Arr.isArray(parsed.users) ||
+      !Arr.isNonEmpty(parsed.users)
+    ) {
+      return;
+    }
 
-          assert.deepStrictEqual(userKeys, ['active', 'id', 'name']);
-        }
-      }
+    const firstUser = parsed.users[0];
+
+    if (!isRecord(firstUser)) {
+      return;
     }
+
+    const userKeys = Object.keys(firstUser);
+
+    assert.deepStrictEqual(userKeys, ['active', 'id', 'name']);
   });
 
   test('should handle formatting with space parameter', () => {
@@ -727,24 +738,30 @@ describe('stringifySortedKey', () => {
 
     const parsed: unknown = JSON.parse(result.value);
 
-    if (isRecord(parsed) && hasKey(parsed, 'level1')) {
-      const level1 = parsed.level1;
+    if (!isRecord(parsed) || !hasKey(parsed, 'level1')) {
+      return;
+    }
 
-      if (isRecord(level1)) {
-        assert.deepStrictEqual(Object.keys(level1), ['a', 'z']);
+    const level1 = parsed.level1;
 
-        if (
-          hasKey(level1, 'a') &&
-          isRecord(level1.a) &&
-          hasKey(level1.a, 'nested')
-        ) {
-          const nested = level1.a.nested;
+    if (!isRecord(level1)) {
+      return;
+    }
 
-          if (isRecord(nested)) {
-            assert.deepStrictEqual(Object.keys(nested), ['x', 'y']);
-          }
-        }
-      }
+    assert.deepStrictEqual(Object.keys(level1), ['a', 'z']);
+
+    if (
+      !hasKey(level1, 'a') ||
+      !isRecord(level1.a) ||
+      !hasKey(level1.a, 'nested')
+    ) {
+      return;
+    }
+
+    const nested = level1.a.nested;
+
+    if (isRecord(nested)) {
+      assert.deepStrictEqual(Object.keys(nested), ['x', 'y']);
     }
   });
 });

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

@@ -1,7 +1,7 @@
-import {
-  type Int,
-  type NonNegativeFiniteNumber,
-  type FiniteNumber as TtfImported_FiniteNumber,
+import type {
+  Int,
+  NonNegativeFiniteNumber,
+  FiniteNumber as TtfImported_FiniteNumber,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';

package/src/number/branded-types/int.mts

@@ -1,4 +1,4 @@
-import { type Int as TtfImported_Int } from 'ts-type-forge';
+import type { Int as TtfImported_Int } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
@@ -175,7 +175,7 @@ export const Int = {
    *
    * assert.isTrue(Int.is(randomValue));
    *
-   * assert.isTrue(randomValue >= 1 && randomValue <= 6);
+   * assert.isTrue(1 <= randomValue && randomValue <= 6);
    * ```
    *
    * @param min - The minimum value (inclusive)

package/src/number/branded-types/int16.mts

@@ -1,4 +1,4 @@
-import { type Int16 as TtfImported_Int16 } from 'ts-type-forge';
+import type { Int16 as TtfImported_Int16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/int32.mts

@@ -1,4 +1,4 @@
-import { type Int32 as TtfImported_Int32 } from 'ts-type-forge';
+import type { Int32 as TtfImported_Int32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/negative-finite-number.mts

@@ -1,4 +1,4 @@
-import { type NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
+import type { NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 import { PositiveFiniteNumber } from './positive-finite-number.mjs';
 

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

@@ -1,7 +1,7 @@
-import {
-  type NegativeInt,
-  type NonPositiveInt,
-  type PositiveFiniteNumber,
+import type {
+  NegativeInt,
+  NonPositiveInt,
+  PositiveFiniteNumber,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';

package/src/number/branded-types/negative-int.mts

@@ -1,6 +1,6 @@
-import {
-  type NegativeInt as TtfImported_NegativeInt,
-  type WithSmallInt,
+import type {
+  NegativeInt as TtfImported_NegativeInt,
+  WithSmallInt,
 } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 import { PositiveInt } from './positive-int.mjs';

package/src/number/branded-types/negative-int.test.mts

@@ -1,4 +1,4 @@
-import { type PositiveInt } from 'ts-type-forge';
+import type { PositiveInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import { asNegativeInt, isNegativeInt, NegativeInt } from './negative-int.mjs';

package/src/number/branded-types/negative-safe-int.mts

@@ -1,6 +1,6 @@
-import {
-  type NegativeSafeInt as TtfImported_NegativeSafeInt,
-  type WithSmallInt,
+import type {
+  NegativeSafeInt as TtfImported_NegativeSafeInt,
+  WithSmallInt,
 } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 import { PositiveSafeInt } from './positive-safe-int.mjs';

package/src/number/branded-types/negative-safe-int.test.mts

@@ -1,4 +1,4 @@
-import { type PositiveSafeInt } from 'ts-type-forge';
+import type { PositiveSafeInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import {

package/src/number/branded-types/non-negative-finite-number.mts

@@ -1,6 +1,6 @@
-import {
-  type NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber,
-  type Uint,
+import type {
+  NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber,
+  Uint,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';

package/src/number/branded-types/non-negative-int16.mts

@@ -1,4 +1,4 @@
-import { type NonNegativeInt16 as TtfImported_NonNegativeInt16 } from 'ts-type-forge';
+import type { NonNegativeInt16 as TtfImported_NonNegativeInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/non-negative-int32.mts

@@ -1,4 +1,4 @@
-import { type NonNegativeInt32 as TtfImported_NonNegativeInt32 } from 'ts-type-forge';
+import type { NonNegativeInt32 as TtfImported_NonNegativeInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

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

@@ -1,4 +1,4 @@
-import { type NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
+import type { NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 export type NonPositiveFiniteNumber = TtfImported_NonPositiveFiniteNumber;

package/src/number/branded-types/non-positive-int.mts

@@ -1,4 +1,4 @@
-import { type NonPositiveInt as TtfImported_NonPositiveInt } from 'ts-type-forge';
+import type { NonPositiveInt as TtfImported_NonPositiveInt } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 export type NonPositiveInt = TtfImported_NonPositiveInt;

package/src/number/branded-types/non-positive-safe-int.mts

@@ -1,4 +1,4 @@
-import { type NonPositiveSafeInt as TtfImported_NonPositiveSafeInt } from 'ts-type-forge';
+import type { NonPositiveSafeInt as TtfImported_NonPositiveSafeInt } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 export type NonPositiveSafeInt = TtfImported_NonPositiveSafeInt;

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

@@ -1,8 +1,8 @@
-import {
-  type Int,
-  type NonZeroInt,
-  type PositiveFiniteNumber,
-  type NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber,
+import type {
+  Int,
+  NonZeroInt,
+  PositiveFiniteNumber,
+  NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';

package/src/number/branded-types/non-zero-int.mts

@@ -1,4 +1,4 @@
-import { type NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';
+import type { NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/non-zero-int16.mts

@@ -1,4 +1,4 @@
-import { type NonZeroInt16 as TtfImported_NonZeroInt16 } from 'ts-type-forge';
+import type { NonZeroInt16 as TtfImported_NonZeroInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/non-zero-int32.mts

@@ -1,4 +1,4 @@
-import { type NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
+import type { NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/non-zero-safe-int.mts

@@ -1,7 +1,7 @@
-import {
-  type SafeInt,
-  type SafeUint,
-  type NonZeroSafeInt as TtfImported_NonZeroSafeInt,
+import type {
+  SafeInt,
+  SafeUint,
+  NonZeroSafeInt as TtfImported_NonZeroSafeInt,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';

package/src/number/branded-types/non-zero-uint16.mts

@@ -1,4 +1,4 @@
-import { type NonZeroUint16 as TtfImported_NonZeroUint16 } from 'ts-type-forge';
+import type { NonZeroUint16 as TtfImported_NonZeroUint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/non-zero-uint32.mts

@@ -1,4 +1,4 @@
-import { type NonZeroUint32 as TtfImported_NonZeroUint32 } from 'ts-type-forge';
+import type { NonZeroUint32 as TtfImported_NonZeroUint32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

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

@@ -1,7 +1,7 @@
-import {
-  type PositiveInt,
-  type PositiveFiniteNumber as TtfImported_PositiveFiniteNumber,
-  type Uint,
+import type {
+  PositiveInt,
+  PositiveFiniteNumber as TtfImported_PositiveFiniteNumber,
+  Uint,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';

package/src/number/branded-types/positive-int.mts

@@ -1,4 +1,4 @@
-import { type PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
+import type { PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
@@ -192,7 +192,7 @@ export const PositiveInt = {
    *
    * assert.isTrue(PositiveInt.is(randomValue));
    *
-   * assert.isTrue(randomValue >= 3 && randomValue <= 6);
+   * assert.isTrue(3 <= randomValue && randomValue <= 6);
    * ```
    *
    * @param min - The minimum value (inclusive)

package/src/number/branded-types/positive-int16.mts

@@ -1,4 +1,4 @@
-import { type PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
+import type { PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 

package/src/number/branded-types/positive-int32.mts

@@ -1,4 +1,4 @@
-import { type PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
+import type { PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';