@rimbu/deep 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/deep",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Tools to use handle plain JS objects as immutable objects",
   "keywords": [
     "immutable",
@@ -36,6 +36,7 @@
   "types": "./dist/cjs/index.d.cts",
   "exports": {
     ".": {
+      "bun": "./dist/bun/index.mts",
       "import": {
         "types": "./dist/esm/index.d.mts",
         "default": "./dist/esm/index.mjs"
@@ -43,8 +44,7 @@
       "require": {
         "types": "./dist/cjs/index.d.cts",
         "default": "./dist/cjs/index.cjs"
-      },
-      "bun": "./dist/bun/index.mts"
+      }
     }
   },
   "files": [
@@ -66,7 +66,7 @@
     "bundle:deno-clean": "rimraf _deno_prepare",
     "bundle:esm": "tsc --p tsconfig.esm.json",
     "clean": "rimraf dist",
-    "extract-api": "ts-node ../../config/api-extractor.ts config/api-extractor.main.json",
+    "extract-api": "tsx ../../config/api-extractor.ts config/api-extractor.main.json",
     "format": "yarn format:base --write",
     "format:base": "prettier \"{!CHANGELOG.md}|**/**/*.{ts,tsx,js,mts,mjs,json,md}\"",
     "format:check": "yarn format:base --check",
@@ -78,12 +78,12 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@rimbu/base": "^2.0.1",
-    "@rimbu/common": "^2.0.1",
+    "@rimbu/base": "^2.0.3",
+    "@rimbu/common": "^2.0.3",
     "tslib": "^2.6.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b7ed656d2c55d1a715d6a3f52e364e68cb98c759"
+  "gitHead": "1c35dbdd9ce13aeba818b41eb20bab1e826b3e16"
 }

package/src/deep.mts

@@ -90,9 +90,9 @@ export function patchAtWith<T, P extends Path.Set<T>, TE extends T = T, TT = T>(
 
 /**
  * Returns a function that matches a given `value` with the given `matcher`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @param matcher - a matcher object that matches input values.
- * @param source - the value to use the given `patchItem` on at the given `path`.
+ * @param source - the value to match (parameter of the returned function).
  * @example
  * ```ts
  * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }];
@@ -128,7 +128,7 @@ export function matchAt<T, P extends Path.Get<T>>(
 
 /**
  * Returns a function that matches a given `value` with the given `matcher` at the given string `path`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam P - the string literal path type in the object
  * @typeparam TE - utility type
  * @param path - the string path in the object
@@ -150,7 +150,7 @@ export function matchAtWith<T, P extends Path.Get<T>, TE extends T = T>(
 
 /**
  * Returns a function that selects a certain shape from a given `value` with the given `selector`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam SL - the selector shape type
  * @param selector - a shape indicating the selection from the source values
  * @param source - the value to use the given `selector` on.
@@ -169,7 +169,7 @@ export function selectWith<T, SL extends Selector<T>>(
 
 /**
  * Returns the result of applying the given `selector` shape to the given `source` value.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam P - the string literal path type in the object
  * @typeparam SL - the selector shape type
  * @param source - the source value to select from
@@ -185,7 +185,7 @@ export function selectWith<T, SL extends Selector<T>>(
 export function selectAt<
   T,
   P extends Path.Get<T>,
-  SL extends Selector<Path.Result<T, P>>
+  SL extends Selector<Path.Result<T, P>>,
 >(
   source: T,
   path: P,
@@ -196,7 +196,7 @@ export function selectAt<
 
 /**
  * Returns a function that selects a certain shape from a given `value` with the given `selector` at the given string `path`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam P - the string literal path type in the object
  * @typeparam SL - the selector shape type
  * @param path - the string path in the object
@@ -211,7 +211,7 @@ export function selectAt<
 export function selectAtWith<
   T,
   P extends Path.Get<T>,
-  SL extends Selector<Path.Result<T, P>>
+  SL extends Selector<Path.Result<T, P>>,
 >(
   path: P,
   selector: Selector.Shape<SL>

package/src/match.mts

@@ -28,25 +28,31 @@ export namespace Match {
    * @typeparam P - the parent type
    * @typeparam R - the root object type
    */
-  export type Entry<T, C, P, R> = IsAnyFunc<T> extends true
-    ? // function can only be directly matched
-      T
-    : IsPlainObj<T> extends true
-    ? // determine allowed match values for object
-      Match.WithResult<T, P, R, Match.Obj<T, C, P, R>>
-    : IsArray<T> extends true
-    ? // determine allowed match values for array or tuple
-      | Match.Arr<T, C, P, R>
-        | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
-        | Match.Func<
-            T,
-            P,
-            R,
+  export type Entry<T, C, P, R> =
+    IsAnyFunc<T> extends true
+      ? // function can only be directly matched
+        T
+      : IsPlainObj<T> extends true
+        ? // determine allowed match values for object
+          Match.WithResult<T, P, R, Match.Obj<T, C, P, R>>
+        : IsArray<T> extends true
+          ? // determine allowed match values for array or tuple
             | Match.Arr<T, C, P, R>
-            | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
-          >
-    : // only accept values with same interface
-      Match.WithResult<T, P, R, { [K in keyof C]: C[K & keyof T] }>;
+              | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
+              | Match.Func<
+                  T,
+                  P,
+                  R,
+                  | Match.Arr<T, C, P, R>
+                  | Match.Entry<
+                      T[number & keyof T],
+                      C[number & keyof C],
+                      P,
+                      R
+                    >[]
+                >
+          : // only accept values with same interface
+            Match.WithResult<T, P, R, { [K in keyof C]: C[K & keyof T] }>;
 
   /**
    * The type that determines allowed matchers for objects.
@@ -128,7 +134,7 @@ export namespace Match {
   export type ArrayTraversalType = `${CompoundType}Item`;
 
   /**
-   * Compount matcher for objects, can only be an array staring with a compound type keyword.
+   * Compound matcher for objects, represented as an array starting with a compound type keyword.
    * @typeparam T - the input value type
    * @typeparam C - utility type
    * @typeparam P - the parent type
@@ -136,7 +142,7 @@ export namespace Match {
    */
   export type CompoundForObj<T, C, P, R> = [
     Match.CompoundType,
-    ...Match.Entry<T, C, P, R>[]
+    ...Match.Entry<T, C, P, R>[],
   ];
 
   /**
@@ -188,7 +194,7 @@ export namespace Match {
  * match(input, { a: 2 }) // => false
  * match(input, { a: (v) => v > 10 }) // => false
  * match(input, { b: { c: true }}) // => true
- * match(input, (['every', { a: (v) => v > 0 }, { b: { c: true } }]) // => true
+ * match(input, ['every', { a: (v) => v > 0 }, { b: { c: true } }]) // => true
  * match(input, { b: { c: (v, parent, root) => v && parent.d.length > 0 && root.a > 0 } })
  *  // => true
  * ```
@@ -272,9 +278,7 @@ function matchEntry<T, C, P, R>(
   // already determined above that the source and matcher are not equal
 
   failureLog?.push(
-    `value ${JSON.stringify(
-      source
-    )} does not match given matcher ${JSON.stringify(matcher)}`
+    `value ${JSON.stringify(source)} does not match given matcher ${JSON.stringify(matcher)}`
   );
 
   return false;
@@ -469,9 +473,7 @@ function matchPlainObj<T extends object, C, P, R>(
       // the source does not have the given key
 
       failureLog?.push(
-        `key ${key} is specified in matcher but not present in value ${JSON.stringify(
-          source
-        )}`
+        `key ${key} is specified in matcher but not present in value ${JSON.stringify(source)}`
       );
 
       return false;

package/src/patch.mts

@@ -22,15 +22,16 @@ export namespace Patch {
    * @typeparam P - the parent type
    * @typeparam R - the root object type
    */
-  export type Entry<T, C, P, R> = IsAnyFunc<T> extends true
-    ? T
-    : IsPlainObj<T> extends true
-    ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>>
-    : Tuple.IsTuple<T> extends true
-    ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>>
-    : IsArray<T> extends true
-    ? Patch.WithResult<T, P, R, T>
-    : Patch.WithResult<T, P, R, T>;
+  export type Entry<T, C, P, R> =
+    IsAnyFunc<T> extends true
+      ? T
+      : IsPlainObj<T> extends true
+        ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>>
+        : Tuple.IsTuple<T> extends true
+          ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>>
+          : IsArray<T> extends true
+            ? Patch.WithResult<T, P, R, T>
+            : Patch.WithResult<T, P, R, T>;
 
   /**
    * Either result type S, or a patch function with the value type, the parent type, and the root type.
@@ -109,7 +110,7 @@ export namespace Patch {
  * patch(input, [{ a: 2 }])  // => { a: 2, b: { c: true, d: 'a' } }
  * patch(input, [{ b: [{ c: (v) => !v }] }] )
  * // => { a: 1, b: { c: false, d: 'a' } }
- * patch(input: [{ a: (v) => v + 1, b: [{ d: 'q' }] }] )
+ * patch(input, [{ a: (v) => v + 1, b: [{ d: 'q' }] }] )
  * // => { a: 2, b: { c: true, d: 'q' } }
  * ```
  */

package/src/path.mts

@@ -36,7 +36,7 @@ export namespace Path {
       T,
       Write extends boolean,
       Maybe extends boolean,
-      First extends boolean = false
+      First extends boolean = false,
     > = `${IsAnyFunc<T> extends true
       ? // functions can not be further decomposed
         ''
@@ -54,47 +54,44 @@ export namespace Path {
       T,
       Write extends boolean,
       Maybe extends boolean,
-      First extends boolean
-    > = Path.Internal.IsOptional<T> extends true
-      ? // the value T may be null or undefined, check whether further chaining is allowed
-        Write extends false
-        ? // path is not used to write to, so optional chaining is allowed
-          Path.Internal.Generic<Exclude<T, undefined | null>, Write, true>
-        : // path can be written to, no optional chaining allowed
-          never
-      : // determine separator, and continue with non-optional value
-        `${Path.Internal.Separator<
-          First,
-          Maybe,
-          IsArray<T>
-        >}${Path.Internal.NonOptional<T, Write, Maybe>}`;
+      First extends boolean,
+    > =
+      Path.Internal.IsOptional<T> extends true
+        ? // the value T may be null or undefined, check whether further chaining is allowed
+          Write extends false
+          ? // path is not used to write to, so optional chaining is allowed
+            Path.Internal.Generic<Exclude<T, undefined | null>, Write, true>
+          : // path can be written to, no optional chaining allowed
+            never
+        : // determine separator, and continue with non-optional value
+          `${Path.Internal.Separator<
+            First,
+            Maybe,
+            IsArray<T>
+          >}${Path.Internal.NonOptional<T, Write, Maybe>}`;
 
     /**
      * Determines the allowed paths into a non-optional value of type `T`.
      * @typeparam T - the source type
      * @typeparam Write - if true the path should be writable (no optional chaining)
      * @typeparam Maybe - if true the value at the current path is optional
-     * @typeparam First - if true this is the root call
      */
-    export type NonOptional<
-      T,
-      Write extends boolean,
-      Maybe extends boolean
-    > = Tuple.IsTuple<T> extends true
-      ? // determine allowed paths for tuple
-        Path.Internal.Tup<T, Write, Maybe>
-      : T extends readonly any[]
-      ? // determine allowed paths for array
-        Write extends false
-        ? // path is not writable so arrays are allowed
-          Path.Internal.Arr<T>
-        : // path is writable, no arrays allowed
-          never
-      : IsPlainObj<T> extends true
-      ? // determine allowed paths for object
-        Path.Internal.Obj<T, Write, Maybe>
-      : // no match
-        never;
+    export type NonOptional<T, Write extends boolean, Maybe extends boolean> =
+      Tuple.IsTuple<T> extends true
+        ? // determine allowed paths for tuple
+          Path.Internal.Tup<T, Write, Maybe>
+        : T extends readonly any[]
+          ? // determine allowed paths for array
+            Write extends false
+            ? // path is not writable so arrays are allowed
+              Path.Internal.Arr<T>
+            : // path is writable, no arrays allowed
+              never
+          : IsPlainObj<T> extends true
+            ? // determine allowed paths for object
+              Path.Internal.Obj<T, Write, Maybe>
+            : // no match
+              never;
 
     /**
      * Determines the allowed paths for a tuple. Since tuples have fixed types, they do not
@@ -104,11 +101,7 @@ export namespace Path {
      * @typeparam Maybe - if true the value at the current path is optional
      */
     export type Tup<T, Write extends boolean, Maybe extends boolean> = {
-      [K in Tuple.KeysOf<T>]: `[${K}]${Path.Internal.Generic<
-        T[K],
-        Write,
-        Maybe
-      >}`;
+      [K in Tuple.KeysOf<T>]: `[${K}]${Path.Internal.Generic<T[K], Write, Maybe>}`;
     }[Tuple.KeysOf<T>];
 
     /**
@@ -135,7 +128,7 @@ export namespace Path {
     }[keyof T];
 
     /**
-     * Determines the allowed path part seperator based on the input types.
+     * Determines the allowed path part separator based on the input types.
      * @typeparam First - if true, this is the first call
      * @typeparam Maybe - if true, the value is optional
      * @typeparam IsArray - if true, the value is an array
@@ -143,7 +136,7 @@ export namespace Path {
     export type Separator<
       First extends boolean,
       Maybe extends boolean,
-      IsArray extends boolean
+      IsArray extends boolean,
     > = Maybe extends true
       ? First extends true
         ? // first optional value cannot have separator
@@ -151,13 +144,13 @@ export namespace Path {
         : // non-first optional value must have separator
           '?.'
       : First extends true
-      ? // first non-optional value has empty separator
-        ''
-      : IsArray extends true
-      ? // array selectors do not have separator
-        ''
-      : // normal separator
-        '.';
+        ? // first non-optional value has empty separator
+          ''
+        : IsArray extends true
+          ? // array selectors do not have separator
+            ''
+          : // normal separator
+            '.';
 
     /**
      * Determines whether the given type `T` is optional, that is, whether it can be null or undefined.
@@ -169,10 +162,10 @@ export namespace Path {
       ? // is optional
         True
       : null extends T
-      ? // is optional
-        True
-      : // not optional
-        False;
+        ? // is optional
+          True
+        : // not optional
+          False;
 
     /**
      * Returns type `T` if `Maybe` is false, `T | undefined` otherwise.
@@ -185,12 +178,12 @@ export namespace Path {
 
     /**
      * Utility type to only add non-empty string types to a string array.
-     * @typeparma A - the input string array
+     * @typeparam A - the input string array
      * @typeparam T - the string value to optionally add
      */
     export type AppendIfNotEmpty<
       A extends string[],
-      T extends string
+      T extends string,
     > = T extends ''
       ? // empty string, do not add
         A
@@ -224,23 +217,23 @@ export namespace Path {
     export type For<
       T,
       Tokens,
-      Maybe extends boolean = Path.Internal.IsOptional<T>
+      Maybe extends boolean = Path.Internal.IsOptional<T>,
     > = Tokens extends []
       ? // no more token
         Path.Internal.MaybeValue<T, Maybe>
       : Path.Internal.IsOptional<T> extends true
-      ? // T can be null or undefined, so continue with Maybe set to true
-        Path.Result.For<Exclude<T, undefined | null>, Tokens, Maybe>
-      : Tokens extends ['?.', infer Key, ...infer Rest]
-      ? // optional chaining, process first part and set Maybe to true
-        Path.Result.For<Path.Result.Part<T, Key, Maybe>, Rest, true>
-      : Tokens extends ['.', infer Key, ...infer Rest]
-      ? // normal chaining, process first part and continue
-        Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
-      : Tokens extends [infer Key, ...infer Rest]
-      ? // process first part, and continue
-        Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
-      : never;
+        ? // T can be null or undefined, so continue with Maybe set to true
+          Path.Result.For<Exclude<T, undefined | null>, Tokens, Maybe>
+        : Tokens extends ['?.', infer Key, ...infer Rest]
+          ? // optional chaining, process first part and set Maybe to true
+            Path.Result.For<Path.Result.Part<T, Key, Maybe>, Rest, true>
+          : Tokens extends ['.', infer Key, ...infer Rest]
+            ? // normal chaining, process first part and continue
+              Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
+            : Tokens extends [infer Key, ...infer Rest]
+              ? // process first part, and continue
+                Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
+              : never;
 
     /**
      * Determines the result of getting the property/index `K` from type `T`, taking into
@@ -249,15 +242,16 @@ export namespace Path {
      * @typeparam K - the key to get from the source type
      * @typeparam Maybe - if true indicates that the path may be undefined
      */
-    export type Part<T, K, Maybe extends boolean> = IsArray<T> extends true
-      ? // for arrays, Maybe needs to be set to true to force optional chaining
-        // for tuples, Maybe should be false
-        Path.Internal.MaybeValue<
-          T[K & keyof T],
-          Tuple.IsTuple<T> extends true ? Maybe : true
-        >
-      : // Return the type at the given key, and take `Maybe` into account
-        Path.Internal.MaybeValue<T[K & keyof T], Maybe>;
+    export type Part<T, K, Maybe extends boolean> =
+      IsArray<T> extends true
+        ? // for arrays, Maybe needs to be set to true to force optional chaining
+          // for tuples, Maybe should be false
+          Path.Internal.MaybeValue<
+            T[K & keyof T],
+            Tuple.IsTuple<T> extends true ? Maybe : true
+          >
+        : // Return the type at the given key, and take `Maybe` into account
+          Path.Internal.MaybeValue<T[K & keyof T], Maybe>;
 
     /**
      * Converts a path string into separate tokens in a string array.
@@ -268,31 +262,35 @@ export namespace Path {
     export type Tokenize<
       P extends string,
       Token extends string = '',
-      Res extends string[] = []
+      Res extends string[] = [],
     > = P extends ''
       ? // no more input to process, return result
         Path.Internal.AppendIfNotEmpty<Res, Token>
       : P extends `[${infer Index}]${infer Rest}`
-      ? // input is an array selector, append index to tokens. Continue with new token
-        Tokenize<
-          Rest,
-          '',
-          [...Path.Internal.AppendIfNotEmpty<Res, Token>, Index]
-        >
-      : P extends `?.${infer Rest}`
-      ? // optional chaining, append to tokens. Continue with new token
-        Tokenize<
-          Rest,
-          '',
-          [...Path.Internal.AppendIfNotEmpty<Res, Token>, '?.']
-        >
-      : P extends `.${infer Rest}`
-      ? // normal chaining, append to tokens. Continue with new token
-        Tokenize<Rest, '', [...Path.Internal.AppendIfNotEmpty<Res, Token>, '.']>
-      : P extends `${infer First}${infer Rest}`
-      ? // process next character
-        Tokenize<Rest, `${Token}${First}`, Res>
-      : never;
+        ? // input is an array selector, append index to tokens. Continue with new token
+          Tokenize<
+            Rest,
+            '',
+            [...Path.Internal.AppendIfNotEmpty<Res, Token>, Index]
+          >
+        : P extends `?.${infer Rest}`
+          ? // optional chaining, append to tokens. Continue with new token
+            Tokenize<
+              Rest,
+              '',
+              [...Path.Internal.AppendIfNotEmpty<Res, Token>, '?.']
+            >
+          : P extends `.${infer Rest}`
+            ? // normal chaining, append to tokens. Continue with new token
+              Tokenize<
+                Rest,
+                '',
+                [...Path.Internal.AppendIfNotEmpty<Res, Token>, '.']
+              >
+            : P extends `${infer First}${infer Rest}`
+              ? // process next character
+                Tokenize<Rest, `${Token}${First}`, Res>
+              : never;
   }
 
   /**
@@ -327,9 +325,9 @@ export namespace Path {
  * ```ts
  * const value = { a: { b: { c: [{ d: 5 }, { d: 6 }] } } }
  * Deep.getAt(value, 'a.b');
- * // => { c: 5 }
+ * // => { c: [{ d: 5 }, { d: 6 }] }
  * Deep.getAt(value, 'a.b.c');
- * // => [{ d: 5 }, { d: 5 }]
+ * // => [{ d: 5 }, { d: 6 }]
  * Deep.getAt(value, 'a.b.c[1]');
  * // => { d: 6 }
  * Deep.getAt(value, 'a.b.c[1]?.d');

package/src/protected.mts

@@ -11,20 +11,21 @@ import type { IsAny, IsPlainObj } from '@rimbu/base';
  * - Any other type will not be mapped
  * @typeparam T - the input type
  */
-export type Protected<T> = IsAny<T> extends true
-  ? // to prevent infinite recursion, any will be any
-    T
-  : T extends readonly any[] & infer A
-  ? // convert all keys to readonly and all values to `Protected`
-    { readonly [K in keyof A]: Protected<A[K]> }
-  : T extends Map<infer K, infer V>
-  ? ReadonlyMap<Protected<K>, Protected<V>>
-  : T extends Set<infer E>
-  ? ReadonlySet<Protected<E>>
-  : T extends Promise<infer E>
-  ? Promise<Protected<E>>
-  : IsPlainObj<T> extends true
-  ? // convert all keys to readonly and all values to `Protected`
-    { readonly [K in keyof T]: Protected<T[K]> }
-  : // nothing to do, just return `T`
-    T;
+export type Protected<T> =
+  IsAny<T> extends true
+    ? // to prevent infinite recursion, any will be any
+      T
+    : T extends readonly any[] & infer A
+      ? // convert all keys to readonly and all values to `Protected`
+        { readonly [K in keyof A]: Protected<A[K]> }
+      : T extends Map<infer K, infer V>
+        ? ReadonlyMap<Protected<K>, Protected<V>>
+        : T extends Set<infer E>
+          ? ReadonlySet<Protected<E>>
+          : T extends Promise<infer E>
+            ? Promise<Protected<E>>
+            : IsPlainObj<T> extends true
+              ? // convert all keys to readonly and all values to `Protected`
+                { readonly [K in keyof T]: Protected<T[K]> }
+              : // nothing to do, just return `T`
+                T;

package/src/selector.mts

@@ -22,32 +22,34 @@ export namespace Selector {
    * Type defining the shape of allowed selectors, used to improve compiler checking.
    * @typeparam SL - the selector type
    */
-  export type Shape<SL> = IsAnyFunc<SL> extends true
-    ? // functions are allowed, type provided by `Selector`
-      SL
-    : IsArray<SL> extends true
-    ? // ensure tuple type is preserved
-      readonly [...(SL extends readonly unknown[] ? SL : never)]
-    : SL extends { readonly [key: string | number | symbol]: unknown }
-    ? // ensure all object properties satisfy `Shape`
-      { readonly [K in keyof SL]: Selector.Shape<SL[K]> }
-    : // nothing to check
-      SL;
+  export type Shape<SL> =
+    IsAnyFunc<SL> extends true
+      ? // functions are allowed, type provided by `Selector`
+        SL
+      : IsArray<SL> extends true
+        ? // ensure tuple type is preserved
+          readonly [...(SL extends readonly unknown[] ? SL : never)]
+        : SL extends { readonly [key: string | number | symbol]: unknown }
+          ? // ensure all object properties satisfy `Shape`
+            { readonly [K in keyof SL]: Selector.Shape<SL[K]> }
+          : // nothing to check
+            SL;
 
   /**
    * Type defining the result type of applying the SL selector type to the T value type.
    * @typeparam T - the source value type
    * @typeparam SL - the selector type
    */
-  export type Result<T, SL> = Selector<T> extends SL
-    ? never
-    : SL extends (...args: any[]) => infer R
-    ? R
-    : SL extends string
-    ? Path.Result<T, SL>
-    : {
-        readonly [K in keyof SL]: Selector.Result<T, SL[K]>;
-      };
+  export type Result<T, SL> =
+    Selector<T> extends SL
+      ? never
+      : SL extends (...args: any[]) => infer R
+        ? R
+        : SL extends string
+          ? Path.Result<T, SL>
+          : {
+              readonly [K in keyof SL]: Selector.Result<T, SL[K]>;
+            };
 }
 
 /**