ts-data-forge 8.0.0 → 9.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "8.0.0",
+  "version": "9.0.1",
   "private": false,
   "keywords": [
     "typescript",
@@ -77,16 +77,16 @@
     "test:cov:ui": "vite preview --outDir ./coverage",
     "test:ui": "pnpm run z:vitest:node --ui",
     "testw": "pnpm run z:vitest:node watch",
-    "tsc": "tsc --noEmit",
-    "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
-    "type-check": "tsc --noEmit",
+    "tsc": "node ./node_modules/typescript-native/bin/tsc --noEmit",
+    "tscw": "node ./node_modules/typescript-native/bin/tsc --noEmit --watch -p ./tsconfig.json",
+    "type-check": "node ./node_modules/typescript-native/bin/tsc --noEmit",
     "update-packages": "pnpm update --latest",
     "z:vitest": "vitest --config ./configs/vitest.config.mts",
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
   },
   "dependencies": {
     "@sindresorhus/is": "^8.1.0",
-    "ts-type-forge": "^4.0.0"
+    "ts-type-forge": "^5.0.0"
   },
   "devDependencies": {
     "@emotion/react": "11.14.0",
@@ -94,15 +94,14 @@
     "@mui/material": "9.1.2",
     "@rollup/plugin-replace": "6.0.3",
     "@rollup/plugin-strip": "3.0.4",
-    "@rollup/plugin-typescript": "12.3.0",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/exec": "7.1.0",
     "@semantic-release/git": "10.0.1",
-    "@semantic-release/github": "12.0.8",
+    "@semantic-release/github": "12.0.9",
     "@semantic-release/npm": "13.1.5",
     "@semantic-release/release-notes-generator": "14.1.1",
-    "@types/node": "26.0.1",
+    "@types/node": "26.1.0",
     "@types/react": "19.2.17",
     "@vitest/browser-playwright": "4.1.9",
     "@vitest/coverage-v8": "4.1.9",
@@ -110,35 +109,37 @@
     "conventional-changelog-conventionalcommits": "10.2.0",
     "cspell": "10.0.1",
     "dedent": "1.7.2",
+    "esbuild": "0.28.1",
     "eslint": "9.39.4",
     "eslint-config-typed": "5.3.0",
     "github-settings-as-code": "1.2.9",
-    "immer": "11.1.8",
+    "immer": "11.1.9",
     "jiti": "2.7.0",
     "markdownlint": "0.41.0",
-    "markdownlint-cli2": "0.22.1",
+    "markdownlint-cli2": "0.23.0",
     "npm-run-all2": "9.0.2",
-    "playwright": "1.61.0",
-    "prettier": "3.8.4",
+    "playwright": "1.61.1",
+    "prettier": "3.9.4",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.7",
     "rollup": "4.62.2",
+    "rollup-plugin-esbuild": "6.2.1",
     "semantic-release": "25.0.5",
     "ts-codemod-lib": "2.2.1",
     "ts-repo-utils": "10.1.2",
-    "tslib": "2.8.1",
     "tsx": "4.22.4",
     "typedoc": "0.28.19",
     "typedoc-github-theme": "0.4.0",
-    "typescript": "5.9.3",
-    "vite": "8.1.0",
+    "typescript": "6.0.3",
+    "typescript-native": "npm:typescript@7.0.1-rc",
+    "vite": "8.1.3",
     "vitest": "4.1.9"
   },
   "peerDependencies": {
     "typescript": ">=4.8"
   },
-  "packageManager": "pnpm@10.34.4",
+  "packageManager": "pnpm@11.10.0",
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"

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

@@ -651,8 +651,7 @@ export function partition<
   E,
 >(
   ...args:
-    | readonly [array: readonly E[], chunkSize: N]
-    | readonly [chunkSize: N]
+    readonly [array: readonly E[], chunkSize: N] | readonly [chunkSize: N]
 ):
   | readonly (readonly E[])[]
   | ((array: readonly E[]) => readonly (readonly E[])[]) {

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

@@ -645,18 +645,7 @@ describe('Arr transformations', () => {
       expectType<
         typeof result,
         readonly (readonly (
-          | 1
-          | 2
-          | 3
-          | 4
-          | 5
-          | 6
-          | 7
-          | 8
-          | 9
-          | 10
-          | 11
-          | 12
+          1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
         )[])[]
       >('=');
 
@@ -675,18 +664,7 @@ describe('Arr transformations', () => {
       expectType<
         typeof result,
         readonly (readonly (
-          | 1
-          | 2
-          | 3
-          | 4
-          | 5
-          | 6
-          | 7
-          | 8
-          | 9
-          | 10
-          | 11
-          | 12
+          1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
         )[])[]
       >('=');
 
@@ -706,18 +684,7 @@ describe('Arr transformations', () => {
       expectType<
         typeof result,
         readonly (readonly (
-          | 1
-          | 2
-          | 3
-          | 4
-          | 5
-          | 6
-          | 7
-          | 8
-          | 9
-          | 10
-          | 11
-          | 12
+          1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
         )[])[]
       >('=');
 

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

@@ -228,9 +228,7 @@ describe('Arr validations', () => {
 
       test('should handle union of array types', () => {
         type MixedArrayUnion =
-          | readonly string[]
-          | readonly number[]
-          | readonly boolean[];
+          readonly string[] | readonly number[] | readonly boolean[];
 
         const mixedArray: MixedArrayUnion = [1, 2, 3] as const;
 

package/src/expect-type.mts

@@ -71,9 +71,8 @@ import { type TypeEq, type TypeExtends } from 'ts-type-forge';
 export const expectType = <A, B>(
   _relation: TypeEq<A, B> extends true
     ? '<=' | '=' | '>=' | '~='
-    :
-        | '!='
-        | (TypeExtends<A, B> extends true
-            ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=')
-            : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>=')),
+    : | '!='
+      | (TypeExtends<A, B> extends true
+          ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=')
+          : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>=')),
 ): void => undefined;

package/src/functional/ternary-result/ternary-result.mts

@@ -39,16 +39,12 @@ export type TernaryErr<E> = Readonly<{
  * Represents a value that can be `Ok`, `Warn`, or `Err`.
  */
 export type TernaryResult<S, E, W = E> =
-  | TernaryOk<S>
-  | TernaryWarn<S, W>
-  | TernaryErr<E>;
+  TernaryOk<S> | TernaryWarn<S, W> | TernaryErr<E>;
 
 /**
  * Base type for any `TernaryResult`, used for generic constraints.
  */
 export type UnknownTernaryResult =
-  | TernaryOk<unknown>
-  | TernaryWarn<unknown, unknown>
-  | TernaryErr<unknown>;
+  TernaryOk<unknown> | TernaryWarn<unknown, unknown> | TernaryErr<unknown>;
 
 export * as TernaryResult from './impl/index.mjs';

package/src/guard/index.mts

@@ -1,4 +1,5 @@
 export * from './has-key.mjs';
+export * from './is-length-bounded-string.mjs';
 export * from './is-non-empty-string.mjs';
 export * from './is-non-null-object.mjs';
 export * from './is-primitive.mjs';

package/src/guard/is-length-bounded-string.mts

@@ -0,0 +1,199 @@
+import {
+  type BoundedLengthString,
+  type FixedLengthString,
+  type MaxLengthString,
+  type MinLengthString,
+} from 'ts-type-forge';
+import { type SizeType } from '../types.mjs';
+
+/**
+ * Type guard that checks if a string has at least `minLength` characters.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `MinLengthString<MinLength>` while preserving the
+ *   original string type (e.g. literal types) via intersection.
+ * - The result participates in the length-constraint subtyping relation: for
+ *   example, a value narrowed to `MinLengthString<3>` is assignable to
+ *   `MinLengthString<1>` (= `NonEmptyString`).
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'very-secret-password';
+ *
+ * assert.isTrue(isMinLengthString(input, 12));
+ *
+ * assert.isFalse(isMinLengthString('short', 12));
+ *
+ * if (isMinLengthString(input, 12)) {
+ *   const password: MinLengthString<12> = input;
+ *
+ *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template MinLength - The minimum number of characters (inclusive).
+ * @param s - The string to check.
+ * @param minLength - The minimum number of characters (inclusive).
+ * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
+ *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
+ */
+export const isMinLengthString = <
+  S extends string,
+  MinLength extends SizeType.ArgStr,
+>(
+  s: S,
+  minLength: MinLength,
+): s is MinLengthString<MinLength> & S => s.length >= minLength;
+
+/**
+ * Type guard that checks if a string has at most `maxLength` characters.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the
+ *   original string type (e.g. literal types) via intersection.
+ * - The result participates in the length-constraint subtyping relation: for
+ *   example, a value narrowed to `MaxLengthString<16>` is assignable to
+ *   `MaxLengthString<32>`.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'noshiro';
+ *
+ * assert.isTrue(isMaxLengthString(input, 32));
+ *
+ * assert.isFalse(isMaxLengthString(input, 3));
+ *
+ * if (isMaxLengthString(input, 32)) {
+ *   const userName: MaxLengthString<32> = input;
+ *
+ *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template MaxLength - The maximum number of characters (inclusive).
+ * @param s - The string to check.
+ * @param maxLength - The maximum number of characters (inclusive).
+ * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
+ *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
+ */
+export const isMaxLengthString = <
+  S extends string,
+  MaxLength extends SizeType.ArgStr,
+>(
+  s: S,
+  maxLength: MaxLength,
+): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;
+
+/**
+ * Type guard that checks if a string's length is within the inclusive range
+ * `[minLength, maxLength]`.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while
+ *   preserving the original string type (e.g. literal types) via intersection.
+ * - Since `BoundedLengthString` is the intersection of `MinLengthString` and
+ *   `MaxLengthString`, the narrowed value is assignable to both, and both
+ *   bounds can be weakened independently.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'user-12345678';
+ *
+ * assert.isTrue(isBoundedLengthString(input, 8, 16));
+ *
+ * assert.isFalse(isBoundedLengthString('user', 8, 16));
+ *
+ * if (isBoundedLengthString(input, 8, 16)) {
+ *   const userId: BoundedLengthString<8, 16> = input;
+ *
+ *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template MinLength - The minimum number of characters (inclusive).
+ * @template MaxLength - The maximum number of characters (inclusive).
+ * @param s - The string to check.
+ * @param minLength - The minimum number of characters (inclusive).
+ * @param maxLength - The maximum number of characters (inclusive).
+ * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
+ *   otherwise. When `true`, TypeScript narrows `s` to
+ *   `BoundedLengthString<MinLength, MaxLength> & S`.
+ */
+export const isBoundedLengthString = <
+  S extends string,
+  MinLength extends SizeType.ArgStr,
+  MaxLength extends SizeType.ArgStr,
+>(
+  s: S,
+  minLength: MinLength,
+  maxLength: MaxLength,
+): s is BoundedLengthString<MinLength, MaxLength> & S =>
+  s.length >= minLength && s.length <= maxLength;
+
+/**
+ * Type guard that checks if a string has exactly `length` characters.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `FixedLengthString<Length>` while preserving the
+ *   original string type (e.g. literal types) via intersection.
+ * - Since `FixedLengthString<Length>` is defined as
+ *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to
+ *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`
+ *   with `N >= Length`.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'JP';
+ *
+ * assert.isTrue(isFixedLengthString(input, 2));
+ *
+ * assert.isFalse(isFixedLengthString(input, 3));
+ *
+ * if (isFixedLengthString(input, 2)) {
+ *   const countryCode: FixedLengthString<2> = input;
+ *
+ *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template Length - The exact number of characters.
+ * @param s - The string to check.
+ * @param length - The exact number of characters.
+ * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
+ *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
+ */
+export const isFixedLengthString = <
+  S extends string,
+  Length extends SizeType.ArgStr,
+>(
+  s: S,
+  length: Length,
+): s is FixedLengthString<Length> & S => s.length === length;

package/src/guard/is-length-bounded-string.test.mts

@@ -0,0 +1,170 @@
+import {
+  type BoundedLengthString,
+  type FixedLengthString,
+  type MaxLengthString,
+  type MinLengthString,
+  type NonEmptyString,
+} from 'ts-type-forge';
+import { expectType } from '../expect-type.mjs';
+import {
+  isBoundedLengthString,
+  isFixedLengthString,
+  isMaxLengthString,
+  isMinLengthString,
+} from './is-length-bounded-string.mjs';
+
+describe(isMinLengthString, () => {
+  test('should return true when the string is long enough', () => {
+    assert.isTrue(isMinLengthString('hello', 3));
+
+    assert.isTrue(isMinLengthString('hello', 5));
+
+    assert.isTrue(isMinLengthString('', 0));
+
+    assert.isTrue(isMinLengthString(' ', 1)); // Space counts
+  });
+
+  test('should return false when the string is too short', () => {
+    assert.isFalse(isMinLengthString('hi', 3));
+
+    assert.isFalse(isMinLengthString('', 1));
+  });
+
+  test('should measure length in UTF-16 code units', () => {
+    assert.isTrue(isMinLengthString('🎉', 2)); // Surrogate pair
+
+    assert.isFalse(isMinLengthString('🎉', 3));
+  });
+
+  test('should act as a type guard', () => {
+    const value: string = 'very-secret-password';
+
+    if (isMinLengthString(value, 12)) {
+      expectType<typeof value, MinLengthString<12>>('<=');
+
+      expectType<typeof value, NonEmptyString>('<='); // 12 >= 1
+
+      expectType<typeof value, MinLengthString<16>>('!<=');
+
+      expect(value.length).toBeGreaterThanOrEqual(12);
+    }
+  });
+
+  test('should preserve literal string types', () => {
+    const literal = 'hello';
+
+    if (isMinLengthString(literal, 3)) {
+      expectType<typeof literal, 'hello'>('<=');
+
+      expectType<typeof literal, MinLengthString<3>>('<=');
+    }
+  });
+});
+
+describe(isMaxLengthString, () => {
+  test('should return true when the string is short enough', () => {
+    assert.isTrue(isMaxLengthString('hello', 10));
+
+    assert.isTrue(isMaxLengthString('hello', 5));
+
+    assert.isTrue(isMaxLengthString('', 0));
+  });
+
+  test('should return false when the string is too long', () => {
+    assert.isFalse(isMaxLengthString('hello', 3));
+
+    assert.isFalse(isMaxLengthString(' ', 0));
+  });
+
+  test('should measure length in UTF-16 code units', () => {
+    assert.isFalse(isMaxLengthString('🎉', 1)); // Surrogate pair
+
+    assert.isTrue(isMaxLengthString('🎉', 2));
+  });
+
+  test('should act as a type guard', () => {
+    const value: string = 'noshiro';
+
+    if (isMaxLengthString(value, 32)) {
+      expectType<typeof value, MaxLengthString<32>>('<=');
+
+      expectType<typeof value, MaxLengthString<64>>('<='); // 32 <= 64
+
+      expectType<typeof value, MaxLengthString<16>>('!<=');
+
+      expect(value.length).toBeLessThanOrEqual(32);
+    }
+  });
+});
+
+describe(isBoundedLengthString, () => {
+  test('should return true when the length is within the range', () => {
+    assert.isTrue(isBoundedLengthString('user-12345678', 8, 16));
+
+    assert.isTrue(isBoundedLengthString('12345678', 8, 16)); // Lower bound (inclusive)
+
+    assert.isTrue(isBoundedLengthString('1234567890123456', 8, 16)); // Upper bound (inclusive)
+
+    assert.isTrue(isBoundedLengthString('', 0, 0));
+  });
+
+  test('should return false when the length is out of range', () => {
+    assert.isFalse(isBoundedLengthString('user', 8, 16));
+
+    assert.isFalse(isBoundedLengthString('12345678901234567', 8, 16));
+  });
+
+  test('should act as a type guard', () => {
+    const value: string = 'user-12345678';
+
+    if (isBoundedLengthString(value, 8, 16)) {
+      expectType<typeof value, BoundedLengthString<8, 16>>('<=');
+
+      expectType<typeof value, BoundedLengthString<1, 255>>('<='); // [8, 16] ⊆ [1, 255]
+
+      expectType<typeof value, MinLengthString<8>>('<=');
+
+      expectType<typeof value, MaxLengthString<16>>('<=');
+
+      expectType<typeof value, NonEmptyString>('<='); // 8 >= 1
+
+      expectType<typeof value, BoundedLengthString<10, 16>>('!<=');
+    }
+  });
+});
+
+describe(isFixedLengthString, () => {
+  test('should return true only for the exact length', () => {
+    assert.isTrue(isFixedLengthString('JP', 2));
+
+    assert.isTrue(isFixedLengthString('', 0));
+
+    assert.isFalse(isFixedLengthString('JPN', 2));
+
+    assert.isFalse(isFixedLengthString('J', 2));
+  });
+
+  test('should measure length in UTF-16 code units', () => {
+    assert.isTrue(isFixedLengthString('🎉', 2)); // Surrogate pair
+
+    assert.isFalse(isFixedLengthString('🎉', 1));
+  });
+
+  test('should act as a type guard', () => {
+    const value: string = 'JP';
+
+    if (isFixedLengthString(value, 2)) {
+      expectType<typeof value, FixedLengthString<2>>('<=');
+
+      expectType<typeof value, BoundedLengthString<2, 2>>('<=');
+
+      expectType<typeof value, MaxLengthString<5>>('<='); // 2 <= 5
+
+      expectType<typeof value, MinLengthString<1>>('<='); // 2 >= 1
+
+      expectType<typeof value, NonEmptyString>('<=');
+
+      expectType<typeof value, FixedLengthString<3>>('!<=');
+    }
+  });
+});

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

@@ -185,15 +185,7 @@ export namespace TsDataForgeInternals {
       }>;
 
     type BaseKeys =
-      | 'add'
-      | 'div'
-      | 'is'
-      | 'max'
-      | 'min'
-      | 'mul'
-      | 'pow'
-      | 'random'
-      | 'sub';
+      'add' | 'div' | 'is' | 'max' | 'min' | 'mul' | 'pow' | 'random' | 'sub';
 
     type FloatMethods = 'ceil' | 'floor' | 'round';
 

package/src/object/object.mts

@@ -224,11 +224,9 @@ export namespace Obj {
     const Keys extends readonly (keyof R)[],
   >(
     ...args:
-      | readonly [record: R, keys: Keys]
-      | readonly [keys: readonly PropertyKey[]]
+      readonly [record: R, keys: Keys] | readonly [keys: readonly PropertyKey[]]
   ):
-    | Omit<R, ArrayElement<Keys>>
-    | ((record: R) => Omit<R, ArrayElement<Keys>>) {
+    Omit<R, ArrayElement<Keys>> | ((record: R) => Omit<R, ArrayElement<Keys>>) {
     switch (args.length) {
       case 2: {
         const [record, keys] = args;
@@ -644,32 +642,36 @@ declare namespace TsDataForgeInternals {
     readonly [K in keyof B as {} extends Pick<B, K> ? never : K]: B[K];
   } & {
     // 2. Optional properties from B that are NOT in A
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in keyof B as {} extends Pick<B, K>
-      ? K extends keyof A
-        ? never
-        : K
-      : never]?: B[K];
+    readonly [
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      K in keyof B as {} extends Pick<B, K>
+        ? K extends keyof A
+          ? never
+          : K
+        : never
+    ]?: B[K];
   } & {
     // 3. Optional properties from B that ARE in A (create union)
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in keyof B as {} extends Pick<B, K>
-      ? K extends keyof A
-        ? K
+    readonly [
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      K in keyof B as {} extends Pick<B, K>
+        ? K extends keyof A
+          ? K
+          : never
         : never
-      : never]?: K extends keyof A ? A[K] | B[K] : never;
+    ]?: K extends keyof A ? A[K] | B[K] : never;
   } & {
     // 4. Required properties only in A (not overridden by B)
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in Exclude<keyof A, keyof B> as {} extends Pick<A, K>
-      ? never
-      : K]: A[K];
+    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
+    ]: A[K];
   } & {
     // 5. Optional properties only in A (not overridden by B)
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in Exclude<keyof A, keyof B> as {} extends Pick<A, K>
-      ? K
-      : never]?: A[K];
+    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
+    ]?: A[K];
   } extends infer O
     ? Readonly<
         {