@rimbu/deep 2.0.2 → 2.0.4

package/README.md

@@ -1,122 +1,338 @@
 <p align="center">
-    <img src="https://github.com/rimbu-org/rimbu/raw/main/assets/rimbu_logo.svg" />
+  <img src="https://github.com/rimbu-org/rimbu/raw/main/assets/rimbu_logo.svg" height="96" alt="Rimbu Logo" />
 </p>
 
-[![npm version](https://badge.fury.io/js/@rimbu%2Fdeep.svg)](https://www.npmjs.com/package/@rimbu/deep) [![Deno](https://shield.deno.dev/x/rimbu)](http://deno.land/x/rimbu)
+<div align="center">
 
-![Licence](https://img.shields.io/github/license/rimbu-org/rimbu)
+[![npm version](https://badge.fury.io/js/@rimbu%2Fdeep.svg)](https://www.npmjs.com/package/@rimbu/deep)
+![License](https://img.shields.io/github/license/rimbu-org/rimbu)
+![Types Included](https://img.shields.io/badge/TypeScript-ready-blue)
+![Node](https://img.shields.io/badge/Node-18+-6DA55F?logo=node.js&logoColor=white)
+![Bun](https://img.shields.io/badge/Bun-%23000000.svg)
+![ESM + CJS](https://img.shields.io/badge/modules-ESM%20%2B%20CJS-informational)
 
-# @rimbu/deep
+</div>
 
-Welcome to `@rimbu/deep`! This package offers powerful tools to handle plain JavaScript objects as immutable objects, making your code more robust and maintainable.
+# `@rimbu/deep`
 
-### Key Features:
+**Immutable, type-safe utilities for deeply patching, matching, and selecting from plain JavaScript objects.**
 
-- **Immutable Modification**: Use the [`Patch` object](https://rimbu.org/docs/deep/patch) for convenient and immutable modifications of simple objects.
-- **Pattern Matching**: The [`Match` object](https://rimbu.org/docs/deep/match) allows easy pattern matching on plain objects.
-- **Nested Value Querying**: Easily query nested values with the [`Path` object](https://rimbu.org/docs/deep/path).
-- **Compile-Time Protection**: The [`Immutable` type](https://rimbu.org/docs/deep/immutable) helps create plain objects with compile-time protection against mutation.
-- **Flexible Tuples**: The [`Tuple` type](https://rimbu.org/docs/deep/tuple) provides similar functionality to `as const` but with more flexibility.
+`@rimbu/deep` gives you a set of composable tools – `Patch`, `Match`, `Path`, `Selector`, `Protected`, and `Tuple` –
+to treat plain objects as if they were immutable, deeply typed data structures. You can:
 
-### Documentation
+- **Apply immutable updates** to nested structures using a flexible `Patch` notation.
+- **Express rich match conditions** over objects and arrays using `Match`.
+- **Access nested properties safely** using type‑checked string `Path`s.
+- **Build typed projections** from objects using `Selector` shapes.
+- **Protect values at compile time** from accidental mutation using `Protected`.
+- **Work ergonomically with tuples** and fixed‑length arrays via `Tuple`.
 
-For complete documentation, please visit the [Immutable Objects overview](https://rimbu.org/docs/deep/overview) in the [Rimbu Docs](https://rimbu.org), or directly explore the [Rimbu Deep API Docs](https://rimbu.org/api/rimbu/deep).
+Use it whenever you want the convenience of plain objects, but with **deep type safety**, **immutable semantics**, and
+**refactor‑friendly string paths**.
 
-### Try It Out
+---
 
-Experience `@rimbu/deep` in action! [Try Out Rimbu](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/main?previewwindow=console&view=split&editorsize=65&moduleview=1&module=/src/index.ts) on CodeSandBox.
+## Table of Contents
 
-## Installation
+1. [Why `@rimbu/deep`?](#why-rimbu-deep)
+2. [Feature Highlights](#feature-highlights)
+3. [Quick Start](#quick-start)
+4. [Core Concepts & Types](#core-concepts--types)
+5. [Deep API Helpers](#deep-api-helpers)
+6. [Installation](#installation)
+7. [Ecosystem & Further Reading](#ecosystem--further-reading)
+8. [Contributing](#contributing)
+9. [License](#license)
 
-### Compabitity
+---
 
-- [`Node` ![NodeJS](https://img.shields.io/badge/node.js-6DA55F?logo=node.js&logoColor=white)](https://nodejs.org)
-- [`Deno` ![Deno JS](https://img.shields.io/badge/deno%20js-000000?logo=deno&logoColor=white)](https://deno.com/runtime)
-- [`Bun` ![Bun](https://img.shields.io/badge/Bun-%23000000.svg?logoColor=white)](https://bun.sh/)
-- `Web` ![HTML5](https://img.shields.io/badge/html5-%23E34F26.svg?logoColor=white)
+## Why `@rimbu/deep`?
 
-### Package Managers
+Plain objects are great, but they quickly become painful when:
 
-**Yarn:**
+- You need to **update nested fields immutably** (e.g. in Redux‑style state).
+- You want **type‑safe string paths** like `'a.b.c[0]?.d'` instead of ad‑hoc helpers.
+- You’d like to **pattern‑match** complex structures without a forest of `if`/`switch` checks.
+- You want to **project and reshape data** (e.g. API responses) into well‑typed views.
 
-```sh
-yarn add @rimbu/deep
+`@rimbu/deep` focuses on:
+
+- **Type‑driven paths and selectors** – `Path` and `Selector` are derived from your data types.
+- **Immutable patching** – `Patch` lets you describe updates declaratively and apply them in one go.
+- **Expressive matching** – `Match` supports nested objects, arrays, tuples, and compound predicates.
+- **Compile‑time protection** – `Protected<T>` makes entire object graphs appear readonly to TypeScript.
+
+If you find yourself writing a lot of manual cloning, deep property access, or matcher utilities, `@rimbu/deep` is a
+drop‑in improvement.
+
+---
+
+## Feature Highlights
+
+- **Deep immutable patching** with `patch` and `patchAt`:
+  describe updates using nested objects/arrays and functions instead of manual cloning.
+- **Typed string paths** with `Path.Get` and `Path.Set`:
+  only valid paths for your data type compile.
+- **Structured matching** with `match`:
+  supports nested objects, tuple/array traversal, and compound matchers (`every`, `some`, `none`, `single`).
+- **Selection & projection** with `select` and `Selector`:
+  derive new shapes from existing data using path strings, functions, or nested selector objects.
+- **Compile‑time protection** with `Protected` and `protect`:
+  make values deeply readonly at the type level while still using the underlying runtime value.
+- **Tuple helpers** with `Tuple`:
+  ergonomics around fixed‑length tuples (construction, indexing, updates, etc.).
+
+---
+
+## Quick Start
+
+```ts
+import { Deep } from '@rimbu/deep';
+
+const input = { a: 1, b: { c: true, d: 'a' } } as const;
+
+// Immutable deep patch
+const updated = Deep.patch(input, [{ b: [{ c: (v) => !v }] }]);
+// => { a: 1, b: { c: false, d: 'a' } }
+
+// Type-safe nested get
+const cValue = Deep.getAt(input, 'b.c'); // boolean
+
+// Pattern matching
+if (Deep.match(input, { b: { c: true } })) {
+  // ...
+}
+
+// Selection / projection
+const projected = Deep.select(input, { flag: 'b.c', label: 'b.d' });
+// projected: { flag: boolean; label: string }
 ```
 
-**npm:**
+Try Rimbu (including `@rimbu/deep`) live in the browser using the
+[Rimbu Sandbox on CodeSandbox](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/main?previewwindow=console&view=split&editorsize=65&moduleview=1&module=/src/index.ts).
 
-```sh
-npm install @rimbu/deep
+---
+
+## Core Concepts & Types
+
+### Exported Types & Namespaces
+
+From `@rimbu/deep`’s main entrypoint you have access to:
+
+| Name                            | Description                                                                                            |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `Patch<T, C = T>`               | Type describing allowed patch shapes for a value of type `T`.                                          |
+| `Match<T, C = Partial<T>>`      | Type describing allowed matchers for values of type `T`.                                               |
+| `Path`                          | Namespace containing `Path.Get<T>`, `Path.Set<T>`, and `Path.Result<T, P>` utilities for string paths. |
+| `Selector<T>`                   | Type describing allowed selector shapes for values of type `T`.                                        |
+| `Protected<T>`                  | Deeply readonly/“protected” view of `T` for compile‑time mutation safety.                              |
+| `Tuple<T extends Tuple.Source>` | Tuple wrapper with helper types and functions under the `Tuple` namespace.                             |
+| `Deep`                          | Convenience namespace exposing the main deep utilities (`patch`, `match`, `getAt`, `select`, etc.).    |
+
+See the [Deep overview docs](https://rimbu.org/docs/deep/overview) and
+[API reference](https://rimbu.org/api/rimbu/deep) for the full surface.
+
+### Patching with `patch` and `Patch`
+
+```ts
+import { Deep, type Patch } from '@rimbu/deep';
+
+type State = {
+  count: number;
+  user?: { name: string; active: boolean };
+};
+
+const state: State = { count: 1, user: { name: 'Ada', active: true } };
+
+const patchItem: Patch<State> = [
+  { count: (v) => v + 1 },
+  { user: [{ active: false }] },
+];
+
+const next = Deep.patch(state, patchItem);
+// => { count: 2, user: { name: 'Ada', active: false } }
 ```
 
-**Bun:**
+Patches can be:
 
-```sh
-bun add @rimbu/deep
+- Direct replacement values (`T`).
+- Functions `(current, parent, root) => newValue`.
+- Nested objects / arrays describing which fields or tuple indices to update.
+
+### Matching with `match` and `Match`
+
+```ts
+import { Deep, type Match } from '@rimbu/deep';
+
+type Item = { id: number; tags: string[] };
+
+const items: Item[] = [
+  { id: 1, tags: ['a', 'b'] },
+  { id: 2, tags: ['b'] },
+];
+
+const matcher: Match<Item> = {
+  tags: { someItem: (tag) => tag === 'a' },
+};
+
+const result = items.filter((item) => Deep.match(item, matcher));
+// => only items containing tag 'a'
 ```
 
-### Deno Setup
+`Match` supports:
 
-Create or edit `import_map.json` in your project root:
+- Plain object matchers (`{ a: 1, b: { c: true } }`).
+- Function matchers `(value, parent, root) => boolean | matcher`.
+- Array/tuple matchers and traversal helpers such as `someItem`, `everyItem`, `noneItem`, `singleItem`.
+- Compound matchers like `['every', matcher1, matcher2]`.
 
-```json
-{
-  "imports": {
-    "@rimbu/": "https://deno.land/x/rimbu@x.y.z/"
-  }
-}
+### Paths with `Path.Get`, `Path.Set` and `getAt` / `patchAt`
+
+```ts
+import { Deep, type Path } from '@rimbu/deep';
+
+type Model = { a: { b: { c: number }[] } };
+const value: Model = { a: { b: { c: [5, 6] } } as any };
+
+// Typed paths
+const path: Path.Get<Model> = 'a.b.c[1]?.d'; // compile-time checked
+
+// Reading
+const result = Deep.getAt(value, 'a.b.c[0]'); // number | undefined
+
+// Patching at a path
+const updated = Deep.patchAt(value, 'a.b.c', (arr) => [...arr, 7]);
 ```
 
-_Replace `x.y.z` with the desired version._
+`Path.Result<T, P>` gives you the resulting type at a given path `P` in `T`.
 
-In this way you can use relative imports from Rimbu in your code, like so:
+### Selection with `Selector` and `select`
 
 ```ts
-import { List } from '@rimbu/core/mod.ts';
-import { HashMap } from '@rimbu/hashed/mod.ts';
+import { Deep, type Selector } from '@rimbu/deep';
+
+type Source = {
+  a: { b: number; c: string };
+  meta: { createdAt: string };
+};
+
+const source: Source = {
+  a: { b: 1, c: 'x' },
+  meta: { createdAt: '2024-01-01' },
+};
+
+const selector: Selector<Source> = {
+  value: 'a.b',
+  label: 'a.c',
+  created: 'meta.createdAt',
+};
+
+const view = Deep.select(source, selector);
+// view: { value: number; label: string; created: string }
 ```
 
-Note that for sub-packages, due to conversion limitations it is needed to import the `index.ts` instead of `mod.ts`, like so:
+Selectors can be:
+
+- String paths.
+- Functions `(value: Protected<T>) => any`.
+- Arrays or objects composed of other selectors.
+
+### Protection with `Protected` and `protect`
 
 ```ts
-import { HashMap } from '@rimbu/hashed/map/index.ts';
+import { Deep, type Protected } from '@rimbu/deep';
+
+type Data = { a: { b: number[] } };
+
+const data: Data = { a: { b: [1, 2] } };
+const protectedData: Protected<Data> = Deep.protect(data);
+
+// protectedData.a.b.push(3); // TypeScript error – `b` is readonly
 ```
 
-To run your script (let's assume the entry point is in `src/main.ts`):
+`Protected<T>` is a **type‑level** construct: it does not freeze the value at runtime, but helps prevent
+accidental mutations in your code.
 
-`deno run --import-map import_map.json src/main.ts`
+---
 
-## Usage
+## Deep API Helpers
+
+All top‑level utilities are also available through the `Deep` namespace:
 
 ```ts
-import { patch } from '@rimbu/deep';
-
-console.log(
-  patch({
-    a: 'a',
-    b: { c: 1, d: true },
-  })({
-    a: 'q',
-    b: { c: (v) => v + 1 },
-  })
-);
-// => { a: 'q', b: { c: 2, d: true }}
+import { Deep } from '@rimbu/deep';
+
+// Functional helpers
+const incCount = Deep.patchWith<{ count: number }>([{ count: (v) => v + 1 }]);
+const onlyActive = Deep.matchWith({ active: true });
+const getName = Deep.getAtWith<{ user: { name: string } }>('user.name');
+
+// Typed, curried API with withType
+const s = { a: 1, b: { c: 'a', d: true } };
+const api = Deep.withType<typeof s>();
+
+const next = api.patchWith([{ b: [{ d: (v) => !v }] }])(s);
+// => { a: 1, b: { c: 'a', d: false } }
 ```
 
-## Author
+The `Deep` namespace mirrors the main exports:
 
-Created and maintained by [Arvid Nicolaas](https://github.com/vitoke).
+- `Deep.patch`, `Deep.patchAt`, `Deep.patchWith`, `Deep.patchAtWith`
+- `Deep.match`, `Deep.matchAt`, `Deep.matchWith`, `Deep.matchAtWith`
+- `Deep.getAt`, `Deep.getAtWith`
+- `Deep.select`, `Deep.selectAt`, `Deep.selectWith`, `Deep.selectAtWith`
+- `Deep.withType<T>()` for creating a typed, curried API.
 
-## Contributing
+---
 
-We welcome contributions! Please read our [Contributing guide](https://github.com/rimbu-org/rimbu/blob/main/CONTRIBUTING.md).
+## Installation
 
-## Contributors
+### Node / Bun / npm / Yarn
 
-<img src = "https://contrib.rocks/image?repo=rimbu-org/rimbu"/>
+```sh
+npm install @rimbu/deep
+# or
+yarn add @rimbu/deep
+# or
+bun add @rimbu/deep
+# or
+deno add npm:@rimbu/deep
+```
+
+Then:
+
+```ts
+import { Deep } from '@rimbu/deep/mod.ts';
+```
+
+### Browser / ESM
+
+`@rimbu/deep` ships both **ESM** and **CJS** builds. Use it with any modern bundler
+(Vite, Webpack, esbuild, Bun, etc.) or directly in Node ESM projects.
+
+---
+
+## Ecosystem & Further Reading
+
+- Part of the broader **Rimbu** ecosystem – interoperates with `@rimbu/core`, `@rimbu/collection-types`,
+  and other collection packages.
+- Ideal for modelling immutable application state, selectors, and matchers in complex domains.
+- Learn more in the [Deep overview docs](https://rimbu.org/docs/deep/overview) and the
+  [Deep API reference](https://rimbu.org/api/rimbu/deep).
+
+---
+
+## Contributing
+
+We welcome contributions! See the
+[Contributing guide](https://github.com/rimbu-org/rimbu/blob/main/CONTRIBUTING.md) for details.
+
+<img src="https://contrib.rocks/image?repo=rimbu-org/rimbu" alt="Contributors" />
 
 _Made with [contributors-img](https://contrib.rocks)._
 
+---
+
 ## License
 
-This project is licensed under the MIT License. See the [LICENSE](./LICENSE) for details.
+MIT © Rimbu contributors. See [LICENSE](./LICENSE) for details.

package/dist/bun/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
@@ -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

package/dist/bun/match.mts

@@ -134,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
@@ -194,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
  * ```

package/dist/bun/patch.mts

@@ -110,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/dist/bun/path.mts

@@ -75,7 +75,6 @@ export namespace Path {
      * @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
@@ -129,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
@@ -179,7 +178,7 @@ 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<
@@ -326,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/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

package/dist/cjs/deep.cjs

@@ -94,9 +94,9 @@ function patchAtWith(path, patchItem) {
 }
 /**
  * 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' }];
@@ -126,7 +126,7 @@ function matchAt(source, path, matcher) {
 }
 /**
  * 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
@@ -144,7 +144,7 @@ function matchAtWith(path, matcher) {
 }
 /**
  * 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.
@@ -160,7 +160,7 @@ function selectWith(selector) {
 }
 /**
  * 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
@@ -178,7 +178,7 @@ function selectAt(source, path, selector) {
 }
 /**
  * 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/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

@@ -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
  * ```

package/dist/cjs/match.d.cts

@@ -80,7 +80,7 @@ export declare namespace Match {
      */
     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
@@ -132,7 +132,7 @@ export declare 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
  * ```

package/dist/cjs/patch.cjs

@@ -21,7 +21,7 @@ var base_1 = require("@rimbu/base");
  * 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/dist/cjs/patch.d.cts

@@ -82,7 +82,7 @@ export declare 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/dist/cjs/path.cjs

@@ -33,9 +33,9 @@ var 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/cjs/path.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"path.cjs","sourceRoot":"","sources":["../../_cjs_prepare/path.cts"],"names":[],"mappings":";;;AAiVA,sBA8BC;AAgBD,0BA6CC;;AA3aD,+CAAkD;AAGlD,IAAiB,IAAI,CAqTpB;AArTD,WAAiB,IAAI;IAoSnB;;OAEG;IACU,qBAAgB,GAAG,gBAAgB,CAAC;IAOjD;;;OAGG;IACH,SAAgB,WAAW,CAAC,IAAY;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;IAFe,gBAAW,cAE1B,CAAA;AACH,CAAC,EArTgB,IAAI,oBAAJ,IAAI,QAqTpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,KAAK,CACnB,MAAS,EACT,IAAO;;IAEP,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,kDAAkD;QAClD,OAAO,MAAa,CAAC;IACvB,CAAC;IAED,IAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,sCAAsC;IACtC,IAAI,MAAM,GAAG,MAAa,CAAC;;QAE3B,KAAmB,IAAA,UAAA,iBAAA,KAAK,CAAA,4BAAA,+CAAE,CAAC;YAAtB,IAAM,IAAI,kBAAA;YACb,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACtD,0BAA0B;gBAC1B,SAAS;YACX,CAAC;YAED,IAAI,SAAS,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBAC5C,2FAA2F;gBAC3F,OAAO,SAAgB,CAAC;YAC1B,CAAC;YAED,sCAAsC;YACtC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;;;;;;;;;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,OAAO,CACrB,MAAS,EACT,IAAO,EACP,SAA0D;IAE1D,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,CAAC;IAC9C,CAAC;IAED,IAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,mDAAmD;IACnD,SAAS,eAAe,CAAC,KAAa,EAAE,MAAW;;QACjD,IAAI,KAAK,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;YAC3B,oDAAoD;YACpD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;YACtC,6BAA6B;YAC7B,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,kDAAkD;YAClD,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,gGAAgG;QAChG,IAAM,MAAM;YACV,GAAC,IAAI,IAAG,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;eACjD,CAAC;QAEF,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,wEAAwE;YACxE,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,mEAAmE;QACnE,OAAO,CAAC,MAAM,CAAC,CAAC;IAClB,CAAC;IAED,OAAO,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC"}
+{"version":3,"file":"path.cjs","sourceRoot":"","sources":["../../_cjs_prepare/path.cts"],"names":[],"mappings":";;;AAgVA,sBA8BC;AAgBD,0BA6CC;;AA1aD,+CAAkD;AAGlD,IAAiB,IAAI,CAoTpB;AApTD,WAAiB,IAAI;IAmSnB;;OAEG;IACU,qBAAgB,GAAG,gBAAgB,CAAC;IAOjD;;;OAGG;IACH,SAAgB,WAAW,CAAC,IAAY;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;IAFe,gBAAW,cAE1B,CAAA;AACH,CAAC,EApTgB,IAAI,oBAAJ,IAAI,QAoTpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,KAAK,CACnB,MAAS,EACT,IAAO;;IAEP,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,kDAAkD;QAClD,OAAO,MAAa,CAAC;IACvB,CAAC;IAED,IAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,sCAAsC;IACtC,IAAI,MAAM,GAAG,MAAa,CAAC;;QAE3B,KAAmB,IAAA,UAAA,iBAAA,KAAK,CAAA,4BAAA,+CAAE,CAAC;YAAtB,IAAM,IAAI,kBAAA;YACb,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACtD,0BAA0B;gBAC1B,SAAS;YACX,CAAC;YAED,IAAI,SAAS,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBAC5C,2FAA2F;gBAC3F,OAAO,SAAgB,CAAC;YAC1B,CAAC;YAED,sCAAsC;YACtC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;;;;;;;;;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,OAAO,CACrB,MAAS,EACT,IAAO,EACP,SAA0D;IAE1D,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,CAAC;IAC9C,CAAC;IAED,IAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,mDAAmD;IACnD,SAAS,eAAe,CAAC,KAAa,EAAE,MAAW;;QACjD,IAAI,KAAK,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;YAC3B,oDAAoD;YACpD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;YACtC,6BAA6B;YAC7B,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,kDAAkD;YAClD,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,gGAAgG;QAChG,IAAM,MAAM;YACV,GAAC,IAAI,IAAG,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;eACjD,CAAC;QAEF,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,wEAAwE;YACxE,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,mEAAmE;QACnE,OAAO,CAAC,MAAM,CAAC,CAAC;IAClB,CAAC;IAED,OAAO,mBAAI,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC"}

package/dist/cjs/path.d.cts

@@ -44,7 +44,6 @@ export declare namespace Path {
          * @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
          */
         type NonOptional<T, Write extends boolean, Maybe extends boolean> = Tuple.IsTuple<T> extends true ? Path.Internal.Tup<T, Write, Maybe> : T extends readonly any[] ? Write extends false ? Path.Internal.Arr<T> : never : IsPlainObj<T> extends true ? Path.Internal.Obj<T, Write, Maybe> : never;
         /**
@@ -72,7 +71,7 @@ export declare namespace Path {
             [K in keyof T]: `${K & string}${Path.Internal.Generic<T[K], Write, Write extends true ? false : Path.Internal.IsOptional<T[K], true, Maybe>>}`;
         }[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
@@ -93,7 +92,7 @@ export declare namespace Path {
         type MaybeValue<T, Maybe extends boolean> = Maybe extends true ? T | undefined : T;
         /**
          * 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
          */
         type AppendIfNotEmpty<A extends string[], T extends string> = T extends '' ? A : [
@@ -172,9 +171,9 @@ export declare 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/cjs/tuple.cjs

@@ -23,7 +23,7 @@ var Tuple;
     }
     Tuple.of = of;
     /**
-     * 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

package/dist/cjs/tuple.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.cjs","sourceRoot":"","sources":["../../_cjs_prepare/tuple.cts"],"names":[],"mappings":";;;;AAAA,oCAAkC;AAQlC,IAAiB,KAAK,CA4LrB;AA5LD,WAAiB,KAAK;IAuBpB;;;;;;;;OAQG;IACH,SAAgB,EAAE;QAAiC,gBAAY;aAAZ,UAAY,EAAZ,qBAAY,EAAZ,IAAY;YAAZ,2BAAY;;QAC7D,OAAO,MAAa,CAAC;IACvB,CAAC;IAFe,QAAE,KAEjB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ;QAER,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IALe,cAAQ,WAKvB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,KAAK,CAAyB,KAAQ;QACpD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,WAAK,QAEpB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,MAAM,CAAyB,KAAQ;QACrD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,YAAM,SAErB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAAyB;QAEzB,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAQ,CAAC;IACxC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ,EACR,OAAqB;QAErB,OAAO,UAAG,CAAC,MAAM,CAAC,KAAK,EAAE,KAAe,EAAE,OAAO,CAAM,CAAC;IAC1D,CAAC;IANe,cAAQ,WAMvB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,MAAM,CAGpB,KAAQ;QAAE,gBAAY;aAAZ,UAAY,EAAZ,qBAAY,EAAZ,IAAY;YAAZ,+BAAY;;QACtB,sEAAW,KAAK,0BAAK,MAAM,UAAE;IAC/B,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,MAAM,CACpB,MAAU,EACV,MAAU;QAEV,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAQ,CAAC;IACtC,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,UAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,UAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;AACH,CAAC,EA5LgB,KAAK,qBAAL,KAAK,QA4LrB"}
+{"version":3,"file":"tuple.cjs","sourceRoot":"","sources":["../../_cjs_prepare/tuple.cts"],"names":[],"mappings":";;;;AAAA,oCAAkC;AAQlC,IAAiB,KAAK,CAgMrB;AAhMD,WAAiB,KAAK;IA2BpB;;;;;;;;OAQG;IACH,SAAgB,EAAE;QAAiC,gBAAY;aAAZ,UAAY,EAAZ,qBAAY,EAAZ,IAAY;YAAZ,2BAAY;;QAC7D,OAAO,MAAa,CAAC;IACvB,CAAC;IAFe,QAAE,KAEjB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ;QAER,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IALe,cAAQ,WAKvB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,KAAK,CAAyB,KAAQ;QACpD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,WAAK,QAEpB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,MAAM,CAAyB,KAAQ;QACrD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,YAAM,SAErB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAAyB;QAEzB,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAQ,CAAC;IACxC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ,EACR,OAAqB;QAErB,OAAO,UAAG,CAAC,MAAM,CAAC,KAAK,EAAE,KAAe,EAAE,OAAO,CAAM,CAAC;IAC1D,CAAC;IANe,cAAQ,WAMvB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,MAAM,CAGpB,KAAQ;QAAE,gBAAY;aAAZ,UAAY,EAAZ,qBAAY,EAAZ,IAAY;YAAZ,+BAAY;;QACtB,sEAAW,KAAK,0BAAK,MAAM,UAAE;IAC/B,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,MAAM,CACpB,MAAU,EACV,MAAU;QAEV,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAQ,CAAC;IACtC,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,UAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,UAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;AACH,CAAC,EAhMgB,KAAK,qBAAL,KAAK,QAgMrB"}

package/dist/cjs/tuple.d.cts

@@ -12,6 +12,10 @@ export declare namespace Tuple {
      * A readonly array that can serve as a source for a Tuple.
      */
     type Source = readonly unknown[];
+    /**
+     * Determines whether the given type `T` is a tuple type.
+     * @typeparam T - the input type
+     */
     type IsTuple<T> = T extends {
         length: infer L;
     } ? 0 extends L ? false : true : false;
@@ -33,7 +37,7 @@ export declare namespace Tuple {
      */
     function of<T extends Tuple.NonEmptySource>(...values: T): Tuple<T>;
     /**
-     * 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

package/dist/esm/deep.d.mts

@@ -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/esm/deep.mjs

@@ -75,9 +75,9 @@ export function patchAtWith(path, patchItem) {
 }
 /**
  * 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' }];
@@ -107,7 +107,7 @@ export function matchAt(source, path, matcher) {
 }
 /**
  * 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
@@ -125,7 +125,7 @@ export function matchAtWith(path, matcher) {
 }
 /**
  * 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.
@@ -141,7 +141,7 @@ export function selectWith(selector) {
 }
 /**
  * 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
@@ -159,7 +159,7 @@ export function selectAt(source, path, selector) {
 }
 /**
  * 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/esm/match.d.mts

@@ -80,7 +80,7 @@ export declare namespace Match {
      */
     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
@@ -132,7 +132,7 @@ export declare 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
  * ```

package/dist/esm/match.mjs

@@ -13,7 +13,7 @@ import { isPlainObj, } from '@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
  * ```

package/dist/esm/patch.d.mts

@@ -82,7 +82,7 @@ export declare 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/dist/esm/patch.mjs

@@ -17,7 +17,7 @@ import { isPlainObj, } from '@rimbu/base';
  * 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/dist/esm/path.d.mts

@@ -44,7 +44,6 @@ export declare namespace Path {
          * @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
          */
         type NonOptional<T, Write extends boolean, Maybe extends boolean> = Tuple.IsTuple<T> extends true ? Path.Internal.Tup<T, Write, Maybe> : T extends readonly any[] ? Write extends false ? Path.Internal.Arr<T> : never : IsPlainObj<T> extends true ? Path.Internal.Obj<T, Write, Maybe> : never;
         /**
@@ -72,7 +71,7 @@ export declare namespace Path {
             [K in keyof T]: `${K & string}${Path.Internal.Generic<T[K], Write, Write extends true ? false : Path.Internal.IsOptional<T[K], true, Maybe>>}`;
         }[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
@@ -93,7 +92,7 @@ export declare namespace Path {
         type MaybeValue<T, Maybe extends boolean> = Maybe extends true ? T | undefined : T;
         /**
          * 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
          */
         type AppendIfNotEmpty<A extends string[], T extends string> = T extends '' ? A : [
@@ -172,9 +171,9 @@ export declare 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/esm/path.mjs

@@ -27,9 +27,9 @@ export var 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/esm/path.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"path.mjs","sourceRoot":"","sources":["../../src/path.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAc,MAAM,gBAAgB,CAAC;AAGlD,MAAM,KAAW,IAAI,CAqTpB;AArTD,WAAiB,IAAI;IAoSnB;;OAEG;IACU,qBAAgB,GAAG,gBAAgB,CAAC;IAOjD;;;OAGG;IACH,SAAgB,WAAW,CAAC,IAAY;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;IAFe,gBAAW,cAE1B,CAAA;AACH,CAAC,EArTgB,IAAI,KAAJ,IAAI,QAqTpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,KAAK,CACnB,MAAS,EACT,IAAO;IAEP,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,kDAAkD;QAClD,OAAO,MAAa,CAAC;IACvB,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,sCAAsC;IACtC,IAAI,MAAM,GAAG,MAAa,CAAC;IAE3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACtD,0BAA0B;YAC1B,SAAS;QACX,CAAC;QAED,IAAI,SAAS,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YAC5C,2FAA2F;YAC3F,OAAO,SAAgB,CAAC;QAC1B,CAAC;QAED,sCAAsC;QACtC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACrB,MAAS,EACT,IAAO,EACP,SAA0D;IAE1D,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,CAAC;IAC9C,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,mDAAmD;IACnD,SAAS,eAAe,CAAC,KAAa,EAAE,MAAW;QACjD,IAAI,KAAK,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;YAC3B,oDAAoD;YACpD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;YACtC,6BAA6B;YAC7B,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,kDAAkD;YAClD,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,gGAAgG;QAChG,MAAM,MAAM,GAAG;YACb,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;SACjD,CAAC;QAEF,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,wEAAwE;YACxE,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,mEAAmE;QACnE,OAAO,CAAC,MAAM,CAAC,CAAC;IAClB,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC"}
+{"version":3,"file":"path.mjs","sourceRoot":"","sources":["../../src/path.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAc,MAAM,gBAAgB,CAAC;AAGlD,MAAM,KAAW,IAAI,CAoTpB;AApTD,WAAiB,IAAI;IAmSnB;;OAEG;IACU,qBAAgB,GAAG,gBAAgB,CAAC;IAOjD;;;OAGG;IACH,SAAgB,WAAW,CAAC,IAAY;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;IAFe,gBAAW,cAE1B,CAAA;AACH,CAAC,EApTgB,IAAI,KAAJ,IAAI,QAoTpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,KAAK,CACnB,MAAS,EACT,IAAO;IAEP,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,kDAAkD;QAClD,OAAO,MAAa,CAAC;IACvB,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,sCAAsC;IACtC,IAAI,MAAM,GAAG,MAAa,CAAC;IAE3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACtD,0BAA0B;YAC1B,SAAS;QACX,CAAC;QAED,IAAI,SAAS,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YAC5C,2FAA2F;YAC3F,OAAO,SAAgB,CAAC;QAC1B,CAAC;QAED,sCAAsC;QACtC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACrB,MAAS,EACT,IAAO,EACP,SAA0D;IAE1D,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,CAAC;IAC9C,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAErC,mDAAmD;IACnD,SAAS,eAAe,CAAC,KAAa,EAAE,MAAW;QACjD,IAAI,KAAK,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;YAC3B,oDAAoD;YACpD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;YACtC,6BAA6B;YAC7B,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,kDAAkD;YAClD,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC;QAED,gGAAgG;QAChG,MAAM,MAAM,GAAG;YACb,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;SACjD,CAAC;QAEF,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,wEAAwE;YACxE,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,mEAAmE;QACnE,OAAO,CAAC,MAAM,CAAC,CAAC;IAClB,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC"}

package/dist/esm/tuple.d.mts

@@ -12,6 +12,10 @@ export declare namespace Tuple {
      * A readonly array that can serve as a source for a Tuple.
      */
     type Source = readonly unknown[];
+    /**
+     * Determines whether the given type `T` is a tuple type.
+     * @typeparam T - the input type
+     */
     type IsTuple<T> = T extends {
         length: infer L;
     } ? 0 extends L ? false : true : false;
@@ -33,7 +37,7 @@ export declare namespace Tuple {
      */
     function of<T extends Tuple.NonEmptySource>(...values: T): Tuple<T>;
     /**
-     * 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

package/dist/esm/tuple.mjs

@@ -15,7 +15,7 @@ export var Tuple;
     }
     Tuple.of = of;
     /**
-     * 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

package/dist/esm/tuple.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.mjs","sourceRoot":"","sources":["../../src/tuple.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAQlC,MAAM,KAAW,KAAK,CA4LrB;AA5LD,WAAiB,KAAK;IAuBpB;;;;;;;;OAQG;IACH,SAAgB,EAAE,CAAiC,GAAG,MAAS;QAC7D,OAAO,MAAa,CAAC;IACvB,CAAC;IAFe,QAAE,KAEjB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ;QAER,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IALe,cAAQ,WAKvB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,KAAK,CAAyB,KAAQ;QACpD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,WAAK,QAEpB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,MAAM,CAAyB,KAAQ;QACrD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,YAAM,SAErB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAAyB;QAEzB,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAQ,CAAC;IACxC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ,EACR,OAAqB;QAErB,OAAO,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,KAAe,EAAE,OAAO,CAAM,CAAC;IAC1D,CAAC;IANe,cAAQ,WAMvB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,MAAM,CAGpB,KAAQ,EAAE,GAAG,MAAS;QACtB,OAAO,CAAC,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC;IAC/B,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,MAAM,CACpB,MAAU,EACV,MAAU;QAEV,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAQ,CAAC;IACtC,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;AACH,CAAC,EA5LgB,KAAK,KAAL,KAAK,QA4LrB"}
+{"version":3,"file":"tuple.mjs","sourceRoot":"","sources":["../../src/tuple.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAQlC,MAAM,KAAW,KAAK,CAgMrB;AAhMD,WAAiB,KAAK;IA2BpB;;;;;;;;OAQG;IACH,SAAgB,EAAE,CAAiC,GAAG,MAAS;QAC7D,OAAO,MAAa,CAAC;IACvB,CAAC;IAFe,QAAE,KAEjB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ;QAER,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IALe,cAAQ,WAKvB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,KAAK,CAAyB,KAAQ;QACpD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,WAAK,QAEpB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,MAAM,CAAyB,KAAQ;QACrD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAFe,YAAM,SAErB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAAyB;QAEzB,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAQ,CAAC;IACxC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,QAAQ,CACtB,KAAQ,EACR,KAAQ,EACR,OAAqB;QAErB,OAAO,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,KAAe,EAAE,OAAO,CAAM,CAAC;IAC1D,CAAC;IANe,cAAQ,WAMvB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,MAAM,CAGpB,KAAQ,EAAE,GAAG,MAAS;QACtB,OAAO,CAAC,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC;IAC/B,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,MAAM,CACpB,MAAU,EACV,MAAU;QAEV,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAQ,CAAC;IACtC,CAAC;IALe,YAAM,SAKrB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,IAAI,CAClB,KAA+B;QAE/B,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAQ,CAAC;IAChC,CAAC;IAJe,UAAI,OAInB,CAAA;AACH,CAAC,EAhMgB,KAAK,KAAL,KAAK,QAgMrB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/deep",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Tools to use handle plain JS objects as immutable objects",
   "keywords": [
     "immutable",
@@ -53,17 +53,12 @@
   ],
   "scripts": {
     "build": "yarn clean && yarn bundle",
-    "build:deno": "yarn bundle:deno-prepare && yarn bundle:deno-convert && yarn bundle:deno-move && yarn bundle:deno-clean",
     "bundle": "yarn bundle:cjs && yarn bundle:esm && yarn bundle:bun",
     "bundle:bun": "node ../../config/bunnify.mjs -mode bun",
     "bundle:cjs": "yarn bundle:cjs-prepare && yarn bundle:cjs-build && yarn bundle:cjs-clean",
     "bundle:cjs-prepare": "node ../../config/bunnify.mjs -mode cjs",
     "bundle:cjs-build": "tsc -p tsconfig.cjs.json",
     "bundle:cjs-clean": "rimraf _cjs_prepare",
-    "bundle:deno-prepare": "node ../../config/prepare-denoify.mjs",
-    "bundle:deno-convert": "denoify --src _deno_prepare/src",
-    "bundle:deno-move": "rimraf ../../deno_dist/deep && mv deno_dist ../../deno_dist/deep",
-    "bundle:deno-clean": "rimraf _deno_prepare",
     "bundle:esm": "tsc --p tsconfig.esm.json",
     "clean": "rimraf dist",
     "extract-api": "tsx ../../config/api-extractor.ts config/api-extractor.main.json",
@@ -78,12 +73,12 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@rimbu/base": "^2.0.2",
-    "@rimbu/common": "^2.0.2",
-    "tslib": "^2.6.2"
+    "@rimbu/base": "^2.0.4",
+    "@rimbu/common": "^2.0.4",
+    "tslib": "^2.8.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f18ddf964507dbd10790da3cd4deef8f455a178e"
+  "gitHead": "bc6bc82af86461c423ba459d6d9809efdd5ffd61"
 }

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
@@ -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

package/src/match.mts

@@ -134,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
@@ -194,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
  * ```

package/src/patch.mts

@@ -110,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

@@ -75,7 +75,6 @@ export namespace Path {
      * @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
@@ -129,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
@@ -179,7 +178,7 @@ 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<
@@ -326,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/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