@rimbu/base 2.0.3 → 2.0.5

package/README.md

@@ -6,7 +6,6 @@
 ![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)
-![Deno](https://shield.deno.dev/x/rimbu)
 ![Bun](https://img.shields.io/badge/Bun-%23000000.svg)
 ![ESM + CJS](https://img.shields.io/badge/modules-ESM%20%2B%20CJS-informational)
 
@@ -77,10 +76,10 @@ import { Arr } from '@rimbu/base';
 const base = [1, 2, 3];
 
 // Pure modification: only clones when the value actually changes
-const incremented = Arr.mod(base, 1, v => v + 1); // [1, 3, 3]
+const incremented = Arr.mod(base, 1, (v) => v + 1); // [1, 3, 3]
 
 // Structural no-op returns original reference for efficiency
-const same = Arr.mod(base, 5, v => v); // index out of range → original
+const same = Arr.mod(base, 5, (v) => v); // index out of range → original
 
 // Append without mutating
 const appended = Arr.append(incremented, 4); // [1, 3, 3, 4]
@@ -97,22 +96,22 @@ console.log(base); // [1, 2, 3]
 
 All functions accept a `readonly T[]` input and return either the original array (when unchanged) or an optimized clone.
 
-| Function | Purpose |
-| -------- | ------- |
-| `append` | Add element at end (non-empty array optimization). |
-| `prepend` | Add element at start efficiently. |
-| `concat` | Smart concat – reuses original when one side empty. |
-| `reverse` | Fast reversed copy (range slice optional). |
-| `forEach` | Controlled traversal with optional reverse + halt state. |
-| `map` / `reverseMap` | Indexed transformation forward or backward. |
-| `last` | O(1) last element access (uses `.at(-1)` when available). |
-| `update` | Apply `Update<T>` logic at index (no-op preserved). |
-| `mod` | Lightweight element modification via `(value)=>value'`. |
-| `insert` | Insert at index. |
-| `tail` / `init` | Drop first / last element. |
-| `splice` | Immutable variant of native splice. |
-| `copySparse` | Preserve holes in sparse arrays. |
-| `mapSparse` | Transform only present indices, keeping sparsity. |
+| Function             | Purpose                                                   |
+| -------------------- | --------------------------------------------------------- |
+| `append`             | Add element at end (non-empty array optimization).        |
+| `prepend`            | Add element at start efficiently.                         |
+| `concat`             | Smart concat – reuses original when one side empty.       |
+| `reverse`            | Fast reversed copy (range slice optional).                |
+| `forEach`            | Controlled traversal with optional reverse + halt state.  |
+| `map` / `reverseMap` | Indexed transformation forward or backward.               |
+| `last`               | O(1) last element access (uses `.at(-1)` when available). |
+| `update`             | Apply `Update<T>` logic at index (no-op preserved).       |
+| `mod`                | Lightweight element modification via `(value)=>value'`.   |
+| `insert`             | Insert at index.                                          |
+| `tail` / `init`      | Drop first / last element.                                |
+| `splice`             | Immutable variant of native splice.                       |
+| `copySparse`         | Preserve holes in sparse arrays.                          |
+| `mapSparse`          | Transform only present indices, keeping sparsity.         |
 
 Design details:
 
@@ -132,7 +131,9 @@ Entry.first(pair); // 'age'
 Entry.second(pair); // 42
 
 // Shared sentinel for internal tagging / identity
-if (someValue === Token) { /* special branch */ }
+if (someValue === Token) {
+  /* special branch */
+}
 ```
 
 ---
@@ -141,14 +142,14 @@ if (someValue === Token) { /* special branch */ }
 
 Compile-time predicates for discriminating plain data objects from complex / functional structures:
 
-| Type | Description |
-| ---- | ----------- |
-| `IsPlainObj<T>` | True only for non-iterable, non-function object types without function properties. |
-| `PlainObj<T>` | Narrows to T if `IsPlainObj<T>`; otherwise `never`. |
-| `IsArray<T>` | Resolves to `true` if T is a (readonly) array type. |
-| `IsAny<T>` | Detects `any`. |
-| `isPlainObj(obj)` | Runtime guard for plain data objects. |
-| `isIterable(obj)` | Runtime guard for `Iterable`. |
+| Type              | Description                                                                        |
+| ----------------- | ---------------------------------------------------------------------------------- |
+| `IsPlainObj<T>`   | True only for non-iterable, non-function object types without function properties. |
+| `PlainObj<T>`     | Narrows to T if `IsPlainObj<T>`; otherwise `never`.                                |
+| `IsArray<T>`      | Resolves to `true` if T is a (readonly) array type.                                |
+| `IsAny<T>`        | Detects `any`.                                                                     |
+| `isPlainObj(obj)` | Runtime guard for plain data objects.                                              |
+| `isIterable(obj)` | Runtime guard for `Iterable`.                                                      |
 
 Use these when building APIs that must reject iterables or functions while retaining strong type discrimination.
 
@@ -158,12 +159,12 @@ Use these when building APIs that must reject iterables or functions while retai
 
 Structured error classes provide meaningful failure contexts internally and externally:
 
-| Error Class | Trigger Scenario |
-| ----------- | ---------------- |
-| `EmptyCollectionAssumedNonEmptyError` | An operation expected a non-empty collection. |
-| `ModifiedBuilderWhileLoopingOverItError` | Mutating a builder mid-iteration. |
-| `InvalidStateError` | Internal invariant breach (should not happen). |
-| `InvalidUsageError` | Consumer used an API incorrectly. |
+| Error Class                              | Trigger Scenario                               |
+| ---------------------------------------- | ---------------------------------------------- |
+| `EmptyCollectionAssumedNonEmptyError`    | An operation expected a non-empty collection.  |
+| `ModifiedBuilderWhileLoopingOverItError` | Mutating a builder mid-iteration.              |
+| `InvalidStateError`                      | Internal invariant breach (should not happen). |
+| `InvalidUsageError`                      | Consumer used an API incorrectly.              |
 
 Helper throw functions exist for concise signaling (`throwInvalidStateError()`, etc.). Prefer them for consistency.
 
@@ -174,7 +175,6 @@ Helper throw functions exist for concise signaling (`throwInvalidStateError()`,
 ### 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)
 
@@ -198,37 +198,12 @@ npm install @rimbu/base
 bun add @rimbu/base
 ```
 
-### Deno Setup
-
-Create or edit `import_map.json` in your project root:
-
-```json
-{
-  "imports": {
-    "@rimbu/": "https://deno.land/x/rimbu@x.y.z/"
-  }
-}
-```
-
-_Replace `x.y.z` with the desired version._
+**Deno:**
 
-In this way you can use relative imports from Rimbu in your code, like so:
-
-```ts
-import { List } from '@rimbu/core/mod.ts';
-import { HashMap } from '@rimbu/hashed/mod.ts';
-```
-
-Note that for sub-packages, due to conversion limitations it is needed to import the `index.ts` instead of `mod.ts`, like so:
-
-```ts
-import { HashMap } from '@rimbu/hashed/map/index.ts';
+```sh
+deno add npm:@rimbu/base
 ```
 
-To run your script (let's assume the entry point is in `src/main.ts`):
-
-`deno run --import-map import_map.json src/main.ts`
-
 ## Usage
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/base",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Utilities to implement Rimbu collections",
   "keywords": [
     "array",
@@ -32,7 +32,6 @@
   "types": "./dist/cjs/index.d.cts",
   "exports": {
     ".": {
-      "bun": "./dist/bun/main/index.mts",
       "import": {
         "types": "./dist/esm/index.d.mts",
         "default": "./dist/esm/index.mjs"
@@ -49,17 +48,11 @@
   ],
   "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": "yarn bundle:cjs && yarn bundle:esm",
     "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/base && mv deno_dist ../../deno_dist/base",
-    "bundle:deno-clean": "rimraf _deno_prepare",
     "bundle:esm": "tsc --p tsconfig.esm.json",
     "clean": "rimraf dist",
     "format": "yarn format:base --write",
@@ -73,10 +66,10 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@rimbu/common": "^2.0.3"
+    "@rimbu/common": "^2.0.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1c35dbdd9ce13aeba818b41eb20bab1e826b3e16"
+  "gitHead": "15fd7c44f369838a47d42532bcd9771d65d6f660"
 }

package/dist/bun/arr.mts

@@ -1,477 +0,0 @@
-import { TraverseState, Update, type ArrayNonEmpty } from '@rimbu/common';
-
-/**
- * Internal helper that appends a value using the modern immutable `toSpliced` API.
- * @internal
- * @typeparam T - the array element type
- * @param array - the source array (not mutated)
- * @param value - the value to append
- * @returns a new non-empty array with the value at the end
- */
-export function _appendNew<T>(array: readonly T[], value: T): ArrayNonEmpty<T> {
-  return array.toSpliced(array.length, 0, value) as ArrayNonEmpty<T>;
-}
-
-/**
- * Internal helper that appends a value by cloning and pushing (legacy fallback).
- * @internal
- * @typeparam T - the array element type
- * @param array - the source array (not mutated)
- * @param value - the value to append
- * @returns a new non-empty array with the value at the end
- */
-export function _appendOld<T>(array: readonly T[], value: T): ArrayNonEmpty<T> {
-  const clone = array.slice();
-  clone.push(value);
-  return clone as ArrayNonEmpty<T>;
-}
-
-/**
- * Returns a copy of the array with the given value appended.
- * Chooses an implementation depending on environment capabilities.
- * @typeparam T - the array element type
- * @param array - the source array (not mutated)
- * @param value - the value to append
- * @returns a new array with the value at the end
- */
-export const append = `toSpliced` in Array.prototype ? _appendNew : _appendOld;
-
-/**
- * Returns the concatenation of two arrays, reusing an input array when the other is empty.
- * @typeparam T - the array element type
- * @param first - the first array
- * @param second - the second array
- * @returns a new array containing all elements of both arrays (or one of the originals if the other is empty)
- */
-export function concat<T>(
-  first: readonly T[],
-  second: readonly T[]
-): readonly T[] {
-  if (first.length === 0) return second;
-  if (second.length === 0) return first;
-  return first.concat(second);
-}
-
-/**
- * Internal helper to create a reversed copy using modern `toReversed` with optional slicing.
- * @internal
- */
-export function _reverseNew<T>(
-  array: readonly T[],
-  start?: number,
-  end?: number
-): T[] {
-  const source =
-    undefined !== start || undefined !== end
-      ? array.slice(start ?? 0, (end ?? array.length - 1) + 1)
-      : array;
-
-  return source.toReversed();
-}
-
-/**
- * Internal helper to create a reversed copy using manual iteration (legacy fallback).
- * @internal
- */
-export function _reverseOld<T>(
-  array: readonly T[],
-  start?: number,
-  end?: number
-): T[] {
-  const _start = start ?? 0;
-  const _end = end ?? array.length - 1;
-  const length = _end - _start + 1;
-  const res = [] as T[];
-
-  let arrayIndex = _start - 1;
-  let resIndex = length - 1;
-
-  while (++arrayIndex <= _end) res[resIndex--] = array[arrayIndex];
-
-  return res;
-}
-
-/**
- * Returns a copy of the array (or a slice) with elements in reversed order.
- * @typeparam T - array element type
- * @param array - the source array
- * @param start - optional start index (inclusive)
- * @param end - optional end index (inclusive)
- */
-export const reverse =
-  'toReversed' in Array.prototype ? _reverseNew : _reverseOld;
-
-/**
- * Performs the given function for each element of the array, optionally in reverse order.
- * Halting is supported through the provided `TraverseState`.
- * @typeparam T - element type
- * @param array - the source array
- * @param f - callback receiving (value, sequential index, halt)
- * @param state - traversal state (created if omitted)
- * @param reversed - whether to traverse in reverse order
- */
-export function forEach<T>(
-  array: readonly T[],
-  f: (value: T, index: number, halt: () => void) => void,
-  state: TraverseState = TraverseState(),
-  reversed = false
-): void {
-  if (state.halted) return;
-
-  const { halt } = state;
-
-  if (reversed) {
-    let i = array.length;
-
-    while (!state.halted && --i >= 0) {
-      f(array[i], state.nextIndex(), halt);
-    }
-  } else {
-    const length = array.length;
-    let i = -1;
-
-    while (!state.halted && ++i < length) {
-      f(array[i], state.nextIndex(), halt);
-    }
-  }
-}
-
-/**
- * Returns a copy of the array where the given function is applied to each element.
- * Supports an index offset useful for composed traversals.
- * @typeparam T - source element type
- * @typeparam R - result element type
- * @param array - the source array
- * @param f - the mapping function
- * @param indexOffset - optional start index value passed to `f`
- */
-export function map<T, R>(
-  array: readonly T[],
-  f: (value: T, index: number) => R,
-  indexOffset = 0
-): R[] {
-  if (indexOffset === 0) {
-    // without offset, can use standard array map
-    return array.map(f);
-  }
-
-  const result: R[] = [];
-
-  let index = indexOffset;
-  let i = -1;
-  const length = array.length;
-  while (++i < length) {
-    result[i] = f(array[i], index++);
-  }
-  return result;
-}
-
-/**
- * Returns a copy of the array where the given function is applied to each element in reverse order.
- * @typeparam T - source element type
- * @typeparam R - result element type
- * @param array - the source array
- * @param f - the mapping function
- * @param indexOffset - optional index offset passed to `f`
- */
-export function reverseMap<T, R>(
-  array: readonly T[],
-  f: (value: T, index: number) => R,
-  indexOffset = 0
-): R[] {
-  const result: R[] = [];
-
-  let index = indexOffset;
-  let arrayIndex = array.length;
-  let resultIndex = 0;
-  while (--arrayIndex >= 0)
-    result[resultIndex++] = f(array[arrayIndex], index++);
-
-  return result;
-}
-
-/**
- * Internal helper to prepend a value using `toSpliced`.
- * @internal
- */
-export function _prependNew<T>(
-  array: readonly T[],
-  value: T
-): ArrayNonEmpty<T> {
-  return array.toSpliced(0, 0, value) as ArrayNonEmpty<T>;
-}
-
-/**
- * Internal helper to prepend a value using legacy cloning.
- * @internal
- */
-export function _prependOld<T>(
-  array: readonly T[],
-  value: T
-): ArrayNonEmpty<T> {
-  const clone = array.slice();
-  clone.unshift(value);
-  return clone as ArrayNonEmpty<T>;
-}
-
-/**
- * Returns a copy of the array with the given value inserted at the start.
- * @typeparam T - element type
- * @param array - the source array
- * @param value - value to insert at index 0
- */
-export const prepend =
-  `toSpliced` in Array.prototype ? _prependNew : _prependOld;
-
-/**
- * Internal helper to obtain the last element using modern `at`.
- * @internal
- */
-export function _lastNew<T>(arr: readonly T[]): T {
-  return arr.at(-1)!;
-}
-
-/**
- * Internal helper to obtain the last element using index arithmetic.
- * @internal
- */
-export function _lastOld<T>(arr: readonly T[]): T {
-  return arr[arr.length - 1];
-}
-
-/**
- * Returns the last element of the array.
- * @typeparam T - element type
- * @param arr - the array
- */
-export const last = `at` in Array.prototype ? _lastNew : _lastOld;
-
-/**
- * Internal helper implementing an immutable index update via `with`.
- * @internal
- */
-export function _updateNew<T>(
-  arr: readonly T[],
-  index: number,
-  updater: Update<T>
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-  const curValue = arr[index];
-
-  const newValue = Update(curValue, updater);
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  return arr.with(index, newValue);
-}
-
-/**
- * Internal helper implementing an immutable index update via cloning.
- * @internal
- */
-export function _updateOld<T>(
-  arr: readonly T[],
-  index: number,
-  updater: Update<T>
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-  const curValue = arr[index];
-
-  const newValue = Update(curValue, updater);
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  const newArr = arr.slice();
-  newArr[index] = newValue;
-  return newArr;
-}
-
-/**
- * Returns a copy of the array where the element at the given index is replaced using the provided updater.
- * If the result value is identical (by `Object.is`) the original array is returned.
- * @typeparam T - element type
- * @param arr - the source array
- * @param index - the index to update
- * @param updater - value or function update description
- */
-export const update = `with` in Array.prototype ? _updateNew : _updateOld;
-
-/**
- * Internal helper applying a modifier function via `with`.
- * @internal
- */
-export function _modNew<T>(
-  arr: readonly T[],
-  index: number,
-  f: (value: T) => T
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-
-  const curValue = arr[index];
-  const newValue = f(curValue);
-
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  return arr.with(index, newValue);
-}
-
-/**
- * Internal helper applying a modifier function via cloning.
- * @internal
- */
-export function _modOld<T>(
-  arr: readonly T[],
-  index: number,
-  f: (value: T) => T
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-
-  const curValue = arr[index];
-  const newValue = f(curValue);
-
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  const newArr = arr.slice();
-  newArr[index] = newValue;
-  return newArr;
-}
-
-/**
- * Returns a copy of the array where the element at the given index is transformed by a modifier function.
- * If the result value is identical (by `Object.is`) the original array is returned.
- * @typeparam T - element type
- * @param arr - the source array
- * @param index - the index to modify
- * @param f - modifier function receiving the current value
- */
-export const mod = `with` in Array.prototype ? _modNew : _modOld;
-
-/**
- * Internal helper for inserting a value using `toSpliced`.
- * @internal
- */
-export function _insertNew<T>(arr: readonly T[], index: number, value: T): T[] {
-  return arr.toSpliced(index, 0, value);
-}
-
-/**
- * Internal helper for inserting a value using legacy `splice` on a clone.
- * @internal
- */
-export function _insertOld<T>(arr: readonly T[], index: number, value: T): T[] {
-  const clone = arr.slice();
-  clone.splice(index, 0, value);
-  return clone;
-}
-
-/**
- * Returns a copy of the array where at the given index the provided value is inserted.
- * @typeparam T - element type
- * @param arr - the source array
- * @param index - insertion index
- * @param value - value to insert
- */
-export const insert = `toSpliced` in Array.prototype ? _insertNew : _insertOld;
-
-/**
- * Returns a copy of the array without its first element.
- * @typeparam T - element type
- * @param arr - the source array
- */
-export function tail<T>(arr: readonly T[]): T[] {
-  return arr.slice(1);
-}
-
-/**
- * Returns a copy of the array without its last element.
- * @typeparam T - element type
- * @param arr - the source array
- */
-export function init<T>(arr: readonly T[]): T[] {
-  return arr.slice(0, arr.length - 1);
-}
-
-/**
- * Internal helper providing an immutable `splice` using `toSpliced`.
- * @internal
- */
-export function _spliceNew<T>(
-  arr: readonly T[],
-  start: number,
-  deleteCount: number,
-  ...items: T[]
-): T[] {
-  return arr.toSpliced(start, deleteCount, ...items);
-}
-
-/**
- * Internal helper providing an immutable `splice` via cloning.
- * @internal
- */
-export function _spliceOld<T>(
-  arr: readonly T[],
-  start: number,
-  deleteCount: number,
-  ...items: T[]
-): T[] {
-  const clone = arr.slice();
-  clone.splice(start, deleteCount, ...items);
-  return clone;
-}
-
-/**
- * Immutable version of the array `.splice` command, always returning a new array.
- * @typeparam T - element type
- * @param arr - the source array
- * @param start - start index
- * @param deleteCount - number of elements to delete
- * @param items - optional items to insert
- */
-export const splice = `toSpliced` in Array.prototype ? _spliceNew : _spliceOld;
-
-/**
- * Returns a copy of a (potentially) sparse array preserving sparsity (skips holes).
- * @typeparam T - element type
- * @param arr - the source sparse array
- */
-export function copySparse<T>(arr: readonly T[]): T[] {
-  const clone: T[] = [];
-  for (const key in arr) {
-    clone[key] = arr[key];
-  }
-  return clone;
-}
-
-/**
- * Returns a copy of a sparse array applying the given function to each present element, preserving holes.
- * @typeparam T - source element type
- * @typeparam T2 - result element type
- * @param arr - the source sparse array
- * @param f - mapping function
- */
-export function mapSparse<T, T2>(
-  arr: readonly T[],
-  f: (value: T, index: number) => T2
-): T2[] {
-  const result: T2[] = Array(arr.length);
-
-  for (const key in arr) {
-    result[key] = f(arr[key], key as any);
-  }
-
-  return result;
-}

package/dist/bun/entry.mts

@@ -1,21 +0,0 @@
-/**
- * Returns the first element of a 2-tuple.
- * @typeparam K - the first element type
- * @typeparam V - the second element type
- * @param entry - the tuple
- * @returns the first element
- */
-export function first<K, V>(entry: readonly [K, V]): K {
-  return entry[0];
-}
-
-/**
- * Returns the second element of a 2-tuple.
- * @typeparam K - the first element type
- * @typeparam V - the second element type
- * @param entry - the tuple
- * @returns the second element
- */
-export function second<K, V>(entry: readonly [K, V]): V {
-  return entry[1];
-}

package/dist/bun/index.mts

@@ -1,16 +0,0 @@
-/**
- * @packageDocumentation
- *
- * The `@rimbu/base` package provides foundational immutable array utilities, tuple helpers,
- * plain‑object type predicates and structured error types that power all other Rimbu collections.<br/>
- * Use it directly when you need low‑level, performance‑aware primitives for persistent data
- * structures without pulling in the higher‑level collection packages.<br/>
- * See the Rimbu docs and API reference for more information.
- */
-export * as Arr from './arr.mts';
-export * as Entry from './entry.mts';
-export * as RimbuError from './rimbu-error.mts';
-export * from './plain-object.mts';
-
-// Internal exports (may change without notice)
-export * from './internal.mts';

package/dist/bun/internal.mts

@@ -1 +0,0 @@
-export * from './token.mts';

package/dist/bun/plain-object.mts

@@ -1,95 +0,0 @@
-/**
- * Matches any type of function
- */
-export type AnyFunc = (...args: any[]) => any;
-
-/**
- * Gives true if the given type T is a function, false otherwise.
- * @typeparam T - the input type
- */
-export type IsAnyFunc<T> = AnyFunc extends T ? true : false;
-
-/**
- * A predicate type for any record that resolves to true if any of the record
- * properties is a function, false otherwise.
- * This is useful to have a coarse discrimination between pure data objects and class instances.
- * @typeparam T - the input type
- */
-export type IsObjWithoutFunctions<T> = AnyFunc extends T[keyof T]
-  ? false
-  : true;
-
-/**
- * A predicate type that resolves to true if the given type satisfies:
- * - it is an object type (not a primitive)
- * - it is not a function
- * - it is not iterable
- * - it does not have any properties that are functions
- * Otherwise, it resolves to false
- * @typeparam T - the input type
- */
-export type IsPlainObj<T> = T extends
-  | null
-  | undefined
-  | number
-  | string
-  | boolean
-  | bigint
-  | symbol
-  | AnyFunc
-  | Iterable<any>
-  | AsyncIterable<any>
-  ? false
-  : IsObjWithoutFunctions<T>;
-
-/**
- * Utility type that will only accept objects that are considered 'plain objects' according
- * to the `IsPlainObj` predicate type.
- * @typeparam T - the value type to test
- */
-export type PlainObj<T> = IsPlainObj<T> extends true ? T : never;
-
-/**
- * Utility type that will only return true if the input type T is equal to `any`.
- * @typeparam T - the value type to test
- */
-export type IsAny<T> = 0 extends 1 & T ? true : false;
-
-/**
- * Utility type that will only return true if the input type T is a (readonly) array.
- * @typeparm T - the value type to test
- */
-export type IsArray<T> = T extends readonly any[] ? true : false;
-
-/**
- * Utility type to exclude any types that are iterable. Useful in cases where
- * plain objects are required as inputs but not arrays.
- */
-export type NotIterable = {
-  [Symbol.iterator]?: never;
-};
-
-/**
- * Companion function to the `IsRecord<T>` type that checks whether the given object is a pure
- * data object.
- * @param obj - the object to check
- * @returns true if the given object is a pure data object
- * @note does not check whether a record's properties are not functions
- */
-export function isPlainObj(obj: any): obj is object {
-  return (
-    typeof obj === 'object' &&
-    null !== obj &&
-    (obj.constructor === Object || !(obj.constructor instanceof Function)) &&
-    !(Symbol.iterator in obj) &&
-    !(Symbol.asyncIterator in obj)
-  );
-}
-
-/**
- * Returns true if the given object is Iterable
- * @param obj - the object to check
- */
-export function isIterable(obj: any): obj is Iterable<unknown> {
-  return obj !== null && typeof obj === 'object' && Symbol.iterator in obj;
-}

package/dist/bun/rimbu-error.mts

@@ -1,64 +0,0 @@
-import { ErrBase } from '@rimbu/common';
-
-/**
- * Error thrown when an operation assumes a collection is non-empty but it is empty.
- */
-export class EmptyCollectionAssumedNonEmptyError extends ErrBase.CustomError {
-  constructor() {
-    super('empty collection was assumbed to be non-empty');
-  }
-}
-
-/**
- * Error thrown when a builder is modified while it is being iterated.
- */
-export class ModifiedBuilderWhileLoopingOverItError extends ErrBase.CustomError {
-  constructor() {
-    super('an attempt was made to modify a builder while looping over it');
-  }
-}
-
-/**
- * Error indicating an unexpected internal state. Users are encouraged to file an issue.
- */
-export class InvalidStateError extends ErrBase.CustomError {
-  constructor() {
-    super(
-      "something happend that shouldn't happen, please consider creating an issue"
-    );
-  }
-}
-
-/**
- * Error indicating incorrect usage of the API.
- */
-export class InvalidUsageError extends ErrBase.CustomError {}
-
-/**
- * Throws an `EmptyCollectionAssumedNonEmptyError`.
- */
-export function throwEmptyCollectionAssumedNonEmptyError(): never {
-  throw new EmptyCollectionAssumedNonEmptyError();
-}
-
-/**
- * Throws a `ModifiedBuilderWhileLoopingOverItError`.
- */
-export function throwModifiedBuilderWhileLoopingOverItError(): never {
-  throw new ModifiedBuilderWhileLoopingOverItError();
-}
-
-/**
- * Throws an `InvalidStateError`.
- */
-export function throwInvalidStateError(): never {
-  throw new InvalidStateError();
-}
-
-/**
- * Throws an `InvalidUsageError` with the provided message.
- * @param msg - context message describing the invalid usage
- */
-export function throwInvalidUsageError(msg: string): never {
-  throw new InvalidUsageError(msg);
-}

package/dist/bun/token.mts

@@ -1,9 +0,0 @@
-/**
- * Unique symbol used as a nominal token within the base package.
- * Can be employed for branding or sentinel values.
- */
-export const Token = Symbol('Token');
-/**
- * Type alias representing the Token symbol.
- */
-export type Token = typeof Token;