massaman 0.0.1-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zac Rosenbauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+<div align="center">
+  <img src="assets/banner.svg" alt="tadka" width="100%" />
+</div>
+
+# tadka
+
+A comprehensive functional programming library for TypeScript — a curated unified surface over [es-toolkit](https://es-toolkit.slash.page) and [ts-pattern](https://github.com/gvergnaud/ts-pattern), with custom utilities for composition, predicates, Result-style error handling, and pattern matching.
+
+## Installation
+
+```bash
+npm install tadka
+```
+
+```bash
+# pnpm
+pnpm add tadka
+
+# yarn
+yarn add tadka
+```
+
+## Features
+
+| Feature                            | Description                                                                                              |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| **Unified FP surface**             | Array, object, string, function, math, predicate, promise — one curated import root, tree-shakeable.     |
+| **Result-style error handling**    | `attempt` / `attemptAsync` / `ok` / `err` / `isOk` / `isErr` / `unwrap` — no thrown exceptions.          |
+| **Pattern matching**               | Full [ts-pattern](https://github.com/gvergnaud/ts-pattern) re-export under `tadka/pattern`.              |
+| **Variadic type-guard narrowing**  | `allPass([isString, isNotEmpty])` returns a guard that narrows to `string` — composes any arity.         |
+| **Async-aware pipelines**          | `flowAsync` chains promise-returning functions with end-to-end type inference (up to 7 steps).           |
+| **Safe error normalization**       | `toError` + `stringify` handle non-`Error` throws, circular refs, Maps/Sets — no more `[object Object]`. |
+| **Branching combinators**          | `when` / `unless` / `ifElse` for point-free conditionals inside `flow` pipelines.                        |
+| **100% test coverage**             | Enforced by CI — every line, branch, and function is verified.                                           |
+| **ESM-only, `sideEffects: false`** | 12 subpath exports, tree-shakeable, zero side effects.                                                   |
+
+## Usage
+
+```ts
+import { flow, compact, uniq, toArray } from 'tadka'
+
+const normalize = flow(toArray, compact, uniq)
+normalize([1, null, 2, 1, null]) // [1, 2]
+```
+
+```ts
+import { match, P } from 'tadka/pattern'
+
+const label = match(status)
+  .with('active', () => 'Live')
+  .with('draft', () => 'Draft')
+  .with(P._, () => 'N/A')
+  .exhaustive()
+```
+
+```ts
+import { attempt, isOk } from 'tadka/control'
+
+const result = attempt(() => JSON.parse(raw))
+if (isOk(result)) {
+  console.log(result.value)
+} else {
+  console.error(result.error)
+}
+```
+
+```ts
+import { allPass } from 'tadka/predicate'
+import { isString } from 'es-toolkit/predicate'
+import { isNotEmpty } from 'tadka/predicate'
+
+const isNonEmptyString = allPass([isString, isNotEmpty])
+if (isNonEmptyString(x)) {
+  // x is narrowed to string
+}
+```
+
+### Error-safe composition
+
+`flow` and `flowAsync` don't catch throws — wrap the pipeline with `attempt` / `attemptAsync` to recover:
+
+```ts
+import { flow, attempt, isOk } from 'tadka'
+
+const parseUser = flow(JSON.parse, (u) => u.name.trim())
+
+const result = attempt(() => parseUser(rawInput))
+if (isOk(result)) {
+  return result.value
+}
+return 'unknown'
+```
+
+## Modules
+
+| Subpath            | Description                                                                |
+| ------------------ | -------------------------------------------------------------------------- |
+| `tadka`            | Root barrel — re-exports everything below                                  |
+| `tadka/array`      | Array utilities (chunk, groupBy, sortWith, scan, unfold, …)                |
+| `tadka/object`     | Object utilities (evolve, pick, omit, merge, mapKeys, …)                   |
+| `tadka/function`   | Composition (flow, flowAsync, tap, call, curry, when, unless, ifElse, …)   |
+| `tadka/predicate`  | Type guards, combinators with variadic narrowing                           |
+| `tadka/conversion` | Coercion + safe stringification (toError, stringify, toNumber, toArray, …) |
+| `tadka/string`     | String transforms (camelCase, kebabCase, trim, …)                          |
+| `tadka/math`       | Numeric utilities (clamp, sum, mean, range, …)                             |
+| `tadka/promise`    | Async helpers (delay, timeout, Mutex, Semaphore)                           |
+| `tadka/control`    | Result-style error handling (attempt, ok, err, isOk, isErr, unwrap, …)     |
+| `tadka/pattern`    | Pattern matching (match, P, isMatching)                                    |
+| `tadka/error`      | Error types (AbortError, TimeoutError)                                     |
+
+## Custom Utilities
+
+Utilities that aren't in es-toolkit or ts-pattern — implemented in this package:
+
+| Module       | Utility                                          | Description                                                    |
+| ------------ | ------------------------------------------------ | -------------------------------------------------------------- |
+| `array`      | `adjust`, `scan`, `unfold`, `dropRepeats`        | Index update, accumulator scan, seed unfold, consecutive dedup |
+| `array`      | `reduceWhile`, `ascend`, `descend`, `sortWith`   | Short-circuit reduce, comparator factories, multi-key sort     |
+| `function`   | `flowAsync`, `tap`                               | Async composition, side-effect-in-pipeline                     |
+| `function`   | `when`, `unless`, `ifElse`, `call`, `callAsync`  | Point-free conditionals, named application                     |
+| `object`     | `evolve`                                         | Apply transforms per key                                       |
+| `predicate`  | `allPass`, `anyPass`, `both`, `either`           | Variadic-narrowing predicate combinators                       |
+| `predicate`  | `isArray`, `isObject`, `isEmpty`, `isNotEmpty`   | Type guards + emptiness                                        |
+| `predicate`  | `isFiniteNumber`, `isInteger`, `isNaN`           | Strict numeric guards (shadowing the broken global `isNaN`)    |
+| `control`    | `attempt`, `attemptAsync`                        | Wrap throwing/rejecting code into a `Result`                   |
+| `control`    | `ok`, `err`, `isOk`, `isErr`, `unwrap`           | Construct, narrow, and unwrap a `Result`                       |
+| `conversion` | `toError`, `stringify`                           | Normalize unknown thrown values + safe JSON of any value       |
+| `conversion` | `toNumber`, `toString`, `toBoolean`, `toInteger` | Stable coercion primitives                                     |
+| `conversion` | `toFinite`, `toArray`                            | Safe coercion with fallback semantics                          |
+
+## Requirements
+
+- Node.js >= 24.0.0
+- ESM only (`require()` / CommonJS is not supported)
+- TypeScript >= 5.9 recommended (variadic narrowing benefits from recent inference)
+
+## License
+
+MIT © Zac Rosenbauer

package/dist/array/index.d.mts

@@ -0,0 +1,2 @@
+import { $ as unionWith, A as last, B as remove, C as initial, D as isSubset, E as intersectionWith, F as orderBy, G as tail, H as sampleSize, I as partition, J as takeRightWhile, K as take, L as pull, M as mapAsync, N as maxBy, O as isSubsetWith, P as minBy, Q as unionBy, R as pullAt, S as head, T as intersectionBy, U as shuffle, V as sample, W as sortBy, X as toFilled, Y as takeWhile, Z as union, _ as flatten, _t as scan, a as difference, at as windowed, b as forEachRight, bt as adjust, c as drop, ct as xorBy, d as dropWhile, dt as zipObject, et as uniq, f as fill, ft as zipWith, g as flatMapDeep, gt as sortWith, h as flatMapAsync, ht as descend, i as countBy, it as unzipWith, j as limitAsync, k as keyBy, l as dropRight, lt as xorWith, m as flatMap, mt as ascend, n as chunk, nt as uniqWith, o as differenceBy, ot as without, p as filterAsync, pt as unfold, q as takeRight, r as compact, rt as unzip, s as differenceWith, st as xor, t as at, tt as uniqBy, u as dropRightWhile, ut as zip, v as flattenDeep, vt as reduceWhile, w as intersection, x as groupBy, y as forEachAsync, yt as dropRepeats, z as reduceAsync } from "../index-Dw_tuZdb.mjs";
+export { adjust, ascend, at, chunk, compact, countBy, descend, difference, differenceBy, differenceWith, drop, dropRepeats, dropRight, dropRightWhile, dropWhile, fill, filterAsync, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, forEachAsync, forEachRight, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, keyBy, last, limitAsync, mapAsync, maxBy, minBy, orderBy, partition, pull, pullAt, reduceAsync, reduceWhile, remove, sample, sampleSize, scan, shuffle, sortBy, sortWith, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, unfold, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/array/index.mjs

@@ -0,0 +1,2 @@
+import { $ as unionWith, A as last, B as remove, C as initial, D as isSubset, E as intersectionWith, F as orderBy, G as tail, H as sampleSize, I as partition, J as takeRightWhile, K as take, L as pull, M as mapAsync, N as maxBy, O as isSubsetWith, P as minBy, Q as unionBy, R as pullAt, S as head, T as intersectionBy, U as shuffle, V as sample, W as sortBy, X as toFilled, Y as takeWhile, Z as union, _ as flatten, _t as scan, a as difference, at as windowed, b as forEachRight, bt as adjust, c as drop, ct as xorBy, d as dropWhile, dt as zipObject, et as uniq, f as fill, ft as zipWith, g as flatMapDeep, gt as sortWith, h as flatMapAsync, ht as descend, i as countBy, it as unzipWith, j as limitAsync, k as keyBy, l as dropRight, lt as xorWith, m as flatMap, mt as ascend, n as chunk, nt as uniqWith, o as differenceBy, ot as without, p as filterAsync, pt as unfold, q as takeRight, r as compact, rt as unzip, s as differenceWith, st as xor, t as at, tt as uniqBy, u as dropRightWhile, ut as zip, v as flattenDeep, vt as reduceWhile, w as intersection, x as groupBy, y as forEachAsync, yt as dropRepeats, z as reduceAsync } from "../array-C8MqjyiP.mjs";
+export { adjust, ascend, at, chunk, compact, countBy, descend, difference, differenceBy, differenceWith, drop, dropRepeats, dropRight, dropRightWhile, dropWhile, fill, filterAsync, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, forEachAsync, forEachRight, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, keyBy, last, limitAsync, mapAsync, maxBy, minBy, orderBy, partition, pull, pullAt, reduceAsync, reduceWhile, remove, sample, sampleSize, scan, shuffle, sortBy, sortWith, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, unfold, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/array-C8MqjyiP.mjs

@@ -0,0 +1,191 @@
+import { at, chunk, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, filterAsync, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, forEachAsync, forEachRight, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, keyBy, last, limitAsync, mapAsync, maxBy, minBy, orderBy, partition, pull, pullAt, reduceAsync, remove, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith } from "es-toolkit/array";
+//#region src/array/adjust.ts
+/**
+* Applies a function to the element at the given index, returning a new array.
+*
+* The original array is not modified. If the index is out of bounds, the
+* array is returned unchanged.
+*
+* @example
+* ```ts
+* adjust([1, 2, 3], 1, (n) => n * 10)
+* // [1, 20, 3]
+* ```
+*/
+function adjust(array, index, fn) {
+	const result = [...array];
+	if (index >= 0 && index < array.length) result[index] = fn(result[index]);
+	return result;
+}
+//#endregion
+//#region src/array/dropRepeats.ts
+/**
+* Removes consecutively repeated elements from an array using strict
+* equality (`===`).
+*
+* Only adjacent duplicates are removed — non-adjacent duplicates are kept.
+* Use {@link uniq} from es-toolkit to remove all duplicates regardless of position.
+*
+* Quirks (inherent to `===`):
+* - `NaN !== NaN`, so adjacent `NaN`s are *not* collapsed.
+* - `-0 === 0`, so adjacent `-0` and `0` *are* collapsed.
+* - Object/array elements compare by reference, not structure.
+*
+* @example
+* ```ts
+* dropRepeats([1, 1, 2, 3, 3, 2, 1])
+* // [1, 2, 3, 2, 1]
+* ```
+*/
+function dropRepeats(array) {
+	return array.reduce((acc, item, index) => {
+		if (index === 0 || item !== array[index - 1]) acc.push(item);
+		return acc;
+	}, []);
+}
+//#endregion
+//#region src/array/reduceWhile.ts
+/**
+* Like `reduce` but stops early when the predicate returns `false`.
+*
+* The predicate receives the current accumulator and element. When it
+* returns `false`, the current accumulator is returned without processing
+* the remaining elements.
+*
+* @example
+* ```ts
+* // Sum until we hit a negative number
+* reduceWhile(
+*   [1, 2, 3, -1, 5],
+*   (acc, n) => n >= 0,
+*   (acc, n) => acc + n,
+*   0,
+* )
+* // 6
+* ```
+*/
+function reduceWhile(array, predicate, fn, initial) {
+	let acc = initial;
+	for (let index = 0; index < array.length; index += 1) {
+		const value = array[index];
+		if (!predicate(acc, value)) return acc;
+		acc = fn(acc, value, index);
+	}
+	return acc;
+}
+//#endregion
+//#region src/array/scan.ts
+/**
+* Like `reduce` but returns an array of all intermediate accumulator values.
+*
+* The result array starts with the initial value and ends with the final
+* accumulator, so its length is `array.length + 1`.
+*
+* @example
+* ```ts
+* scan([1, 2, 3, 4], (acc, n) => acc + n, 0)
+* // [0, 1, 3, 6, 10]
+* ```
+*/
+function scan(array, fn, initial) {
+	return array.reduce((result, item, index) => {
+		const prev = result[result.length - 1];
+		result.push(fn(prev, item, index));
+		return result;
+	}, [initial]);
+}
+//#endregion
+//#region src/array/sorting.ts
+/**
+* Creates an ascending comparator from an accessor function.
+*
+* @example
+* ```ts
+* users.sort(ascend(u => u.name))
+* ```
+*/
+function ascend(fn) {
+	return (a, b) => {
+		const aa = fn(a);
+		const bb = fn(b);
+		if (aa < bb) return -1;
+		if (aa > bb) return 1;
+		return 0;
+	};
+}
+/**
+* Creates a descending comparator from an accessor function.
+*
+* @example
+* ```ts
+* users.sort(descend(u => u.age))
+* ```
+*/
+function descend(fn) {
+	return (a, b) => {
+		const aa = fn(a);
+		const bb = fn(b);
+		if (aa > bb) return -1;
+		if (aa < bb) return 1;
+		return 0;
+	};
+}
+/**
+* Sorts an array using multiple comparators in priority order.
+*
+* The first comparator has highest priority. When it returns 0 (tie),
+* the next comparator is used, and so on.
+*
+* @example
+* ```ts
+* sortWith(users, [
+*   ascend(u => u.department),
+*   descend(u => u.age),
+* ])
+* ```
+*/
+function sortWith(array, comparators) {
+	return [...array].toSorted((a, b) => {
+		for (const cmp of comparators) {
+			const result = cmp(a, b);
+			if (result !== 0) return result;
+		}
+		return 0;
+	});
+}
+//#endregion
+//#region src/array/unfold.ts
+/**
+* Builds an array from a seed value using an iterator function.
+*
+* The iterator receives the current seed and returns either a `[value, nextSeed]`
+* tuple to continue, or `false` to stop.
+*
+* Dual of `reduce` — reduce collapses a list into a value, unfold expands
+* a value into a list.
+*
+* **Termination is the caller's responsibility.** If `fn` never returns
+* `false`, `unfold` will run until memory is exhausted. For bounded
+* generation, encode a counter or limit into the seed.
+*
+* @example
+* ```ts
+* unfold((n) => (n > 0 ? [n, n - 1] : false), 5)
+* // [5, 4, 3, 2, 1]
+* ```
+*/
+function unfold(fn, seed) {
+	const result = [];
+	let current = seed;
+	let pair = fn(current);
+	while (pair !== false) {
+		result.push(pair[0]);
+		current = pair[1];
+		pair = fn(current);
+	}
+	return result;
+}
+//#endregion
+export { unionWith as $, last as A, remove as B, initial as C, isSubset as D, intersectionWith as E, orderBy as F, tail as G, sampleSize as H, partition as I, takeRightWhile as J, take as K, pull as L, mapAsync as M, maxBy as N, isSubsetWith as O, minBy as P, unionBy as Q, pullAt as R, head as S, intersectionBy as T, shuffle as U, sample as V, sortBy as W, toFilled as X, takeWhile as Y, union as Z, flatten as _, scan as _t, difference as a, windowed as at, forEachRight as b, adjust as bt, drop as c, xorBy as ct, dropWhile as d, zipObject as dt, uniq as et, fill as f, zipWith as ft, flatMapDeep as g, sortWith as gt, flatMapAsync as h, descend as ht, countBy as i, unzipWith as it, limitAsync as j, keyBy as k, dropRight as l, xorWith as lt, flatMap as m, ascend as mt, chunk as n, uniqWith as nt, differenceBy as o, without as ot, filterAsync as p, unfold as pt, takeRight as q, compact as r, unzip as rt, differenceWith as s, xor as st, at as t, uniqBy as tt, dropRightWhile as u, zip as ut, flattenDeep as v, reduceWhile as vt, intersection as w, groupBy as x, forEachAsync as y, dropRepeats as yt, reduceAsync as z };
+
+//# sourceMappingURL=array-C8MqjyiP.mjs.map

package/dist/array-C8MqjyiP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-C8MqjyiP.mjs","names":[],"sources":["../src/array/adjust.ts","../src/array/dropRepeats.ts","../src/array/reduceWhile.ts","../src/array/scan.ts","../src/array/sorting.ts","../src/array/unfold.ts"],"sourcesContent":["/**\n * Applies a function to the element at the given index, returning a new array.\n *\n * The original array is not modified. If the index is out of bounds, the\n * array is returned unchanged.\n *\n * @example\n * ```ts\n * adjust([1, 2, 3], 1, (n) => n * 10)\n * // [1, 20, 3]\n * ```\n */\nexport function adjust<T>(array: readonly T[], index: number, fn: (value: T) => T): T[] {\n  const result = [...array]\n  if (index >= 0 && index < array.length) {\n    // oxlint-disable-next-line security/detect-object-injection -- Numeric array index parameter, not user-controlled key\n    result[index] = fn(result[index])\n  }\n  return result\n}\n","/**\n * Removes consecutively repeated elements from an array using strict\n * equality (`===`).\n *\n * Only adjacent duplicates are removed — non-adjacent duplicates are kept.\n * Use {@link uniq} from es-toolkit to remove all duplicates regardless of position.\n *\n * Quirks (inherent to `===`):\n * - `NaN !== NaN`, so adjacent `NaN`s are *not* collapsed.\n * - `-0 === 0`, so adjacent `-0` and `0` *are* collapsed.\n * - Object/array elements compare by reference, not structure.\n *\n * @example\n * ```ts\n * dropRepeats([1, 1, 2, 3, 3, 2, 1])\n * // [1, 2, 3, 2, 1]\n * ```\n */\nexport function dropRepeats<T>(array: readonly T[]): T[] {\n  return array.reduce<T[]>((acc, item, index) => {\n    if (index === 0 || item !== array[index - 1]) {\n      acc.push(item)\n    }\n    return acc\n  }, [])\n}\n","/* oxlint-disable functional/no-let -- iterative impl avoids stack overflow on large arrays */\n\n/**\n * Like `reduce` but stops early when the predicate returns `false`.\n *\n * The predicate receives the current accumulator and element. When it\n * returns `false`, the current accumulator is returned without processing\n * the remaining elements.\n *\n * @example\n * ```ts\n * // Sum until we hit a negative number\n * reduceWhile(\n *   [1, 2, 3, -1, 5],\n *   (acc, n) => n >= 0,\n *   (acc, n) => acc + n,\n *   0,\n * )\n * // 6\n * ```\n */\nexport function reduceWhile<T, R>(\n  array: readonly T[],\n  predicate: (accumulator: R, value: T) => boolean,\n  fn: (accumulator: R, value: T, index: number) => R,\n  initial: R\n): R {\n  let acc = initial\n  for (let index = 0; index < array.length; index += 1) {\n    // oxlint-disable-next-line security/detect-object-injection -- Locally computed numeric array index\n    const value = array[index]\n    if (!predicate(acc, value)) {\n      return acc\n    }\n    acc = fn(acc, value, index)\n  }\n  return acc\n}\n","/**\n * Like `reduce` but returns an array of all intermediate accumulator values.\n *\n * The result array starts with the initial value and ends with the final\n * accumulator, so its length is `array.length + 1`.\n *\n * @example\n * ```ts\n * scan([1, 2, 3, 4], (acc, n) => acc + n, 0)\n * // [0, 1, 3, 6, 10]\n * ```\n */\nexport function scan<T, R>(\n  array: readonly T[],\n  fn: (accumulator: R, value: T, index: number) => R,\n  initial: R\n): R[] {\n  return array.reduce<R[]>(\n    (result, item, index) => {\n      const prev = result[result.length - 1]\n      result.push(fn(prev, item, index))\n      return result\n    },\n    [initial]\n  )\n}\n","/**\n * Creates an ascending comparator from an accessor function.\n *\n * @example\n * ```ts\n * users.sort(ascend(u => u.name))\n * ```\n */\nexport function ascend<T>(fn: (value: T) => number | string): (a: T, b: T) => number {\n  return (a: T, b: T) => {\n    const aa = fn(a)\n    const bb = fn(b)\n    if (aa < bb) {\n      return -1\n    }\n    if (aa > bb) {\n      return 1\n    }\n    return 0\n  }\n}\n\n/**\n * Creates a descending comparator from an accessor function.\n *\n * @example\n * ```ts\n * users.sort(descend(u => u.age))\n * ```\n */\nexport function descend<T>(fn: (value: T) => number | string): (a: T, b: T) => number {\n  return (a: T, b: T) => {\n    const aa = fn(a)\n    const bb = fn(b)\n    if (aa > bb) {\n      return -1\n    }\n    if (aa < bb) {\n      return 1\n    }\n    return 0\n  }\n}\n\n/**\n * Sorts an array using multiple comparators in priority order.\n *\n * The first comparator has highest priority. When it returns 0 (tie),\n * the next comparator is used, and so on.\n *\n * @example\n * ```ts\n * sortWith(users, [\n *   ascend(u => u.department),\n *   descend(u => u.age),\n * ])\n * ```\n */\nexport function sortWith<T>(\n  array: readonly T[],\n  comparators: ReadonlyArray<(a: T, b: T) => number>\n): T[] {\n  return [...array].toSorted((a, b) => {\n    for (const cmp of comparators) {\n      const result = cmp(a, b)\n      if (result !== 0) {\n        return result\n      }\n    }\n    return 0\n  })\n}\n","/* oxlint-disable functional/no-let -- iterative impl avoids stack overflow on large outputs */\n\n/**\n * Builds an array from a seed value using an iterator function.\n *\n * The iterator receives the current seed and returns either a `[value, nextSeed]`\n * tuple to continue, or `false` to stop.\n *\n * Dual of `reduce` — reduce collapses a list into a value, unfold expands\n * a value into a list.\n *\n * **Termination is the caller's responsibility.** If `fn` never returns\n * `false`, `unfold` will run until memory is exhausted. For bounded\n * generation, encode a counter or limit into the seed.\n *\n * @example\n * ```ts\n * unfold((n) => (n > 0 ? [n, n - 1] : false), 5)\n * // [5, 4, 3, 2, 1]\n * ```\n */\nexport function unfold<T, R>(fn: (seed: T) => [R, T] | false, seed: T): R[] {\n  const result: R[] = []\n  let current = seed\n  let pair = fn(current)\n  while (pair !== false) {\n    result.push(pair[0])\n    current = pair[1]\n    pair = fn(current)\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,SAAgB,OAAU,OAAqB,OAAe,IAA0B;CACtF,MAAM,SAAS,CAAC,GAAG,MAAM;CACzB,IAAI,SAAS,KAAK,QAAQ,MAAM,QAE9B,OAAO,SAAS,GAAG,OAAO,OAAO;CAEnC,OAAO;;;;;;;;;;;;;;;;;;;;;;ACAT,SAAgB,YAAe,OAA0B;CACvD,OAAO,MAAM,QAAa,KAAK,MAAM,UAAU;EAC7C,IAAI,UAAU,KAAK,SAAS,MAAM,QAAQ,IACxC,IAAI,KAAK,KAAK;EAEhB,OAAO;IACN,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;ACHR,SAAgB,YACd,OACA,WACA,IACA,SACG;CACH,IAAI,MAAM;CACV,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EAEpD,MAAM,QAAQ,MAAM;EACpB,IAAI,CAAC,UAAU,KAAK,MAAM,EACxB,OAAO;EAET,MAAM,GAAG,KAAK,OAAO,MAAM;;CAE7B,OAAO;;;;;;;;;;;;;;;;ACxBT,SAAgB,KACd,OACA,IACA,SACK;CACL,OAAO,MAAM,QACV,QAAQ,MAAM,UAAU;EACvB,MAAM,OAAO,OAAO,OAAO,SAAS;EACpC,OAAO,KAAK,GAAG,MAAM,MAAM,MAAM,CAAC;EAClC,OAAO;IAET,CAAC,QAAQ,CACV;;;;;;;;;;;;AChBH,SAAgB,OAAU,IAA2D;CACnF,QAAQ,GAAM,MAAS;EACrB,MAAM,KAAK,GAAG,EAAE;EAChB,MAAM,KAAK,GAAG,EAAE;EAChB,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;EAET,OAAO;;;;;;;;;;;AAYX,SAAgB,QAAW,IAA2D;CACpF,QAAQ,GAAM,MAAS;EACrB,MAAM,KAAK,GAAG,EAAE;EAChB,MAAM,KAAK,GAAG,EAAE;EAChB,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;EAET,OAAO;;;;;;;;;;;;;;;;;AAkBX,SAAgB,SACd,OACA,aACK;CACL,OAAO,CAAC,GAAG,MAAM,CAAC,UAAU,GAAG,MAAM;EACnC,KAAK,MAAM,OAAO,aAAa;GAC7B,MAAM,SAAS,IAAI,GAAG,EAAE;GACxB,IAAI,WAAW,GACb,OAAO;;EAGX,OAAO;GACP;;;;;;;;;;;;;;;;;;;;;;;ACjDJ,SAAgB,OAAa,IAAiC,MAAc;CAC1E,MAAM,SAAc,EAAE;CACtB,IAAI,UAAU;CACd,IAAI,OAAO,GAAG,QAAQ;CACtB,OAAO,SAAS,OAAO;EACrB,OAAO,KAAK,KAAK,GAAG;EACpB,UAAU,KAAK;EACf,OAAO,GAAG,QAAQ;;CAEpB,OAAO"}

package/dist/control/index.d.mts

@@ -0,0 +1,2 @@
+import { a as isOk, c as attempt, d as Ok, f as Result, i as isErr, l as attemptAsync, n as invariant, o as ok, r as err, s as unwrap, t as assert, u as Err } from "../index-Br9PO6mU.mjs";
+export { Err, Ok, Result, assert, attempt, attemptAsync, err, invariant, isErr, isOk, ok, unwrap };

package/dist/control/index.mjs

@@ -0,0 +1,2 @@
+import { a as err, c as ok, i as attemptAsync, l as unwrap, n as invariant, o as isErr, r as attempt, s as isOk, t as assert } from "../control-B4mDPBn6.mjs";
+export { assert, attempt, attemptAsync, err, invariant, isErr, isOk, ok, unwrap };

package/dist/control-B4mDPBn6.mjs

@@ -0,0 +1,164 @@
+import { isNil } from "es-toolkit/predicate";
+import { assert, invariant } from "es-toolkit/util";
+//#region src/control/result.ts
+/**
+* Minimal error coercion used internally by `err()`. Kept local to avoid
+* pulling the full conversion module into the `tadka/control` bundle.
+* For richer stringification (Maps, Sets, Errors with own props, circular
+* refs), import `toError` from `tadka/conversion`.
+*/
+function coerceError(thrown) {
+	if (thrown instanceof Error) return thrown;
+	if (typeof thrown === "string") return new Error(thrown);
+	try {
+		const message = JSON.stringify(thrown) ?? String(thrown);
+		return new Error(message, { cause: thrown });
+	} catch {
+		return new Error(String(thrown), { cause: thrown });
+	}
+}
+/**
+* Creates a success result wrapping the given value.
+*
+* @param value - The success value
+* @returns An `Ok` result containing the value
+*
+* @example
+* ```ts
+* const result = ok(42)
+* // { ok: true, value: 42 }
+* ```
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value,
+		error: null
+	};
+}
+/**
+* Creates a failure result wrapping the given error.
+*
+* @param error - The error value
+* @returns An `Err` result containing the error
+*
+* @example
+* ```ts
+* const result = err(new Error('fail'))
+* // { ok: false, error: Error('fail') }
+* ```
+*/
+function err(error) {
+	return {
+		ok: false,
+		value: null,
+		error: coerceError(error)
+	};
+}
+/**
+* Type guard that narrows a `Result` to `Ok`.
+*
+* @param result - The result to check
+* @returns `true` if the result is `Ok`
+*
+* @example
+* ```ts
+* const result = attempt(() => JSON.parse('{}'))
+* if (isOk(result)) {
+*   console.log(result.value)
+* }
+* ```
+*/
+function isOk(result) {
+	return result.ok === true;
+}
+/**
+* Type guard that narrows a `Result` to `Err`.
+*
+* @param result - The result to check
+* @returns `true` if the result is `Err`
+*
+* @example
+* ```ts
+* const result = attempt(() => JSON.parse('bad'))
+* if (isErr(result)) {
+*   console.error(result.error)
+* }
+* ```
+*/
+function isErr(result) {
+	return result.ok === false;
+}
+/**
+* Extract the value from an `Ok` result, or throw on `Err`.
+*
+* When called without a message, throws the original error.
+* When called with a message, throws a new Error with that message
+* and the original error as `cause` (like Rust's `expect`).
+*
+* @param result - The result to unwrap
+* @param message - Optional custom error message (Rust `expect` behavior)
+* @returns The unwrapped value
+*
+* @example
+* ```ts
+* const value = unwrap(ok(42))           // 42
+* unwrap(err('fail'))                    // throws Error('fail')
+* unwrap(err('fail'), 'config required') // throws Error('config required', { cause: Error('fail') })
+* ```
+*/
+function unwrap(result, message) {
+	if (result.ok) return result.value;
+	if (!isNil(message)) throw new Error(message, { cause: result.error });
+	throw result.error;
+}
+//#endregion
+//#region src/control/attempt.ts
+/**
+* Executes a synchronous function and wraps the outcome in a `Result`.
+* Returns `Ok` with the return value on success, `Err` with the thrown value on failure.
+*
+* @param fn - The function to execute
+* @returns A `Result` containing either the value or the error
+*
+* @example
+* ```ts
+* const result = attempt(() => JSON.parse('{"a":1}'))
+* if (isOk(result)) {
+*   console.log(result.value) // { a: 1 }
+* }
+* ```
+*/
+function attempt(fn) {
+	try {
+		return ok(fn());
+	} catch (error) {
+		return err(error);
+	}
+}
+/**
+* Executes an asynchronous function and wraps the outcome in a `Result`.
+* Returns `Ok` with the resolved value on success, `Err` with the rejection reason on failure.
+*
+* @param fn - The async function to execute
+* @returns A promise resolving to a `Result` containing either the value or the error
+*
+* @example
+* ```ts
+* const result = await attemptAsync(() => fetch('/api/data'))
+* if (isErr(result)) {
+*   console.error(result.error)
+* }
+* ```
+*/
+async function attemptAsync(fn) {
+	try {
+		return ok(await fn());
+	} catch (error) {
+		return err(error);
+	}
+}
+//#endregion
+export { err as a, ok as c, attemptAsync as i, unwrap as l, invariant as n, isErr as o, attempt as r, isOk as s, assert as t };
+
+//# sourceMappingURL=control-B4mDPBn6.mjs.map

package/dist/control-B4mDPBn6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-B4mDPBn6.mjs","names":[],"sources":["../src/control/result.ts","../src/control/attempt.ts"],"sourcesContent":["import { isNil } from 'es-toolkit/predicate'\n\nimport type { Err, Ok, Result } from './types.js'\n\n/**\n * Minimal error coercion used internally by `err()`. Kept local to avoid\n * pulling the full conversion module into the `tadka/control` bundle.\n * For richer stringification (Maps, Sets, Errors with own props, circular\n * refs), import `toError` from `tadka/conversion`.\n */\nfunction coerceError(thrown: unknown): Error {\n  if (thrown instanceof Error) {\n    return thrown\n  }\n  if (typeof thrown === 'string') {\n    return new Error(thrown)\n  }\n  try {\n    const message = JSON.stringify(thrown) ?? String(thrown)\n    return new Error(message, { cause: thrown })\n  } catch {\n    return new Error(String(thrown), { cause: thrown })\n  }\n}\n\n/**\n * Creates a success result wrapping the given value.\n *\n * @param value - The success value\n * @returns An `Ok` result containing the value\n *\n * @example\n * ```ts\n * const result = ok(42)\n * // { ok: true, value: 42 }\n * ```\n */\nexport function ok<T>(value: T): Ok<T> {\n  return { ok: true, value, error: null }\n}\n\n/**\n * Creates a failure result wrapping the given error.\n *\n * @param error - The error value\n * @returns An `Err` result containing the error\n *\n * @example\n * ```ts\n * const result = err(new Error('fail'))\n * // { ok: false, error: Error('fail') }\n * ```\n */\nexport function err(error: unknown): Err {\n  return { ok: false, value: null, error: coerceError(error) }\n}\n\n/**\n * Type guard that narrows a `Result` to `Ok`.\n *\n * @param result - The result to check\n * @returns `true` if the result is `Ok`\n *\n * @example\n * ```ts\n * const result = attempt(() => JSON.parse('{}'))\n * if (isOk(result)) {\n *   console.log(result.value)\n * }\n * ```\n */\nexport function isOk<T>(result: Result<T>): result is Ok<T> {\n  return result.ok === true\n}\n\n/**\n * Type guard that narrows a `Result` to `Err`.\n *\n * @param result - The result to check\n * @returns `true` if the result is `Err`\n *\n * @example\n * ```ts\n * const result = attempt(() => JSON.parse('bad'))\n * if (isErr(result)) {\n *   console.error(result.error)\n * }\n * ```\n */\nexport function isErr<T>(result: Result<T>): result is Err {\n  return result.ok === false\n}\n\n/**\n * Extract the value from an `Ok` result, or throw on `Err`.\n *\n * When called without a message, throws the original error.\n * When called with a message, throws a new Error with that message\n * and the original error as `cause` (like Rust's `expect`).\n *\n * @param result - The result to unwrap\n * @param message - Optional custom error message (Rust `expect` behavior)\n * @returns The unwrapped value\n *\n * @example\n * ```ts\n * const value = unwrap(ok(42))           // 42\n * unwrap(err('fail'))                    // throws Error('fail')\n * unwrap(err('fail'), 'config required') // throws Error('config required', { cause: Error('fail') })\n * ```\n */\nexport function unwrap<T>(result: Result<T>, message?: string): T {\n  if (result.ok) {\n    return result.value\n  }\n  if (!isNil(message)) {\n    throw new Error(message, { cause: result.error })\n  }\n  throw result.error\n}\n","import { err, ok } from './result.js'\nimport type { Result } from './types.js'\n\n/**\n * Executes a synchronous function and wraps the outcome in a `Result`.\n * Returns `Ok` with the return value on success, `Err` with the thrown value on failure.\n *\n * @param fn - The function to execute\n * @returns A `Result` containing either the value or the error\n *\n * @example\n * ```ts\n * const result = attempt(() => JSON.parse('{\"a\":1}'))\n * if (isOk(result)) {\n *   console.log(result.value) // { a: 1 }\n * }\n * ```\n */\nexport function attempt<T>(fn: () => T): Result<T> {\n  try {\n    return ok(fn())\n  } catch (error) {\n    return err(error)\n  }\n}\n\n/**\n * Executes an asynchronous function and wraps the outcome in a `Result`.\n * Returns `Ok` with the resolved value on success, `Err` with the rejection reason on failure.\n *\n * @param fn - The async function to execute\n * @returns A promise resolving to a `Result` containing either the value or the error\n *\n * @example\n * ```ts\n * const result = await attemptAsync(() => fetch('/api/data'))\n * if (isErr(result)) {\n *   console.error(result.error)\n * }\n * ```\n */\nexport async function attemptAsync<T>(fn: () => Promise<T>): Promise<Result<T>> {\n  try {\n    return ok(await fn())\n  } catch (error) {\n    return err(error)\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,SAAS,YAAY,QAAwB;CAC3C,IAAI,kBAAkB,OACpB,OAAO;CAET,IAAI,OAAO,WAAW,UACpB,OAAO,IAAI,MAAM,OAAO;CAE1B,IAAI;EACF,MAAM,UAAU,KAAK,UAAU,OAAO,IAAI,OAAO,OAAO;EACxD,OAAO,IAAI,MAAM,SAAS,EAAE,OAAO,QAAQ,CAAC;SACtC;EACN,OAAO,IAAI,MAAM,OAAO,OAAO,EAAE,EAAE,OAAO,QAAQ,CAAC;;;;;;;;;;;;;;;AAgBvD,SAAgB,GAAM,OAAiB;CACrC,OAAO;EAAE,IAAI;EAAM;EAAO,OAAO;EAAM;;;;;;;;;;;;;;AAezC,SAAgB,IAAI,OAAqB;CACvC,OAAO;EAAE,IAAI;EAAO,OAAO;EAAM,OAAO,YAAY,MAAM;EAAE;;;;;;;;;;;;;;;;AAiB9D,SAAgB,KAAQ,QAAoC;CAC1D,OAAO,OAAO,OAAO;;;;;;;;;;;;;;;;AAiBvB,SAAgB,MAAS,QAAkC;CACzD,OAAO,OAAO,OAAO;;;;;;;;;;;;;;;;;;;;AAqBvB,SAAgB,OAAU,QAAmB,SAAqB;CAChE,IAAI,OAAO,IACT,OAAO,OAAO;CAEhB,IAAI,CAAC,MAAM,QAAQ,EACjB,MAAM,IAAI,MAAM,SAAS,EAAE,OAAO,OAAO,OAAO,CAAC;CAEnD,MAAM,OAAO;;;;;;;;;;;;;;;;;;;ACpGf,SAAgB,QAAW,IAAwB;CACjD,IAAI;EACF,OAAO,GAAG,IAAI,CAAC;UACR,OAAO;EACd,OAAO,IAAI,MAAM;;;;;;;;;;;;;;;;;;AAmBrB,eAAsB,aAAgB,IAA0C;CAC9E,IAAI;EACF,OAAO,GAAG,MAAM,IAAI,CAAC;UACd,OAAO;EACd,OAAO,IAAI,MAAM"}

package/dist/conversion/index.d.mts

@@ -0,0 +1,2 @@
+import { a as toFinite, c as toString, i as toError, n as toArray, o as toInteger, r as toBoolean, s as toNumber, t as stringify } from "../index-COFf0Pih.mjs";
+export { stringify, toArray, toBoolean, toError, toFinite, toInteger, toNumber, toString };

package/dist/conversion/index.mjs

@@ -0,0 +1,2 @@
+import { a as toFinite, c as toString, i as toError, n as toArray, o as toInteger, r as toBoolean, s as toNumber, t as stringify } from "../conversion-ByBXBR5i.mjs";
+export { stringify, toArray, toBoolean, toError, toFinite, toInteger, toNumber, toString };