@rimbu/deep 2.0.1 → 2.0.3

package/dist/bun/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/dist/bun/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/dist/bun/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]>;
+            };
 }
 
 /**

package/dist/bun/tuple.mts

@@ -17,6 +17,10 @@ export namespace Tuple {
    */
   export type Source = readonly unknown[];
 
+  /**
+   * Determines whether the given type `T` is a tuple type.
+   * @typeparam T - the input type
+   */
   export type IsTuple<T> = T extends { length: infer L }
     ? 0 extends L
       ? false
@@ -43,7 +47,7 @@ export namespace Tuple {
   }
 
   /**
-   * Returns the item at the given `index` in the givn `tuple`.
+   * Returns the item at the given `index` in the given `tuple`.
    * @param tuple - the tuple to get the item from
    * @param index - the index in of the tuple element
    * @example
@@ -138,7 +142,7 @@ export namespace Tuple {
    */
   export function append<
     T extends Tuple.Source,
-    V extends readonly [unknown, ...unknown[]]
+    V extends readonly [unknown, ...unknown[]],
   >(tuple: T, ...values: V): readonly [...T, ...V] {
     return [...tuple, ...values];
   }

package/dist/cjs/deep.cjs

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withType = exports.selectAtWith = exports.selectAt = exports.selectWith = exports.matchAtWith = exports.matchAt = exports.matchWith = exports.patchAtWith = exports.patchWith = exports.getAtWith = exports.protect = exports.select = exports.patchAt = exports.getAt = exports.patch = exports.match = void 0;
+exports.select = exports.patchAt = exports.getAt = exports.patch = exports.match = void 0;
+exports.protect = protect;
+exports.getAtWith = getAtWith;
+exports.patchWith = patchWith;
+exports.patchAtWith = patchAtWith;
+exports.matchWith = matchWith;
+exports.matchAt = matchAt;
+exports.matchAtWith = matchAtWith;
+exports.selectWith = selectWith;
+exports.selectAt = selectAt;
+exports.selectAtWith = selectAtWith;
+exports.withType = withType;
 var internal_cjs_1 = require("./internal.cjs");
 var match_cjs_1 = require("./match.cjs");
 Object.defineProperty(exports, "match", { enumerable: true, get: function () { return match_cjs_1.match; } });
@@ -29,7 +40,6 @@ Object.defineProperty(exports, "select", { enumerable: true, get: function () {
 function protect(source) {
     return source;
 }
-exports.protect = protect;
 /**
  * Returns a function that gets the value at the given string `path` inside an object.
  * @typeparam T - the input value type
@@ -46,7 +56,6 @@ exports.protect = protect;
 function getAtWith(path) {
     return function (source) { return internal_cjs_1.Deep.getAt(source, path); };
 }
-exports.getAtWith = getAtWith;
 /**
  * Returns a function that patches a given `source` with the given `patchItems`.
  * @typeparam T - the patch value type
@@ -64,7 +73,6 @@ exports.getAtWith = getAtWith;
 function patchWith(patchItem) {
     return function (source) { return internal_cjs_1.Deep.patch(source, patchItem); };
 }
-exports.patchWith = patchWith;
 /**
  * Returns a function that patches a given `value` with the given `patchItems` at the given `path`.
  * @typeparam T - the patch value type
@@ -84,12 +92,11 @@ exports.patchWith = patchWith;
 function patchAtWith(path, patchItem) {
     return function (source) { return internal_cjs_1.Deep.patchAt(source, path, patchItem); };
 }
-exports.patchAtWith = patchAtWith;
 /**
  * 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' }];
@@ -100,7 +107,6 @@ exports.patchAtWith = patchAtWith;
 function matchWith(matcher) {
     return function (source) { return internal_cjs_1.Deep.match(source, matcher); };
 }
-exports.matchWith = matchWith;
 /**
  * Returns true if the given `value` object matches the given `matcher` at the given `path`, false otherwise.
  * @typeparam T - the input value type
@@ -118,10 +124,9 @@ exports.matchWith = matchWith;
 function matchAt(source, path, matcher) {
     return internal_cjs_1.Deep.match(internal_cjs_1.Deep.getAt(source, path), matcher);
 }
-exports.matchAt = matchAt;
 /**
  * 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
@@ -137,10 +142,9 @@ exports.matchAt = matchAt;
 function matchAtWith(path, matcher) {
     return function (source) { return internal_cjs_1.Deep.matchAt(source, path, matcher); };
 }
-exports.matchAtWith = matchAtWith;
 /**
  * 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.
@@ -154,10 +158,9 @@ exports.matchAtWith = matchAtWith;
 function selectWith(selector) {
     return function (source) { return internal_cjs_1.Deep.select(source, selector); };
 }
-exports.selectWith = selectWith;
 /**
  * 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
@@ -173,10 +176,9 @@ exports.selectWith = selectWith;
 function selectAt(source, path, selector) {
     return internal_cjs_1.Deep.select(internal_cjs_1.Deep.getAt(source, path), selector);
 }
-exports.selectAt = 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
@@ -191,7 +193,6 @@ exports.selectAt = selectAt;
 function selectAtWith(path, selector) {
     return function (source) { return internal_cjs_1.Deep.selectAt(source, path, selector); };
 }
-exports.selectAtWith = selectAtWith;
 /**
  * Returns a curried API with a known target type. This can be useful for using the methods in
  * contexts where the target type can be inferred from the usage.
@@ -207,5 +208,4 @@ exports.selectAtWith = selectAtWith;
 function withType() {
     return internal_cjs_1.Deep;
 }
-exports.withType = withType;
 //# sourceMappingURL=deep.cjs.map

package/dist/cjs/deep.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"deep.cjs","sourceRoot":"","sources":["../../_cjs_prepare/deep.cts"],"names":[],"mappings":";;;AACA,+CAAsC;AAEtC,yCAAgD;AAAvC,kGAAA,KAAK,OAAA;AACd,yCAAgD;AAAvC,kGAAA,KAAK,OAAA;AACd,uCAAuD;AAA9C,iGAAA,KAAK,OAAA;AAAE,mGAAA,OAAO,OAAA;AAEvB,+CAAuD;AAA9C,sGAAA,MAAM,OAAA;AAEf;;;;;;;;;;;;;;GAcG;AACH,SAAgB,OAAO,CAAI,MAAS;IAClC,OAAO,MAAsB,CAAC;AAChC,CAAC;AAFD,0BAEC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,SAAS,CACvB,IAAO;IAEP,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAxB,CAAwB,CAAC;AAC9C,CAAC;AAJD,8BAIC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,SAAS,CACvB,SAAwB;IAExB,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,EAApC,CAAoC,CAAC;AAC1D,CAAC;AAJD,8BAIC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,SAAwD;IAExD,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,SAAgB,CAAC,EAA5C,CAA4C,CAAC;AAClE,CAAC;AALD,kCAKC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,SAAS,CAAI,OAAiB;IAC5C,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAA3B,CAA2B,CAAC;AACjD,CAAC;AAFD,8BAEC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,OAAO,CACrB,MAAS,EACT,IAAO,EACP,OAAiC;IAEjC,OAAO,mBAAI,CAAC,KAAK,CAAC,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAND,0BAMC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,OAAsC;IAEtC,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,OAAc,CAAC,EAA1C,CAA0C,CAAC;AAChE,CAAC;AALD,kCAKC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,UAAU,CACxB,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAA7B,CAA6B,CAAC;AACnD,CAAC;AAJD,gCAIC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,QAAQ,CAKtB,MAAS,EACT,IAAO,EACP,QAA4B;IAE5B,OAAO,mBAAI,CAAC,MAAM,CAAC,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAVD,4BAUC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,YAAY,CAK1B,IAAO,EACP,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,EAArC,CAAqC,CAAC;AAC3D,CAAC;AATD,oCASC;AAkID;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ;IACtB,OAAO,mBAAI,CAAC;AACd,CAAC;AAFD,4BAEC"}
+{"version":3,"file":"deep.cjs","sourceRoot":"","sources":["../../_cjs_prepare/deep.cts"],"names":[],"mappings":";;;AAwBA,0BAEC;AAeD,8BAIC;AAgBD,8BAIC;AAkBD,kCAKC;AAcD,8BAEC;AAgBD,0BAMC;AAiBD,kCAKC;AAeD,gCAIC;AAiBD,4BAUC;AAgBD,oCASC;AA8ID,4BAEC;AA1WD,+CAAsC;AAEtC,yCAAgD;AAAvC,kGAAA,KAAK,OAAA;AACd,yCAAgD;AAAvC,kGAAA,KAAK,OAAA;AACd,uCAAuD;AAA9C,iGAAA,KAAK,OAAA;AAAE,mGAAA,OAAO,OAAA;AAEvB,+CAAuD;AAA9C,sGAAA,MAAM,OAAA;AAEf;;;;;;;;;;;;;;GAcG;AACH,SAAgB,OAAO,CAAI,MAAS;IAClC,OAAO,MAAsB,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,SAAS,CACvB,IAAO;IAEP,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAxB,CAAwB,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,SAAS,CACvB,SAAwB;IAExB,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,EAApC,CAAoC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,SAAwD;IAExD,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,SAAgB,CAAC,EAA5C,CAA4C,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,SAAS,CAAI,OAAiB;IAC5C,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAA3B,CAA2B,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,OAAO,CACrB,MAAS,EACT,IAAO,EACP,OAAiC;IAEjC,OAAO,mBAAI,CAAC,KAAK,CAAC,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,OAAsC;IAEtC,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,OAAc,CAAC,EAA1C,CAA0C,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,UAAU,CACxB,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAA7B,CAA6B,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,QAAQ,CAKtB,MAAS,EACT,IAAO,EACP,QAA4B;IAE5B,OAAO,mBAAI,CAAC,MAAM,CAAC,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,YAAY,CAK1B,IAAO,EACP,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,mBAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,EAArC,CAAqC,CAAC;AAC3D,CAAC;AAkID;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ;IACtB,OAAO,mBAAI,CAAC;AACd,CAAC"}

package/dist/cjs/deep.d.cts

@@ -68,9 +68,9 @@ export declare function patchWith<T, TE extends T = T, TT = T>(patchItem: Patch<
 export declare function patchAtWith<T, P extends Path.Set<T>, TE extends T = T, TT = T>(path: P, patchItem: Patch<Path.Result<TE, P>, Path.Result<TT, P>>): (source: T) => 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' }];
@@ -96,7 +96,7 @@ export declare function matchWith<T>(matcher: Match<T>): (source: T) => boolean;
 export declare function matchAt<T, P extends Path.Get<T>>(source: T, path: P, matcher: Match<Path.Result<T, P>>): boolean;
 /**
  * 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
@@ -112,7 +112,7 @@ export declare function matchAt<T, P extends Path.Get<T>>(source: T, path: P, ma
 export declare function matchAtWith<T, P extends Path.Get<T>, TE extends T = T>(path: P, matcher: Match<Path.Result<T & TE, P>>): (source: T) => boolean;
 /**
  * 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.
@@ -126,7 +126,7 @@ export declare function matchAtWith<T, P extends Path.Get<T>, TE extends T = T>(
 export declare function selectWith<T, SL extends Selector<T>>(selector: Selector.Shape<SL>): (source: T) => Selector.Result<T, SL>;
 /**
  * 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
@@ -142,7 +142,7 @@ export declare function selectWith<T, SL extends Selector<T>>(selector: Selector
 export declare function selectAt<T, P extends Path.Get<T>, SL extends Selector<Path.Result<T, P>>>(source: T, path: P, selector: Selector.Shape<SL>): Selector.Result<Path.Result<T, P>, SL>;
 /**
  * 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

package/dist/cjs/match.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.match = void 0;
+exports.match = match;
 var tslib_1 = require("tslib");
 var base_1 = require("@rimbu/base");
 /**
@@ -17,7 +17,7 @@ var base_1 = require("@rimbu/base");
  * 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
  * ```
@@ -25,7 +25,6 @@ var base_1 = require("@rimbu/base");
 function match(source, matcher, failureLog) {
     return matchEntry(source, source, source, matcher, failureLog);
 }
-exports.match = match;
 /**
  * Match a generic match entry against the given source.
  */