massaman 0.4.0 → 0.5.0

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/zrosenbauer/massaman/main/.github/assets/banner.png" alt="massaman" width="100%" />
+  <img src="https://raw.githubusercontent.com/zrosenbauer/massaman/main/.github/assets/banner.svg" alt="massaman" width="100%" />
   <p><strong>Functional programming utilities for TypeScript. Result types, pattern matching, async pipelines. Fully typed.</strong></p>
 
 <a href="https://github.com/zrosenbauer/massaman/actions/workflows/ci.yml"><img src="https://github.com/zrosenbauer/massaman/actions/workflows/ci.yml/badge.svg?branch=main" alt="CI" /></a>
@@ -13,8 +13,8 @@
 - Rust's `match` in TypeScript: exhaustive pattern matching via re-exported [ts-pattern](https://github.com/gvergnaud/ts-pattern).
 - Rust's `Result` in TypeScript: compose fallible operations without throws (`attempt`, `attemptAsync`, `ok`, `err`, `isOk`, `unwrap`).
 - Functional programming, fully typed: `flow`, `flowAsync`, `tap`, `when`, `ifElse`, and point-free combinators with end-to-end inference.
-- The missing pieces around [es-toolkit](https://es-toolkit.dev): variadic-narrowing predicates, async composition, and consistent error normalization on top of the array/object/string/math utilities you already love.
-- Tree-shakeable: 12 focused subpath exports, ESM-only, `sideEffects: false`. Import only what you use.
+- The missing pieces around [es-toolkit](https://es-toolkit.dev): variadic-narrowing predicates, async composition, and consistent error normalization alongside its array, object, string, and math utilities.
+- Tree-shakeable: focused subpath exports, ESM-only, `sideEffects: false`. Import only what you use.
 
 ## Install
 
@@ -26,7 +26,7 @@ npm install massaman
 
 ### From ts-pattern
 
-The `pattern` subpath is a transparent re-export of [ts-pattern](https://github.com/gvergnaud/ts-pattern). Exhaustive matching with full TypeScript inference.
+The `match` subpath re-exports [ts-pattern](https://github.com/gvergnaud/ts-pattern) and adds `P.ok` and `P.err` for Massaman results.
 
 ```ts
 import { match, P } from 'massaman/match'

package/dist/array/index.d.mts

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

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

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

package/dist/{array-DGmsKhoS.mjs.map → array-glQHknc3.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"array-DGmsKhoS.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","/**\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  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large arrays\n  let acc = initial\n  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large arrays\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","/**\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  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large outputs\n  let current = seed\n  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large outputs\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,KAAK;CACxB,IAAI,SAAS,KAAK,QAAQ,MAAM,QAE9B,OAAO,SAAS,GAAG,OAAO,MAAM;CAElC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;ACDA,SAAgB,YAAe,OAA0B;CACvD,OAAO,MAAM,QAAa,KAAK,MAAM,UAAU;EAC7C,IAAI,UAAU,KAAK,SAAS,MAAM,QAAQ,IACxC,IAAI,KAAK,IAAI;EAEf,OAAO;CACT,GAAG,CAAC,CAAC;AACP;;;;;;;;;;;;;;;;;;;;;;ACNA,SAAgB,YACd,OACA,WACA,IACA,SACG;CAEH,IAAI,MAAM;CAEV,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EAEpD,MAAM,QAAQ,MAAM;EACpB,IAAI,CAAC,UAAU,KAAK,KAAK,GACvB,OAAO;EAET,MAAM,GAAG,KAAK,OAAO,KAAK;CAC5B;CACA,OAAO;AACT;;;;;;;;;;;;;;;ACzBA,SAAgB,KACd,OACA,IACA,SACK;CACL,OAAO,MAAM,QACV,QAAQ,MAAM,UAAU;EACvB,MAAM,OAAO,OAAO,OAAO,SAAS;EACpC,OAAO,KAAK,GAAG,MAAM,MAAM,KAAK,CAAC;EACjC,OAAO;CACT,GACA,CAAC,OAAO,CACV;AACF;;;;;;;;;;;ACjBA,SAAgB,OAAU,IAA2D;CACnF,QAAQ,GAAM,MAAS;EACrB,MAAM,KAAK,GAAG,CAAC;EACf,MAAM,KAAK,GAAG,CAAC;EACf,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;EAET,OAAO;CACT;AACF;;;;;;;;;AAUA,SAAgB,QAAW,IAA2D;CACpF,QAAQ,GAAM,MAAS;EACrB,MAAM,KAAK,GAAG,CAAC;EACf,MAAM,KAAK,GAAG,CAAC;EACf,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;EAET,OAAO;CACT;AACF;;;;;;;;;;;;;;;AAgBA,SAAgB,SACd,OACA,aACK;CACL,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,UAAU,GAAG,MAAM;EACnC,KAAK,MAAM,OAAO,aAAa;GAC7B,MAAM,SAAS,IAAI,GAAG,CAAC;GACvB,IAAI,WAAW,GACb,OAAO;EAEX;EACA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;ACpDA,SAAgB,OAAa,IAAiC,MAAc;CAC1E,MAAM,SAAc,CAAC;CAErB,IAAI,UAAU;CAEd,IAAI,OAAO,GAAG,OAAO;CACrB,OAAO,SAAS,OAAO;EACrB,OAAO,KAAK,KAAK,EAAE;EACnB,UAAU,KAAK;EACf,OAAO,GAAG,OAAO;CACnB;CACA,OAAO;AACT"}
+{"version":3,"file":"array-glQHknc3.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","/**\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  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large arrays\n  let acc = initial\n  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large arrays\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","/**\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  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large outputs\n  let current = seed\n  // oxlint-disable-next-line functional/no-let -- iterative impl avoids stack overflow on large outputs\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,KAAK;CACxB,IAAI,SAAS,KAAK,QAAQ,MAAM,QAE9B,OAAO,SAAS,GAAG,OAAO,MAAM;CAElC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;ACDA,SAAgB,YAAe,OAA0B;CACvD,OAAO,MAAM,QAAa,KAAK,MAAM,UAAU;EAC7C,IAAI,UAAU,KAAK,SAAS,MAAM,QAAQ,IACxC,IAAI,KAAK,IAAI;EAEf,OAAO;CACT,GAAG,CAAC,CAAC;AACP;;;;;;;;;;;;;;;;;;;;;;ACNA,SAAgB,YACd,OACA,WACA,IACA,SACG;CAEH,IAAI,MAAM;CAEV,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EAEpD,MAAM,QAAQ,MAAM;EACpB,IAAI,CAAC,UAAU,KAAK,KAAK,GACvB,OAAO;EAET,MAAM,GAAG,KAAK,OAAO,KAAK;CAC5B;CACA,OAAO;AACT;;;;;;;;;;;;;;;ACzBA,SAAgB,KACd,OACA,IACA,SACK;CACL,OAAO,MAAM,QACV,QAAQ,MAAM,UAAU;EACvB,MAAM,OAAO,OAAO,OAAO,SAAS;EACpC,OAAO,KAAK,GAAG,MAAM,MAAM,KAAK,CAAC;EACjC,OAAO;CACT,GACA,CAAC,OAAO,CACV;AACF;;;;;;;;;;;ACjBA,SAAgB,OAAU,IAA2D;CACnF,QAAQ,GAAM,MAAS;EACrB,MAAM,KAAK,GAAG,CAAC;EACf,MAAM,KAAK,GAAG,CAAC;EACf,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;EAET,OAAO;CACT;AACF;;;;;;;;;AAUA,SAAgB,QAAW,IAA2D;CACpF,QAAQ,GAAM,MAAS;EACrB,MAAM,KAAK,GAAG,CAAC;EACf,MAAM,KAAK,GAAG,CAAC;EACf,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;EAET,OAAO;CACT;AACF;;;;;;;;;;;;;;;AAgBA,SAAgB,SACd,OACA,aACK;CACL,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,UAAU,GAAG,MAAM;EACnC,KAAK,MAAM,OAAO,aAAa;GAC7B,MAAM,SAAS,IAAI,GAAG,CAAC;GACvB,IAAI,WAAW,GACb,OAAO;EAEX;EACA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;ACpDA,SAAgB,OAAa,IAAiC,MAAc;CAC1E,MAAM,SAAc,CAAC;CAErB,IAAI,UAAU;CAEd,IAAI,OAAO,GAAG,OAAO;CACrB,OAAO,SAAS,OAAO;EACrB,OAAO,KAAK,KAAK,EAAE;EACnB,UAAU,KAAK;EACf,OAAO,GAAG,OAAO;CACnB;CACA,OAAO;AACT"}

package/dist/bigint/index.d.mts

@@ -0,0 +1,2 @@
+import { clamp, inRange, max, maxBy, median, medianBy, min, minBy, percentile, range, rangeRight, sum, sumBy } from "es-toolkit/bigint";
+export { clamp, inRange, max, maxBy, median, medianBy, min, minBy, percentile, range, rangeRight, sum, sumBy };

package/dist/bigint/index.mjs

@@ -0,0 +1,2 @@
+import { clamp, inRange, max, maxBy, median, medianBy, min, minBy, percentile, range, rangeRight, sum, sumBy } from "es-toolkit/bigint";
+export { clamp, inRange, max, maxBy, median, medianBy, min, minBy, percentile, range, rangeRight, sum, sumBy };

package/dist/control/index.d.mts

@@ -1,3 +1,3 @@
 import { n as Ok, r as Result, t as Err } from "../types-BsimcHZS.mjs";
-import { a as todo, c as isOk, d as attempt, f as attemptAsync, i as unimplemented, l as ok, n as invariant, o as err, r as unreachable, s as isErr, t as assert, u as unwrap } from "../index-DKEiLKtl.mjs";
+import { a as todo, c as isOk, d as attempt, f as attemptAsync, i as unimplemented, l as ok, n as invariant, o as err, r as unreachable, s as isErr, t as assert, u as unwrap } from "../index-D5q3I26j.mjs";
 export { type Err, type Ok, type Result, assert, attempt, attemptAsync, err, invariant, isErr, isOk, ok, todo, unimplemented, unreachable, unwrap };

package/dist/function/index.d.mts

@@ -1,2 +1,2 @@
-import { A as unless, C as retry, D as flowAsync, E as unary, M as call, N as callAsync, O as tap, S as rest, T as throttle, _ as negate, a as ThrottledFunction, b as partial, c as asyncNoop, d as curryRight, f as debounce, g as memoize, h as identity, i as ThrottleOptions, j as when, k as ifElse, l as before, m as flowRight, n as DebouncedFunction, o as after, p as flow, r as MemoizeCache, s as ary, t as DebounceOptions, u as curry, v as noop, w as spread, x as partialRight, y as once } from "../index-CoCKuspw.mjs";
+import { A as unless, C as retry, D as flowAsync, E as unary, M as call, N as callAsync, O as tap, S as rest, T as throttle, _ as negate, a as ThrottledFunction, b as partial, c as asyncNoop, d as curryRight, f as debounce, g as memoize, h as identity, i as ThrottleOptions, j as when, k as ifElse, l as before, m as flowRight, n as DebouncedFunction, o as after, p as flow, r as MemoizeCache, s as ary, t as DebounceOptions, u as curry, v as noop, w as spread, x as partialRight, y as once } from "../index-DlZyDxI_.mjs";
 export { type DebounceOptions, type DebouncedFunction, type MemoizeCache, type ThrottleOptions, type ThrottledFunction, after, ary, asyncNoop, before, call, callAsync, curry, curryRight, debounce, flow, flowAsync, flowRight, identity, ifElse, memoize, negate, noop, once, partial, partialRight, rest, retry, spread, tap, throttle, unary, unless, when };

package/dist/{index-B9ig68hj.d.mts → index-BPYJOreI.d.mts}

@@ -1,5 +1,4 @@
-import { at, cartesianProduct, chunk, chunkBy, combinations, 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";
-
+import { at, cartesianProduct, chunk, chunkBy, combinations, 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, 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.d.ts
 /**
  * Applies a function to the element at the given index, returning a new array.
@@ -130,5 +129,5 @@ declare function sortWith<T>(array: readonly T[], comparators: ReadonlyArray<(a:
  */
 declare function unfold<T, R>(fn: (seed: T) => [R, T] | false, seed: T): R[];
 //#endregion
-export { toFilled as $, isSubset as A, pull as B, forEachRight as C, adjust as Ct, intersection as D, initial as E, mapAsync as F, sampleSize as G, reduceAsync as H, maxBy as I, tail as J, shuffle as K, minBy as L, keyBy as M, last as N, intersectionBy as O, limitAsync as P, takeWhile as Q, orderBy as R, forEachAsync as S, dropRepeats as St, head as T, remove as U, pullAt as V, sample as W, takeRight as X, take as Y, takeRightWhile as Z, flatMap as _, ascend as _t, combinations as a, uniqWith as at, flatten as b, scan as bt, difference as c, windowed as ct, drop as d, xorBy as dt, union as et, dropRight as f, xorWith as ft, filterAsync as g, unfold as gt, fill as h, zipWith as ht, chunkBy as i, uniqBy as it, isSubsetWith as j, intersectionWith as k, differenceBy as l, without as lt, dropWhile as m, zipObject as mt, cartesianProduct as n, unionWith as nt, compact as o, unzip as ot, dropRightWhile as p, zip as pt, sortBy as q, chunk as r, uniq as rt, countBy as s, unzipWith as st, at as t, unionBy as tt, differenceWith as u, xor as ut, flatMapAsync as v, descend as vt, groupBy as w, flattenDeep as x, reduceWhile as xt, flatMapDeep as y, sortWith as yt, partition as z };
-//# sourceMappingURL=index-B9ig68hj.d.mts.map
+export { union as $, isSubset as A, pullAt as B, forEachRight as C, intersection as D, initial as E, maxBy as F, shuffle as G, remove as H, minBy as I, take as J, sortBy as K, orderBy as L, keyBy as M, last as N, intersectionBy as O, mapAsync as P, toFilled as Q, partition as R, forEachAsync as S, adjust as St, head as T, sample as U, reduceAsync as V, sampleSize as W, takeRightWhile as X, takeRight as Y, takeWhile as Z, flatMap as _, descend as _t, combinations as a, unzip as at, flatten as b, reduceWhile as bt, difference as c, without as ct, drop as d, xorWith as dt, unionBy as et, dropRight as f, zip as ft, filterAsync as g, ascend as gt, fill as h, unfold as ht, chunkBy as i, uniqWith as it, isSubsetWith as j, intersectionWith as k, differenceBy as l, xor as lt, dropWhile as m, zipWith as mt, cartesianProduct as n, uniq as nt, compact as o, unzipWith as ot, dropRightWhile as p, zipObject as pt, tail as q, chunk as r, uniqBy as rt, countBy as s, windowed as st, at as t, unionWith as tt, differenceWith as u, xorBy as ut, flatMapAsync as v, sortWith as vt, groupBy as w, flattenDeep as x, dropRepeats as xt, flatMapDeep as y, scan as yt, pull as z };
+//# sourceMappingURL=index-BPYJOreI.d.mts.map

package/dist/index-BPYJOreI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BPYJOreI.d.mts","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"],"mappings":";;;;;;;;;;;;;;iBAYgB,OAAO,GAAG,gBAAgB,KAAK,eAAe,KAAK,OAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;iBCMpE,YAAY,GAAG,gBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;iBCCrC,YAAY,GAAG,GAC7B,gBAAgB,KAChB,YAAY,aAAa,GAAG,OAAO,eACnC,KAAK,aAAa,GAAG,OAAO,GAAG,kBAAkB,GACjD,SAAS,IACR;;;;;;;;;;;;;;;iBCZa,KAAK,GAAG,GACtB,gBAAgB,KAChB,KAAK,aAAa,GAAG,OAAO,GAAG,kBAAkB,GACjD,SAAS,IACR;;;;;;;;;;;iBCRa,OAAO,GAAG,KAAK,OAAO,yBAAyB,GAAG,GAAG,GAAG;;;;;;;;;iBAsBxD,QAAQ,GAAG,KAAK,OAAO,yBAAyB,GAAG,GAAG,GAAG;;;;;;;;;;;;;;;iBA4BzD,SAAS,GACvB,gBAAgB,KAChB,aAAa,eAAe,GAAG,GAAG,GAAG,gBACpC;;;;;;;;;;;;;;;;;;;;;;iBC1Ca,OAAO,GAAG,GAAG,KAAK,MAAM,OAAO,GAAG,YAAY,MAAM,IAAI"}

package/dist/index-C7dxY5U-.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index-C7dxY5U-.d.mts","names":[],"sources":["../src/conversion/convert.ts"],"mappings":";;AAwBA;;;;AAA+C;AA8B/C;;;;AAAwC;AAiFxC;;;;AAAuC;AAgBvC;;;;AAAuC;AAavC;iBA5IgB,OAAA,CAAQ,MAAA,YAAkB,KAAK;;;AA4IP;AAexC;;;;AAAuC;AAwBvC;;;;;;;;;;;;iBArJgB,SAAA,CAAU,KAAc;;;;AAqJgC;AA0BxE;;;;AAAwC;;;;;iBA9FxB,QAAA,CAAS,KAAc;;;;;;;;;;;;;iBAgBvB,QAAA,CAAS,KAAc;;;;;;;;;;iBAavB,SAAA,CAAU,KAAc;;;;;;;;;;;;iBAexB,QAAA,CAAS,KAAc;;;;;;;;;;;;;;;;;iBAwBvB,OAAA,IAAW,KAAA,EAAO,QAAA,CAAS,CAAA,IAAK,CAAA,sBAAuB,CAAA;;;;;;;;;;;;;;iBA0BvD,SAAA,CAAU,KAAc"}
+{"version":3,"file":"index-C7dxY5U-.d.mts","names":[],"sources":["../src/conversion/convert.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAwBgB,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBA8B1B,UAAU;;;;;;;;;;;;;;iBAiFV,SAAS;;;;;;;;;;;;;iBAgBT,SAAS;;;;;;;;;;iBAaT,UAAU;;;;;;;;;;;;iBAeV,SAAS;;;;;;;;;;;;;;;;;iBAwBT,QAAQ,GAAG,OAAO,SAAS,KAAK,uBAAuB;;;;;;;;;;;;;;iBA0BvD,UAAU"}

package/dist/{index-DKEiLKtl.d.mts → index-D5q3I26j.d.mts}

@@ -1,6 +1,5 @@
 import { n as Ok, r as Result, t as Err } from "./types-BsimcHZS.mjs";
 import { assert, invariant } from "es-toolkit/util";
-
 //#region src/control/attempt.d.ts
 /**
  * Executes a synchronous function and wraps the outcome in a `Result`.
@@ -183,4 +182,4 @@ declare function unimplemented(message?: string): never;
 declare function unreachable(message?: string): never;
 //#endregion
 export { todo as a, isOk as c, attempt as d, attemptAsync as f, unimplemented as i, ok as l, invariant as n, err as o, unreachable as r, isErr as s, assert as t, unwrap as u };
-//# sourceMappingURL=index-DKEiLKtl.d.mts.map
+//# sourceMappingURL=index-D5q3I26j.d.mts.map

package/dist/index-D5q3I26j.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D5q3I26j.d.mts","names":[],"sources":["../src/control/attempt.ts","../src/control/result.ts","../src/control/todo.ts","../src/control/unimplemented.ts","../src/control/unreachable.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAkBgB,QAAQ,GAAG,UAAU,IAAI,OAAO;;;;;;;;;;;;;;;;iBAuB1B,aAAa,GAAG,UAAU,QAAQ,KAAK,QAAQ,OAAO;;;;;;;;;;;;;;;iBCJ5D,GAAG,GAAG,OAAO,IAAI,GAAG;;;;;;;;;;;;;iBAgBpB,IAAI,iBAAiB;;;;;;;;;;;;;;;iBAkBrB,KAAK,GAAG,QAAQ,OAAO,KAAK,UAAU,GAAG;;;;;;;;;;;;;;;iBAkBzC,MAAM,GAAG,QAAQ,OAAO,KAAK,UAAU;;;;;;;;;;;;;;;;;;;iBAsBvC,OAAO,GAAG,QAAQ,OAAO,IAAI,mBAAmB;;;;;;;;;;;;;;;;;;;;iBC5FhD,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;iBCML,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBCFd,YAAY"}

package/dist/{index-CQAReq7e.d.mts → index-D7DGVrkN.d.mts}

@@ -1,5 +1,4 @@
 import { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError as isError$1, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap as isMap$1, isNil as isNil$1, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive as isPrimitive$1, isPromise, isRegExp, isSet as isSet$1, isString as isString$1, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet } from "es-toolkit/predicate";
-
 //#region src/types/internal.d.ts
 /**
  * Explicit alias for `any` that makes dangerous intent visible at the call site.
@@ -183,4 +182,4 @@ declare function isInteger(value: unknown): value is number;
 declare function isNaN(value: unknown): value is number;
 //#endregion
 export { isString$1 as A, isNaN as B, isNull as C, isPromise as D, isPrimitive$1 as E, isWeakSet as F, both as G, isObject as H, isArray as I, either as K, isEmpty as L, isTypedArray as M, isUndefined as N, isRegExp as O, isWeakMap as P, isFiniteNumber as R, isNotNil as S, isPlainObject as T, allPass as U, isNotEmpty as V, anyPass as W, isJSONValue as _, isBuffer as a, isNil$1 as b, isEqual as c, isFile as d, isFunction as f, isJSONObject as g, isJSONArray as h, isBrowser as i, isSymbol as j, isSet$1 as k, isEqualWith as l, isJSON as m, isBlob as n, isDate as o, isIterable as p, isBoolean as r, isEmptyObject as s, isArrayBuffer as t, isError$1 as u, isLength as v, isNumber as w, isNode as x, isMap$1 as y, isInteger as z };
-//# sourceMappingURL=index-CQAReq7e.d.mts.map
+//# sourceMappingURL=index-D7DGVrkN.d.mts.map

package/dist/index-D7DGVrkN.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D7DGVrkN.d.mts","names":[],"sources":["../src/types/internal.ts","../src/predicate/combinators.ts","../src/predicate/guards.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KAkBY;;;;;;;;;;;;;;;;;;;;;iBCEI,QAAQ,GAAG,2BAA2B,OAAO;iBAC7C,QAAQ,WAAW,eAAe,OAAO,kCACvD,YAAY,MACV,OAAO,WAAW,QAAQ,SAAS,WAAW,MAAM,oBAAoB,QAAQ;;;;;;;;;;;;;;;;;;iBAwBpE,QAAQ,GAAG,2BAA2B,OAAO;iBAC7C,QAAQ,WAAW,eAAe,OAAO,kCACvD,YAAY,MACV,OAAO,WAAW,QAAQ,SAAS,WAAW,MAAM,QAAQ;;;;;;;;;;;;;iBAmBhD,KAAK,GAAG,UAAU,GAAG,UAAU,GAC7C,IAAI,OAAO,MAAM,SAAS,GAC1B,IAAI,OAAO,MAAM,SAAS,KACxB,OAAO,MAAM,SAAS,IAAI;iBACd,KAAK,GAAG,IAAI,OAAO,eAAe,IAAI,OAAO,iBAAiB,OAAO;;;;;;;;;;;;;iBAiBrE,OAAO,GAAG,UAAU,GAAG,UAAU,GAC/C,IAAI,OAAO,MAAM,SAAS,GAC1B,IAAI,OAAO,MAAM,SAAS,KACxB,OAAO,MAAM,SAAS,IAAI;iBACd,OAAO,GAAG,IAAI,OAAO,eAAe,IAAI,OAAO,iBAAiB,OAAO;;;;;KAYlF,QAAQ,KAAK,YAAY,OAAO,wBAAwB,eAAe,KAAK;;;;;KAM5E,WAAW,MAAM,WAAW,eAAe,aAAa,iBAAiB;KAEzE,oBAAoB,MAAM,qBAAqB,GAAG,8BACrD,SAAS,cAEP;;;;;;;;;;;;iBC5GY,QAAQ,iBAAiB;;;;;;;;;;;;;iBAgBzB,SAAS,iBAAiB;;;;;;;;;;;;;;;;;iBAoB1B,QAAQ;;;;;;;;;;iBAmBR,WAAW;;;;;;;;;;iBAaX,eAAe,iBAAiB;;;;;;;;;;iBAahC,UAAU,iBAAiB;;;;;;;;;;iBAa3B,MAAM,iBAAiB"}

package/dist/index-DTrYN2UY.d.mts

@@ -0,0 +1,20 @@
+import { clone, cloneDeep, cloneDeepWith, deepFreeze, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys } from "es-toolkit/object";
+import { ToCamelCaseKeys, ToConstantCaseKeys, ToKebabCaseKeys, ToPascalCaseKeys, ToSnakeCaseKeys } from "es-toolkit/types";
+//#region src/object/evolve.d.ts
+/**
+ * Applies a spec of transformation functions to matching keys of an object,
+ * returning a new object. Keys not in the spec are copied as-is.
+ *
+ * @example
+ * ```ts
+ * evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {
+ *   name: (s) => s.trim(),
+ *   age: (n) => n + 1,
+ * })
+ * // { name: 'Alice', age: 30, role: 'admin' }
+ * ```
+ */
+declare function evolve<T extends Record<string, unknown>>(obj: T, spec: { [K in keyof T]?: (value: T[K]) => T[K]; }): T;
+//#endregion
+export { evolve as A, sortKeys as C, toMerged as D, toKebabCaseKeys as E, toPascalCaseKeys as O, pickBy as S, toConstantCaseKeys as T, merge as _, ToSnakeCaseKeys as a, omitBy as b, cloneDeepWith as c, flattenObject as d, invert as f, mapValuesAsync as g, mapValues as h, ToPascalCaseKeys as i, toSnakeCaseKeys as k, deepFreeze as l, mapKeysAsync as m, ToConstantCaseKeys as n, clone as o, mapKeys as p, ToKebabCaseKeys as r, cloneDeep as s, ToCamelCaseKeys as t, findKey as u, mergeWith as v, toCamelCaseKeys as w, pick as x, omit as y };
+//# sourceMappingURL=index-DTrYN2UY.d.mts.map

package/dist/index-DTrYN2UY.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DTrYN2UY.d.mts","names":[],"sources":["../src/object/evolve.ts"],"mappings":";;;;;;;;;;;;;;;;iBAagB,OAAO,UAAU,yBAC/B,KAAK,GACL,SAAS,WAAW,MAAM,OAAO,EAAE,OAAO,EAAE,QAC3C"}

package/dist/{index-DPhfdSi7.d.mts → index-DcVpX2Bb.d.mts}

@@ -1,27 +1,31 @@
 import { n as Ok$1, t as Err$1 } from "./types-BsimcHZS.mjs";
-import { NonExhaustiveError, P, Pattern, isMatching, match } from "ts-pattern";
-
+import { NonExhaustiveError, P, Pattern, isMatching, match as match$1 } from "ts-pattern";
 //#region src/match/match.d.ts
+declare function okPattern(): {
+  ok: true;
+};
+declare function okPattern<const pattern extends P.Pattern<unknown>>(pattern: pattern): {
+  ok: true;
+  value: pattern;
+};
+declare function errPattern(): {
+  ok: false;
+};
+declare function errPattern<const pattern extends P.Pattern<unknown>>(pattern: pattern): {
+  ok: false;
+  error: pattern;
+};
 /**
  * Extended ts-pattern `P` namespace. Carries everything ts-pattern exports
- * (`P.string`, `P.number`, `P.array`, `P.when`, …) plus `P.ok` / `P.err`
- * for matching `Result` values.
- *
- * Explicit literal-type annotations on the additions (rather than `as const`)
- * keep the values non-`readonly`, which ts-pattern's narrowing requires —
- * a `readonly` pattern collapses the remaining input to `never` after the
- * first arm, breaking exhaustiveness.
+ * (`P.string`, `P.number`, `P.array`, `P.when`, …) plus `P.ok()` / `P.err()`
+ * for matching `Result` values and their contents.
  *
  * For the `P.Pattern<T>` type shorthand, import `Pattern` standalone from
  * `massaman/match` — it's the form ts-pattern's own docs recommend.
  */
 declare const P$1: typeof P & {
-  ok: {
-    ok: true;
-  };
-  err: {
-    ok: false;
-  };
+  ok: typeof okPattern;
+  err: typeof errPattern;
 };
 /**
  * The `Ok` variant of a `Result<T>`. Re-exported here so the value-side
@@ -35,5 +39,5 @@ type Ok<T> = Ok$1<T>;
  */
 type Err = Err$1;
 //#endregion
-export { Err as a, match as i, Pattern as n, Ok as o, isMatching as r, P$1 as s, NonExhaustiveError as t };
-//# sourceMappingURL=index-DPhfdSi7.d.mts.map
+export { Err as a, match$1 as i, Pattern as n, Ok as o, isMatching as r, P$1 as s, NonExhaustiveError as t };
+//# sourceMappingURL=index-DcVpX2Bb.d.mts.map

package/dist/index-DcVpX2Bb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DcVpX2Bb.d.mts","names":[],"sources":["../src/match/match.ts"],"mappings":";;;iBAuBS;EAAe;;iBACf,gBAAgB,gBAAgB,EAAI,kBAC3C,SAAS;EACN;EAAU,OAAO;;iBASb;EAAgB;;iBAChB,iBAAiB,gBAAgB,EAAI,kBAC5C,SAAS;EACN;EAAW,OAAO;;;;;;;;;;cAiBV,YAAU;EAAQ,WAAW;EAAW,YAAY;;;;;;;;KAYrD,GAAG,KAAK,KAAO;;;;KAKf,MAAM"}

package/dist/{index-CoCKuspw.d.mts → index-DlZyDxI_.d.mts}

@@ -1,5 +1,4 @@
 import { DebounceOptions, DebouncedFunction, MemoizeCache, ThrottleOptions, ThrottledFunction, after, ary, asyncNoop, before, curry, curryRight, debounce, flow, flowRight, identity, memoize, negate, noop, once, partial, partialRight, rest, retry, spread, throttle, unary } from "es-toolkit/function";
-
 //#region src/function/call.d.ts
 /**
  * Invokes a function with the provided arguments and returns the result.
@@ -117,4 +116,4 @@ declare function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5, R6>
 declare function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5, R6, R7>(f1: (...args: A) => MaybePromise<R1>, f2: (a: Awaited<R1>) => MaybePromise<R2>, f3: (a: Awaited<R2>) => MaybePromise<R3>, f4: (a: Awaited<R3>) => MaybePromise<R4>, f5: (a: Awaited<R4>) => MaybePromise<R5>, f6: (a: Awaited<R5>) => MaybePromise<R6>, f7: (a: Awaited<R6>) => MaybePromise<R7>): (...args: A) => Promise<Awaited<R7>>;
 //#endregion
 export { unless as A, retry as C, flowAsync as D, unary as E, call as M, callAsync as N, tap as O, rest as S, throttle as T, negate as _, ThrottledFunction as a, partial as b, asyncNoop as c, curryRight as d, debounce as f, memoize as g, identity as h, ThrottleOptions as i, when as j, ifElse as k, before as l, flowRight as m, DebouncedFunction as n, after as o, flow as p, MemoizeCache as r, ary as s, DebounceOptions as t, curry as u, noop as v, spread as w, partialRight as x, once as y };
-//# sourceMappingURL=index-CoCKuspw.d.mts.map
+//# sourceMappingURL=index-DlZyDxI_.d.mts.map

package/dist/index-DlZyDxI_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DlZyDxI_.d.mts","names":[],"sources":["../src/function/call.ts","../src/function/branching.ts","../src/function/tap.ts","../src/function/flowAsync.ts"],"mappings":";;;;;;;;;;;;;;;;iBAcgB,KAAK,8BAA8B,GAAG,QAAQ,MAAM,MAAM,MAAM,MAAM,IAAI;;;;;;;;;;;;;iBAgBpE,UAAU,8BAA8B,GAC5D,QAAQ,MAAM,MAAM,QAAQ,OACzB,MAAM,IACR,QAAQ;;;;;;;;;;;;;iBCvBK,KAAK,GAAG,YAAY,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK,OAAO,MAAM;;;;;;;;;;;;;;iBAsB9E,OAAO,GAAG,YAAY,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK,OAAO,MAAM;;;;;;;;;;;;;;;iBAuBhF,OAAO,GAAG,GACxB,YAAY,OAAO,eACnB,SAAS,OAAO,MAAM,GACtB,UAAU,OAAO,MAAM,KACrB,OAAO,MAAM;;;;;;;;;;;;;;;;;iBC7CD,IAAI,GAAG,KAAK,OAAO,iBAAiB,OAAO,MAAM;;;KCZ5D,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;;;;;;iBAmBnB,UAAU,8BAA8B,IACtD,QAAQ,MAAM,MAAM,aAAa,UAC5B,MAAM,MAAM,QAAQ,QAAQ;iBACnB,UAAU,8BAA8B,IAAI,IAC1D,QAAQ,MAAM,MAAM,aAAa,KACjC,KAAK,GAAG,QAAQ,QAAQ,aAAa,UAChC,MAAM,MAAM,QAAQ,QAAQ;iBACnB,UAAU,8BAA8B,IAAI,IAAI,IAC9D,QAAQ,MAAM,MAAM,aAAa,KACjC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,UAChC,MAAM,MAAM,QAAQ,QAAQ;iBACnB,UAAU,8BAA8B,IAAI,IAAI,IAAI,IAClE,QAAQ,MAAM,MAAM,aAAa,KACjC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,UAChC,MAAM,MAAM,QAAQ,QAAQ;iBACnB,UAAU,8BAA8B,IAAI,IAAI,IAAI,IAAI,IACtE,QAAQ,MAAM,MAAM,aAAa,KACjC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,UAChC,MAAM,MAAM,QAAQ,QAAQ;iBACnB,UAAU,8BAA8B,IAAI,IAAI,IAAI,IAAI,IAAI,IAC1E,QAAQ,MAAM,MAAM,aAAa,KACjC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,UAChC,MAAM,MAAM,QAAQ,QAAQ;iBACnB,UAAU,8BAA8B,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAC9E,QAAQ,MAAM,MAAM,aAAa,KACjC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,KACrC,KAAK,GAAG,QAAQ,QAAQ,aAAa,UAChC,MAAM,MAAM,QAAQ,QAAQ"}

package/dist/index.d.mts

@@ -1,13 +1,13 @@
-import { $ as toFilled, A as isSubset, B as pull, C as forEachRight, Ct as adjust, D as intersection, E as initial, F as mapAsync, G as sampleSize, H as reduceAsync, I as maxBy, J as tail, K as shuffle, L as minBy, M as keyBy, N as last, O as intersectionBy, P as limitAsync, Q as takeWhile, R as orderBy, S as forEachAsync, St as dropRepeats, T as head, U as remove, V as pullAt, W as sample, X as takeRight, Y as take, Z as takeRightWhile, _ as flatMap, _t as ascend, a as combinations, at as uniqWith, b as flatten, bt as scan, c as difference, ct as windowed, d as drop, dt as xorBy, et as union, f as dropRight, ft as xorWith, g as filterAsync, gt as unfold, h as fill, ht as zipWith, i as chunkBy, it as uniqBy, j as isSubsetWith, k as intersectionWith, l as differenceBy, lt as without, m as dropWhile, mt as zipObject, n as cartesianProduct, nt as unionWith, o as compact, ot as unzip, p as dropRightWhile, pt as zip, q as sortBy, r as chunk, rt as uniq, s as countBy, st as unzipWith, t as at, tt as unionBy, u as differenceWith, ut as xor, v as flatMapAsync, vt as descend, w as groupBy, x as flattenDeep, xt as reduceWhile, y as flatMapDeep, yt as sortWith, z as partition } from "./index-B9ig68hj.mjs";
+import { $ as union, A as isSubset, B as pullAt, C as forEachRight, D as intersection, E as initial, F as maxBy, G as shuffle, H as remove, I as minBy, J as take, K as sortBy, L as orderBy, M as keyBy, N as last, O as intersectionBy, P as mapAsync, Q as toFilled, R as partition, S as forEachAsync, St as adjust, T as head, U as sample, V as reduceAsync, W as sampleSize, X as takeRightWhile, Y as takeRight, Z as takeWhile, _ as flatMap, _t as descend, a as combinations, at as unzip, b as flatten, bt as reduceWhile, c as difference, ct as without, d as drop, dt as xorWith, et as unionBy, f as dropRight, ft as zip, g as filterAsync, gt as ascend, h as fill, ht as unfold, i as chunkBy, it as uniqWith, j as isSubsetWith, k as intersectionWith, l as differenceBy, lt as xor, m as dropWhile, mt as zipWith, n as cartesianProduct, nt as uniq, o as compact, ot as unzipWith, p as dropRightWhile, pt as zipObject, q as tail, r as chunk, rt as uniqBy, s as countBy, st as windowed, t as at, tt as unionWith, u as differenceWith, ut as xorBy, v as flatMapAsync, vt as sortWith, w as groupBy, x as flattenDeep, xt as dropRepeats, y as flatMapDeep, yt as scan, z as pull } from "./index-BPYJOreI.mjs";
 import { r as Result } from "./types-BsimcHZS.mjs";
-import { a as todo, c as isOk, d as attempt, f as attemptAsync, i as unimplemented, l as ok, n as invariant, o as err, r as unreachable, s as isErr, t as assert, u as unwrap } from "./index-DKEiLKtl.mjs";
+import { a as todo, c as isOk, d as attempt, f as attemptAsync, i as unimplemented, l as ok, n as invariant, o as err, r as unreachable, s as isErr, t as assert, u as unwrap } from "./index-D5q3I26j.mjs";
 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-C7dxY5U-.mjs";
 import { AbortError, TimeoutError } from "./error/index.mjs";
-import { A as unless, C as retry, D as flowAsync, E as unary, M as call, N as callAsync, O as tap, S as rest, T as throttle, _ as negate, a as ThrottledFunction, b as partial, c as asyncNoop, d as curryRight, f as debounce, g as memoize, h as identity, i as ThrottleOptions, j as when, k as ifElse, l as before, m as flowRight, n as DebouncedFunction, o as after, p as flow, r as MemoizeCache, s as ary, t as DebounceOptions, u as curry, v as noop, w as spread, x as partialRight, y as once } from "./index-CoCKuspw.mjs";
+import { A as unless, C as retry, D as flowAsync, E as unary, M as call, N as callAsync, O as tap, S as rest, T as throttle, _ as negate, a as ThrottledFunction, b as partial, c as asyncNoop, d as curryRight, f as debounce, g as memoize, h as identity, i as ThrottleOptions, j as when, k as ifElse, l as before, m as flowRight, n as DebouncedFunction, o as after, p as flow, r as MemoizeCache, s as ary, t as DebounceOptions, u as curry, v as noop, w as spread, x as partialRight, y as once } from "./index-DlZyDxI_.mjs";
 import { clamp, inRange, mean, meanBy, median, medianBy, percentile, random, randomInt, range, rangeRight, round, sum, sumBy } from "./math/index.mjs";
-import { _ as toMerged, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toCamelCaseKeys, h as sortKeys, i as findKey, l as merge, m as pickBy, n as cloneDeep, o as invert, p as pick, r as cloneDeepWith, s as mapKeys, t as clone, u as mergeWith, v as toSnakeCaseKeys, y as evolve } from "./index-D5qkz-H4.mjs";
-import { A as isString, B as isNaN, C as isNull, D as isPromise, E as isPrimitive, F as isWeakSet, G as both, H as isObject, I as isArray, K as either, L as isEmpty, M as isTypedArray, N as isUndefined, O as isRegExp, P as isWeakMap, R as isFiniteNumber, S as isNotNil, T as isPlainObject, U as allPass, V as isNotEmpty, W as anyPass, _ as isJSONValue, a as isBuffer, b as isNil, c as isEqual, d as isFile, f as isFunction, g as isJSONObject, h as isJSONArray, i as isBrowser, j as isSymbol, k as isSet, l as isEqualWith, m as isJSON, n as isBlob, o as isDate, p as isIterable, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isLength, w as isNumber, x as isNode, y as isMap, z as isInteger } from "./index-CQAReq7e.mjs";
-import { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout } from "./promise/index.mjs";
-import { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "./string/index.mjs";
-import { a as Err, i as match, n as Pattern, o as Ok, r as isMatching, s as P, t as NonExhaustiveError } from "./index-DPhfdSi7.mjs";
-export { AbortError, type DebounceOptions, type DebouncedFunction, type Err, type MemoizeCache, Mutex, NonExhaustiveError, type Ok, P, Pattern, type Result, Semaphore, type ThrottleOptions, type ThrottledFunction, TimeoutError, adjust, after, allKeyed, allPass, anyPass, ary, ascend, assert, asyncNoop, at, attempt, attemptAsync, before, both, call, callAsync, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, descend, difference, differenceBy, differenceWith, drop, dropRepeats, dropRight, dropRightWhile, dropWhile, either, err, escape, escapeRegExp, evolve, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowAsync, flowRight, forEachAsync, forEachRight, groupBy, head, identity, ifElse, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isErr, isError, isFile, isFiniteNumber, isFunction, isInteger, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isMatching, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isOk, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, match, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, ok, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, reduceWhile, remove, rest, retry, reverseString, round, sample, sampleSize, scan, shuffle, snakeCase, sortBy, sortKeys, sortWith, spread, startCase, stringify, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, tap, throttle, timeout, toArray, toBoolean, toCamelCaseKeys, toError, toFilled, toFinite, toInteger, toMerged, toNumber, toSnakeCaseKeys, toString, todo, trim, trimEnd, trimStart, unary, unescape, unfold, unimplemented, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unless, unreachable, unwrap, unzip, unzipWith, upperCase, upperFirst, when, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+import { A as evolve, C as sortKeys, D as toMerged, E as toKebabCaseKeys, O as toPascalCaseKeys, S as pickBy, T as toConstantCaseKeys, _ as merge, a as ToSnakeCaseKeys, b as omitBy, c as cloneDeepWith, d as flattenObject, f as invert, g as mapValuesAsync, h as mapValues, i as ToPascalCaseKeys, k as toSnakeCaseKeys, l as deepFreeze, m as mapKeysAsync, n as ToConstantCaseKeys, o as clone, p as mapKeys, r as ToKebabCaseKeys, s as cloneDeep, t as ToCamelCaseKeys, u as findKey, v as mergeWith, w as toCamelCaseKeys, x as pick, y as omit } from "./index-DTrYN2UY.mjs";
+import { A as isString, B as isNaN, C as isNull, D as isPromise, E as isPrimitive, F as isWeakSet, G as both, H as isObject, I as isArray, K as either, L as isEmpty, M as isTypedArray, N as isUndefined, O as isRegExp, P as isWeakMap, R as isFiniteNumber, S as isNotNil, T as isPlainObject, U as allPass, V as isNotEmpty, W as anyPass, _ as isJSONValue, a as isBuffer, b as isNil, c as isEqual, d as isFile, f as isFunction, g as isJSONObject, h as isJSONArray, i as isBrowser, j as isSymbol, k as isSet, l as isEqualWith, m as isJSON, n as isBlob, o as isDate, p as isIterable, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isLength, w as isNumber, x as isNode, y as isMap, z as isInteger } from "./index-D7DGVrkN.mjs";
+import { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout } from "./promise/index.mjs";
+import { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "./string/index.mjs";
+import { a as Err, i as match, n as Pattern, o as Ok, r as isMatching, s as P, t as NonExhaustiveError } from "./index-DcVpX2Bb.mjs";
+export { AbortError, type DebounceOptions, type DebouncedFunction, type Err, type MemoizeCache, Mutex, NonExhaustiveError, type Ok, P, Pattern, type Result, Semaphore, type ThrottleOptions, type ThrottledFunction, TimeoutError, type ToCamelCaseKeys, type ToConstantCaseKeys, type ToKebabCaseKeys, type ToPascalCaseKeys, type ToSnakeCaseKeys, adjust, after, allKeyed, allPass, anyPass, ary, ascend, assert, asyncNoop, at, attempt, attemptAsync, before, both, call, callAsync, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, dedent, deepFreeze, delay, descend, difference, differenceBy, differenceWith, drop, dropRepeats, dropRight, dropRightWhile, dropWhile, either, err, escape, escapeRegExp, evolve, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowAsync, flowRight, forEachAsync, forEachRight, groupBy, head, identity, ifElse, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isErr, isError, isFile, isFiniteNumber, isFunction, isInteger, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isMatching, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isOk, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, match, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, ok, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, reduceWhile, remove, rest, retry, reverseString, round, sample, sampleSize, scan, shuffle, snakeCase, sortBy, sortKeys, sortWith, spread, startCase, stringify, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, tap, throttle, timeout, toArray, toBoolean, toCamelCaseKeys, toConstantCaseKeys, toError, toFilled, toFinite, toInteger, toKebabCaseKeys, toMerged, toNumber, toPascalCaseKeys, toSnakeCaseKeys, toString, todo, trim, trimEnd, trimStart, unary, unescape, unfold, unimplemented, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unless, unreachable, unwrap, unzip, unzipWith, upperCase, upperFirst, when, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/index.mjs

@@ -1,12 +1,12 @@
-import { $ as toFilled, A as isSubset, B as pull, C as forEachRight, Ct as adjust, D as intersection, E as initial, F as mapAsync, G as sampleSize, H as reduceAsync, I as maxBy, J as tail, K as shuffle, L as minBy, M as keyBy, N as last, O as intersectionBy, P as limitAsync, Q as takeWhile, R as orderBy, S as forEachAsync, St as dropRepeats, T as head, U as remove, V as pullAt, W as sample, X as takeRight, Y as take, Z as takeRightWhile, _ as flatMap, _t as ascend, a as combinations, at as uniqWith, b as flatten, bt as scan, c as difference, ct as windowed, d as drop, dt as xorBy, et as union, f as dropRight, ft as xorWith, g as filterAsync, gt as unfold, h as fill, ht as zipWith, i as chunkBy, it as uniqBy, j as isSubsetWith, k as intersectionWith, l as differenceBy, lt as without, m as dropWhile, mt as zipObject, n as cartesianProduct, nt as unionWith, o as compact, ot as unzip, p as dropRightWhile, pt as zip, q as sortBy, r as chunk, rt as uniq, s as countBy, st as unzipWith, t as at, tt as unionBy, u as differenceWith, ut as xor, v as flatMapAsync, vt as descend, w as groupBy, x as flattenDeep, xt as reduceWhile, y as flatMapDeep, yt as sortWith, z as partition } from "./array-DGmsKhoS.mjs";
+import { $ as union, A as isSubset, B as pullAt, C as forEachRight, D as intersection, E as initial, F as maxBy, G as shuffle, H as remove, I as minBy, J as take, K as sortBy, L as orderBy, M as keyBy, N as last, O as intersectionBy, P as mapAsync, Q as toFilled, R as partition, S as forEachAsync, St as adjust, T as head, U as sample, V as reduceAsync, W as sampleSize, X as takeRightWhile, Y as takeRight, Z as takeWhile, _ as flatMap, _t as descend, a as combinations, at as unzip, b as flatten, bt as reduceWhile, c as difference, ct as without, d as drop, dt as xorWith, et as unionBy, f as dropRight, ft as zip, g as filterAsync, gt as ascend, h as fill, ht as unfold, i as chunkBy, it as uniqWith, j as isSubsetWith, k as intersectionWith, l as differenceBy, lt as xor, m as dropWhile, mt as zipWith, n as cartesianProduct, nt as uniq, o as compact, ot as unzipWith, p as dropRightWhile, pt as zipObject, q as tail, r as chunk, rt as uniqBy, s as countBy, st as windowed, t as at, tt as unionWith, u as differenceWith, ut as xorBy, v as flatMapAsync, vt as sortWith, w as groupBy, x as flattenDeep, xt as dropRepeats, y as flatMapDeep, yt as scan, z as pull } from "./array-glQHknc3.mjs";
 import { AbortError, TimeoutError } from "./error/index.mjs";
 import { C as tap, D as call, E as when, O as callAsync, S as flowAsync, T as unless, _ as rest, a as curry, b as throttle, c as flow, d as memoize, f as negate, g as partialRight, h as partial, i as before, l as flowRight, m as once, n as ary, o as curryRight, p as noop, r as asyncNoop, s as debounce, t as after, u as identity, v as retry, w as ifElse, x as unary, y as spread } from "./function-Brosl7-Y.mjs";
 import { clamp, inRange, mean, meanBy, median, medianBy, percentile, random, randomInt, range, rangeRight, round, sum, sumBy } from "./math/index.mjs";
-import { _ as toMerged, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toCamelCaseKeys, h as sortKeys, i as findKey, l as merge, m as pickBy, n as cloneDeep, o as invert, p as pick, r as cloneDeepWith, s as mapKeys, t as clone, u as mergeWith, v as toSnakeCaseKeys, y as evolve } from "./object-DUAxOgHi.mjs";
+import { C as toPascalCaseKeys, S as toMerged, T as evolve, _ as pickBy, a as findKey, b as toConstantCaseKeys, c as mapKeys, d as mapValuesAsync, f as merge, g as pick, h as omitBy, i as deepFreeze, l as mapKeysAsync, m as omit, n as cloneDeep, o as flattenObject, p as mergeWith, r as cloneDeepWith, s as invert, t as clone, u as mapValues, v as sortKeys, w as toSnakeCaseKeys, x as toKebabCaseKeys, y as toCamelCaseKeys } from "./object-CILtZbTT.mjs";
 import { A as isString, B as isNaN, C as isNull, D as isPromise, E as isPrimitive, F as isWeakSet, G as both, H as isObject, I as isArray, K as either, L as isEmpty, M as isTypedArray, N as isUndefined, O as isRegExp, P as isWeakMap, R as isFiniteNumber, S as isNotNil, T as isPlainObject, U as allPass, V as isNotEmpty, W as anyPass, _ as isJSONValue, a as isBuffer, b as isNil, c as isEqual, d as isFile, f as isFunction, g as isJSONObject, h as isJSONArray, i as isBrowser, j as isSymbol, k as isSet, l as isEqualWith, m as isJSON, n as isBlob, o as isDate, p as isIterable, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isLength, w as isNumber, x as isNode, y as isMap, z as isInteger } from "./predicate-CleUejOb.mjs";
 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-BB912-15.mjs";
-import { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout } from "./promise/index.mjs";
-import { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "./string/index.mjs";
+import { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout } from "./promise/index.mjs";
+import { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "./string/index.mjs";
 import { a as todo, c as err, d as ok, f as unwrap, i as unimplemented, l as isErr, n as invariant, o as attempt, r as unreachable, s as attemptAsync, t as assert, u as isOk } from "./control-DCdm8IH6.mjs";
-import { a as P, i as match, n as Pattern, r as isMatching, t as NonExhaustiveError } from "./match-uR6HPDRb.mjs";
-export { AbortError, Mutex, NonExhaustiveError, P, Pattern, Semaphore, TimeoutError, adjust, after, allKeyed, allPass, anyPass, ary, ascend, assert, asyncNoop, at, attempt, attemptAsync, before, both, call, callAsync, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, descend, difference, differenceBy, differenceWith, drop, dropRepeats, dropRight, dropRightWhile, dropWhile, either, err, escape, escapeRegExp, evolve, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowAsync, flowRight, forEachAsync, forEachRight, groupBy, head, identity, ifElse, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isErr, isError, isFile, isFiniteNumber, isFunction, isInteger, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isMatching, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isOk, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, match, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, ok, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, reduceWhile, remove, rest, retry, reverseString, round, sample, sampleSize, scan, shuffle, snakeCase, sortBy, sortKeys, sortWith, spread, startCase, stringify, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, tap, throttle, timeout, toArray, toBoolean, toCamelCaseKeys, toError, toFilled, toFinite, toInteger, toMerged, toNumber, toSnakeCaseKeys, toString, todo, trim, trimEnd, trimStart, unary, unescape, unfold, unimplemented, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unless, unreachable, unwrap, unzip, unzipWith, upperCase, upperFirst, when, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+import { a as P, i as match, n as Pattern, r as isMatching, t as NonExhaustiveError } from "./match-fBetfaIa.mjs";
+export { AbortError, Mutex, NonExhaustiveError, P, Pattern, Semaphore, TimeoutError, adjust, after, allKeyed, allPass, anyPass, ary, ascend, assert, asyncNoop, at, attempt, attemptAsync, before, both, call, callAsync, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, dedent, deepFreeze, delay, descend, difference, differenceBy, differenceWith, drop, dropRepeats, dropRight, dropRightWhile, dropWhile, either, err, escape, escapeRegExp, evolve, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowAsync, flowRight, forEachAsync, forEachRight, groupBy, head, identity, ifElse, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isErr, isError, isFile, isFiniteNumber, isFunction, isInteger, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isMatching, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isOk, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, match, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, ok, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, reduceWhile, remove, rest, retry, reverseString, round, sample, sampleSize, scan, shuffle, snakeCase, sortBy, sortKeys, sortWith, spread, startCase, stringify, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, tap, throttle, timeout, toArray, toBoolean, toCamelCaseKeys, toConstantCaseKeys, toError, toFilled, toFinite, toInteger, toKebabCaseKeys, toMerged, toNumber, toPascalCaseKeys, toSnakeCaseKeys, toString, todo, trim, trimEnd, trimStart, unary, unescape, unfold, unimplemented, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unless, unreachable, unwrap, unzip, unzipWith, upperCase, upperFirst, when, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/match/index.d.mts

@@ -1,2 +1,2 @@
-import { a as Err, i as match, n as Pattern, o as Ok, r as isMatching, s as P, t as NonExhaustiveError } from "../index-DPhfdSi7.mjs";
+import { a as Err, i as match, n as Pattern, o as Ok, r as isMatching, s as P, t as NonExhaustiveError } from "../index-DcVpX2Bb.mjs";
 export { type Err, NonExhaustiveError, type Ok, P, Pattern, isMatching, match };

package/dist/match/index.mjs

@@ -1,2 +1,2 @@
-import { a as P, i as match, n as Pattern, r as isMatching, t as NonExhaustiveError } from "../match-uR6HPDRb.mjs";
+import { a as P, i as match, n as Pattern, r as isMatching, t as NonExhaustiveError } from "../match-fBetfaIa.mjs";
 export { NonExhaustiveError, P, Pattern, isMatching, match };

package/dist/match-fBetfaIa.mjs

@@ -0,0 +1,49 @@
+import { NonExhaustiveError, P, Pattern, isMatching, match, match as match$1 } from "ts-pattern";
+//#region src/match/match.ts
+/**
+* Extends ts-pattern's `P` namespace with `P.ok()` and `P.err()` — pattern
+* factories for matching a `Result` and its contained value or error.
+*
+* Mirrors Rust's `Ok(value)` / `Err(error)` match arms, but uses the
+* namespace-method form (`P.ok()` / `P.err()`) so it doesn't collide with
+* the lowercase `ok()` / `err()` constructors from `massaman/control`.
+*
+* @example
+* ```ts
+* import { match, P, attempt } from 'massaman'
+*
+* match(attempt(() => JSON.parse(raw)))
+*   .with(P.ok(), ({ value }) => use(value))
+*   .with(P.err(), ({ error }) => log(error))
+*   .exhaustive()
+* ```
+*/
+function okPattern(...patterns) {
+	return match(patterns).with([], () => ({ ok: true })).otherwise(([pattern]) => ({
+		ok: true,
+		value: pattern
+	}));
+}
+function errPattern(...patterns) {
+	return match(patterns).with([], () => ({ ok: false })).otherwise(([pattern]) => ({
+		ok: false,
+		error: pattern
+	}));
+}
+/**
+* Extended ts-pattern `P` namespace. Carries everything ts-pattern exports
+* (`P.string`, `P.number`, `P.array`, `P.when`, …) plus `P.ok()` / `P.err()`
+* for matching `Result` values and their contents.
+*
+* For the `P.Pattern<T>` type shorthand, import `Pattern` standalone from
+* `massaman/match` — it's the form ts-pattern's own docs recommend.
+*/
+const P$1 = {
+	...P,
+	ok: okPattern,
+	err: errPattern
+};
+//#endregion
+export { P$1 as a, match$1 as i, Pattern as n, isMatching as r, NonExhaustiveError as t };
+
+//# sourceMappingURL=match-fBetfaIa.mjs.map

package/dist/match-fBetfaIa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-fBetfaIa.mjs","names":["matchValue","P","TsP"],"sources":["../src/match/match.ts"],"sourcesContent":["/**\n * Extends ts-pattern's `P` namespace with `P.ok()` and `P.err()` — pattern\n * factories for matching a `Result` and its contained value or error.\n *\n * Mirrors Rust's `Ok(value)` / `Err(error)` match arms, but uses the\n * namespace-method form (`P.ok()` / `P.err()`) so it doesn't collide with\n * the lowercase `ok()` / `err()` constructors from `massaman/control`.\n *\n * @example\n * ```ts\n * import { match, P, attempt } from 'massaman'\n *\n * match(attempt(() => JSON.parse(raw)))\n *   .with(P.ok(), ({ value }) => use(value))\n *   .with(P.err(), ({ error }) => log(error))\n *   .exhaustive()\n * ```\n */\n\nimport { match as matchValue, P as TsP } from 'ts-pattern'\n\nimport type { Err as ErrType, Ok as OkType } from '../control/types.js'\n\nfunction okPattern(): { ok: true }\nfunction okPattern<const pattern extends TsP.Pattern<unknown>>(\n  pattern: pattern\n): { ok: true; value: pattern }\nfunction okPattern(\n  ...patterns: readonly [] | readonly [TsP.Pattern<unknown>]\n): { ok: true } | { ok: true; value: TsP.Pattern<unknown> } {\n  return matchValue(patterns)\n    .with([], () => ({ ok: true as const }))\n    .otherwise(([pattern]) => ({ ok: true as const, value: pattern }))\n}\n\nfunction errPattern(): { ok: false }\nfunction errPattern<const pattern extends TsP.Pattern<unknown>>(\n  pattern: pattern\n): { ok: false; error: pattern }\nfunction errPattern(\n  ...patterns: readonly [] | readonly [TsP.Pattern<unknown>]\n): { ok: false } | { ok: false; error: TsP.Pattern<unknown> } {\n  return matchValue(patterns)\n    .with([], () => ({ ok: false as const }))\n    .otherwise(([pattern]) => ({ ok: false as const, error: pattern }))\n}\n\n/**\n * Extended ts-pattern `P` namespace. Carries everything ts-pattern exports\n * (`P.string`, `P.number`, `P.array`, `P.when`, …) plus `P.ok()` / `P.err()`\n * for matching `Result` values and their contents.\n *\n * For the `P.Pattern<T>` type shorthand, import `Pattern` standalone from\n * `massaman/match` — it's the form ts-pattern's own docs recommend.\n */\nexport const P: typeof TsP & { ok: typeof okPattern; err: typeof errPattern } = {\n  ...TsP,\n  ok: okPattern,\n  err: errPattern,\n}\n\n/**\n * The `Ok` variant of a `Result<T>`. Re-exported here so the value-side\n * patterns and the type-side `Ok<T>` live in one module — any consumer\n * import gets both type and value namespaces without cross-module merge\n * issues (TS2300).\n */\nexport type Ok<T> = OkType<T>\n\n/**\n * The `Err` variant of a `Result<T>`. See {@link Ok} for the co-location note.\n */\nexport type Err = ErrType\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA2BA,SAAS,UACP,GAAG,UACuD;CAC1D,OAAOA,MAAW,QAAQ,CAAC,CACxB,KAAK,CAAC,UAAU,EAAE,IAAI,KAAc,EAAE,CAAC,CACvC,WAAW,CAAC,cAAc;EAAE,IAAI;EAAe,OAAO;CAAQ,EAAE;AACrE;AAMA,SAAS,WACP,GAAG,UACyD;CAC5D,OAAOA,MAAW,QAAQ,CAAC,CACxB,KAAK,CAAC,UAAU,EAAE,IAAI,MAAe,EAAE,CAAC,CACxC,WAAW,CAAC,cAAc;EAAE,IAAI;EAAgB,OAAO;CAAQ,EAAE;AACtE;;;;;;;;;AAUA,MAAaC,MAAmE;CAC9E,GAAGC;CACH,IAAI;CACJ,KAAK;AACP"}

package/dist/object/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as toMerged, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toCamelCaseKeys, h as sortKeys, i as findKey, l as merge, m as pickBy, n as cloneDeep, o as invert, p as pick, r as cloneDeepWith, s as mapKeys, t as clone, u as mergeWith, v as toSnakeCaseKeys, y as evolve } from "../index-D5qkz-H4.mjs";
-export { clone, cloneDeep, cloneDeepWith, evolve, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys };
+import { A as evolve, C as sortKeys, D as toMerged, E as toKebabCaseKeys, O as toPascalCaseKeys, S as pickBy, T as toConstantCaseKeys, _ as merge, a as ToSnakeCaseKeys, b as omitBy, c as cloneDeepWith, d as flattenObject, f as invert, g as mapValuesAsync, h as mapValues, i as ToPascalCaseKeys, k as toSnakeCaseKeys, l as deepFreeze, m as mapKeysAsync, n as ToConstantCaseKeys, o as clone, p as mapKeys, r as ToKebabCaseKeys, s as cloneDeep, t as ToCamelCaseKeys, u as findKey, v as mergeWith, w as toCamelCaseKeys, x as pick, y as omit } from "../index-DTrYN2UY.mjs";
+export { type ToCamelCaseKeys, type ToConstantCaseKeys, type ToKebabCaseKeys, type ToPascalCaseKeys, type ToSnakeCaseKeys, clone, cloneDeep, cloneDeepWith, deepFreeze, evolve, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/index.mjs

@@ -1,2 +1,2 @@
-import { _ as toMerged, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toCamelCaseKeys, h as sortKeys, i as findKey, l as merge, m as pickBy, n as cloneDeep, o as invert, p as pick, r as cloneDeepWith, s as mapKeys, t as clone, u as mergeWith, v as toSnakeCaseKeys, y as evolve } from "../object-DUAxOgHi.mjs";
-export { clone, cloneDeep, cloneDeepWith, evolve, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys };
+import { C as toPascalCaseKeys, S as toMerged, T as evolve, _ as pickBy, a as findKey, b as toConstantCaseKeys, c as mapKeys, d as mapValuesAsync, f as merge, g as pick, h as omitBy, i as deepFreeze, l as mapKeysAsync, m as omit, n as cloneDeep, o as flattenObject, p as mergeWith, r as cloneDeepWith, s as invert, t as clone, u as mapValues, v as sortKeys, w as toSnakeCaseKeys, x as toKebabCaseKeys, y as toCamelCaseKeys } from "../object-CILtZbTT.mjs";
+export { clone, cloneDeep, cloneDeepWith, deepFreeze, evolve, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object-CILtZbTT.mjs

@@ -0,0 +1,27 @@
+import { clone, cloneDeep, cloneDeepWith, deepFreeze, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys } from "es-toolkit/object";
+//#region src/object/evolve.ts
+/**
+* Applies a spec of transformation functions to matching keys of an object,
+* returning a new object. Keys not in the spec are copied as-is.
+*
+* @example
+* ```ts
+* evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {
+*   name: (s) => s.trim(),
+*   age: (n) => n + 1,
+* })
+* // { name: 'Alice', age: 30, role: 'admin' }
+* ```
+*/
+function evolve(obj, spec) {
+	const result = { ...obj };
+	for (const key of Object.keys(spec)) {
+		const transform = spec[key];
+		if (transform != null && key in result) result[key] = transform(result[key]);
+	}
+	return result;
+}
+//#endregion
+export { toPascalCaseKeys as C, toMerged as S, evolve as T, pickBy as _, findKey as a, toConstantCaseKeys as b, mapKeys as c, mapValuesAsync as d, merge as f, pick as g, omitBy as h, deepFreeze as i, mapKeysAsync as l, omit as m, cloneDeep as n, flattenObject as o, mergeWith as p, cloneDeepWith as r, invert as s, clone as t, mapValues as u, sortKeys as v, toSnakeCaseKeys as w, toKebabCaseKeys as x, toCamelCaseKeys as y };
+
+//# sourceMappingURL=object-CILtZbTT.mjs.map

package/dist/{object-DUAxOgHi.mjs.map → object-CILtZbTT.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"object-DUAxOgHi.mjs","names":[],"sources":["../src/object/evolve.ts"],"sourcesContent":["/**\n * Applies a spec of transformation functions to matching keys of an object,\n * returning a new object. Keys not in the spec are copied as-is.\n *\n * @example\n * ```ts\n * evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {\n *   name: (s) => s.trim(),\n *   age: (n) => n + 1,\n * })\n * // { name: 'Alice', age: 30, role: 'admin' }\n * ```\n */\nexport function evolve<T extends Record<string, unknown>>(\n  obj: T,\n  spec: { [K in keyof T]?: (value: T[K]) => T[K] }\n): T {\n  const result = { ...obj }\n  for (const key of Object.keys(spec) as Array<keyof T>) {\n    // oxlint-disable-next-line security/detect-object-injection -- key sourced from Object.keys(spec), not user input\n    const transform = spec[key]\n    if (transform != null && key in result) {\n      // oxlint-disable-next-line security/detect-object-injection -- key sourced from Object.keys(spec), not user input\n      result[key] = transform(result[key])\n    }\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;AAaA,SAAgB,OACd,KACA,MACG;CACH,MAAM,SAAS,EAAE,GAAG,IAAI;CACxB,KAAK,MAAM,OAAO,OAAO,KAAK,IAAI,GAAqB;EAErD,MAAM,YAAY,KAAK;EACvB,IAAI,aAAa,QAAQ,OAAO,QAE9B,OAAO,OAAO,UAAU,OAAO,IAAI;CAEvC;CACA,OAAO;AACT"}
+{"version":3,"file":"object-CILtZbTT.mjs","names":[],"sources":["../src/object/evolve.ts"],"sourcesContent":["/**\n * Applies a spec of transformation functions to matching keys of an object,\n * returning a new object. Keys not in the spec are copied as-is.\n *\n * @example\n * ```ts\n * evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {\n *   name: (s) => s.trim(),\n *   age: (n) => n + 1,\n * })\n * // { name: 'Alice', age: 30, role: 'admin' }\n * ```\n */\nexport function evolve<T extends Record<string, unknown>>(\n  obj: T,\n  spec: { [K in keyof T]?: (value: T[K]) => T[K] }\n): T {\n  const result = { ...obj }\n  for (const key of Object.keys(spec) as Array<keyof T>) {\n    // oxlint-disable-next-line security/detect-object-injection -- key sourced from Object.keys(spec), not user input\n    const transform = spec[key]\n    if (transform != null && key in result) {\n      // oxlint-disable-next-line security/detect-object-injection -- key sourced from Object.keys(spec), not user input\n      result[key] = transform(result[key])\n    }\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;AAaA,SAAgB,OACd,KACA,MACG;CACH,MAAM,SAAS,EAAE,GAAG,IAAI;CACxB,KAAK,MAAM,OAAO,OAAO,KAAK,IAAI,GAAqB;EAErD,MAAM,YAAY,KAAK;EACvB,IAAI,aAAa,QAAQ,OAAO,QAE9B,OAAO,OAAO,UAAU,OAAO,IAAI;CAEvC;CACA,OAAO;AACT"}

package/dist/predicate/index.d.mts

@@ -1,2 +1,2 @@
-import { A as isString, B as isNaN, C as isNull, D as isPromise, E as isPrimitive, F as isWeakSet, G as both, H as isObject, I as isArray, K as either, L as isEmpty, M as isTypedArray, N as isUndefined, O as isRegExp, P as isWeakMap, R as isFiniteNumber, S as isNotNil, T as isPlainObject, U as allPass, V as isNotEmpty, W as anyPass, _ as isJSONValue, a as isBuffer, b as isNil, c as isEqual, d as isFile, f as isFunction, g as isJSONObject, h as isJSONArray, i as isBrowser, j as isSymbol, k as isSet, l as isEqualWith, m as isJSON, n as isBlob, o as isDate, p as isIterable, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isLength, w as isNumber, x as isNode, y as isMap, z as isInteger } from "../index-CQAReq7e.mjs";
+import { A as isString, B as isNaN, C as isNull, D as isPromise, E as isPrimitive, F as isWeakSet, G as both, H as isObject, I as isArray, K as either, L as isEmpty, M as isTypedArray, N as isUndefined, O as isRegExp, P as isWeakMap, R as isFiniteNumber, S as isNotNil, T as isPlainObject, U as allPass, V as isNotEmpty, W as anyPass, _ as isJSONValue, a as isBuffer, b as isNil, c as isEqual, d as isFile, f as isFunction, g as isJSONObject, h as isJSONArray, i as isBrowser, j as isSymbol, k as isSet, l as isEqualWith, m as isJSON, n as isBlob, o as isDate, p as isIterable, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isLength, w as isNumber, x as isNode, y as isMap, z as isInteger } from "../index-D7DGVrkN.mjs";
 export { allPass, anyPass, both, either, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFiniteNumber, isFunction, isInteger, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/promise/index.d.mts

@@ -1,2 +1,2 @@
-import { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout } from "es-toolkit/promise";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+import { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout } from "es-toolkit/promise";
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.mjs

@@ -1,2 +1,2 @@
-import { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout } from "es-toolkit/promise";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+import { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout } from "es-toolkit/promise";
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/string/index.d.mts

@@ -1,2 +1,2 @@
-import { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "es-toolkit/string";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+import { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "es-toolkit/string";
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/string/index.mjs

@@ -1,2 +1,2 @@
-import { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "es-toolkit/string";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+import { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "es-toolkit/string";
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/types-BsimcHZS.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types-BsimcHZS.d.mts","names":[],"sources":["../src/control/types.ts"],"mappings":";;AAQA;;;;;;;UAAiB,EAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA,EAAO,CAAC;EAAA,SACR,KAAA;AAAA;;;;;;;;;UAWM,GAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,KAAA,EAAO,KAAK;AAAA;;;;;;;;;;AAcY;;KAAvB,MAAA,MAAY,EAAA,CAAG,CAAA,IAAK,GAAA"}
+{"version":3,"file":"types-BsimcHZS.d.mts","names":[],"sources":["../src/control/types.ts"],"mappings":";;;;;;;;;UAQiB,GAAG;WACT;WACA,OAAO;WACP;;;;;;;;;;UAWM;WACN;WACA;WACA,OAAO;;;;;;;;;;;;;KAcN,OAAO,KAAK,GAAG,KAAK"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "massaman",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A comprehensive functional programming library and utilities for TypeScript",
   "keywords": [
     "es-toolkit",
@@ -43,6 +43,10 @@
       "types": "./dist/array/index.d.mts",
       "import": "./dist/array/index.mjs"
     },
+    "./bigint": {
+      "types": "./dist/bigint/index.d.mts",
+      "import": "./dist/bigint/index.mjs"
+    },
     "./object": {
       "types": "./dist/object/index.d.mts",
       "import": "./dist/object/index.mjs"
@@ -89,25 +93,24 @@
     "provenance": true
   },
   "dependencies": {
-    "es-toolkit": "1.50.0",
+    "es-toolkit": "1.51.0",
     "ts-pattern": "5.9.0"
   },
   "devDependencies": {
-    "@types/node": "^25.9.3",
-    "@typescript/native-preview": "7.0.0-dev.20260611.2",
-    "@vitest/coverage-v8": "^4.1.8",
-    "tsdown": "0.22.2",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.8",
+    "@types/node": "^26.2.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    "tsdown": "0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
     "@massaman/tsconfig": "0.0.0"
   },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=26.0.0"
   },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsgo --noEmit"
+    "typecheck": "tsc --noEmit"
   }
 }

package/dist/index-B9ig68hj.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B9ig68hj.d.mts","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"],"mappings":";;;;;;AAYA;;;;;;;;;iBAAgB,MAAA,IAAU,KAAA,WAAgB,CAAA,IAAK,KAAA,UAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,CAAA;;;;;;AAApF;;;;;;;;;;;;;;;iBCMgB,WAAA,IAAe,KAAA,WAAgB,CAAA,KAAM,CAAC;;;;;;ADNtD;;;;;;;;;;;;;;;;iBEOgB,WAAA,OACd,KAAA,WAAgB,CAAA,IAChB,SAAA,GAAY,WAAA,EAAa,CAAA,EAAG,KAAA,EAAO,CAAA,cACnC,EAAA,GAAK,WAAA,EAAa,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,aAAkB,CAAA,EACjD,OAAA,EAAS,CAAA,GACR,CAAA;;;;;;AFZH;;;;;;;;;iBGAgB,IAAA,OACd,KAAA,WAAgB,CAAA,IAChB,EAAA,GAAK,WAAA,EAAa,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAA,aAAkB,CAAA,EACjD,OAAA,EAAS,CAAA,GACR,CAAA;;;;;;AHJH;;;;;iBIJgB,MAAA,IAAU,EAAA,GAAK,KAAA,EAAO,CAAA,wBAAyB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA;;;;;;;;;iBAsBxD,OAAA,IAAW,EAAA,GAAK,KAAA,EAAO,CAAA,wBAAyB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA;;;;;AJlBY;;;;ACMrF;;;;;;iBGwCgB,QAAA,IACd,KAAA,WAAgB,CAAA,IAChB,WAAA,EAAa,aAAA,EAAe,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACpC,CAAA;;;;;;AJjDH;;;;;;;;;;;;;;;;iBKOgB,MAAA,OAAa,EAAA,GAAK,IAAA,EAAM,CAAA,MAAO,CAAA,EAAG,CAAA,WAAY,IAAA,EAAM,CAAA,GAAI,CAAA"}

package/dist/index-CQAReq7e.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CQAReq7e.d.mts","names":[],"sources":["../src/types/internal.ts","../src/predicate/combinators.ts","../src/predicate/guards.ts"],"mappings":";;;;;;AAkBA;;;;AAA+B;;;;ACE/B;;;;;;KDFY,mBAAA;;;;;AAAZ;;;;AAA+B;;;;ACE/B;;;;;;;;iBAAgB,OAAA,IAAW,UAAA,iBAA2B,KAAA,EAAO,CAAC;AAAA,iBAC9C,OAAA,YAAmB,aAAA,EAAe,KAAA,EAAO,mBAAA,eACvD,UAAA,EAAY,EAAA,IACV,KAAA,EAAO,UAAA,CAAW,EAAA,MAAQ,KAAA,IAAS,UAAA,CAAW,EAAA,IAAM,mBAAA,CAAoB,OAAA,CAAQ,EAAA;AAFpF;;;;;;;;;;;;;;;;;AAAA,iBA0BgB,OAAA,IAAW,UAAA,iBAA2B,KAAA,EAAO,CAAC;AAAA,iBAC9C,OAAA,YAAmB,aAAA,EAAe,KAAA,EAAO,mBAAA,eACvD,UAAA,EAAY,EAAA,IACV,KAAA,EAAO,UAAA,CAAW,EAAA,MAAQ,KAAA,IAAS,UAAA,CAAW,EAAA,IAAM,OAAA,CAAQ,EAAA;;;;;;;;;;;;;iBAmBhD,IAAA,cAAkB,CAAA,YAAa,CAAA,EAC7C,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,CAAA,EAC1B,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,CAAA,IACxB,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,CAAA,GAAI,CAAA;AAAA,iBACd,IAAA,IAAQ,CAAA,GAAI,KAAA,EAAO,CAAA,cAAe,CAAA,GAAI,KAAA,EAAO,CAAA,gBAAiB,KAAA,EAAO,CAAA;;;;;;;;;AA1BvB;AAC9D;;;iBA0CgB,MAAA,cAAoB,CAAA,YAAa,CAAA,EAC/C,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,CAAA,EAC1B,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,CAAA,IACxB,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,CAAA,GAAI,CAAA;AAAA,iBACd,MAAA,IAAU,CAAA,GAAI,KAAA,EAAO,CAAA,cAAe,CAAA,GAAI,KAAA,EAAO,CAAA,gBAAiB,KAAA,EAAO,CAAA;;;;;KAYlF,OAAA,MAAa,CAAA,WAAY,KAAA,EAAO,mBAAmB,KAAK,KAAA,eAAoB,CAAA;;;;;KAM5E,UAAA,OAAiB,EAAA,SAAW,aAAa,EAAE,KAAA,yBAA8B,CAAA;AAAA,KAEzE,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAC,6BACtD,CAAA,sBAEE,CAAA;;;;;;ADnGJ;;;;AAA+B;;iBETf,OAAA,CAAQ,KAAA,YAAiB,KAAK;;ADW9C;;;;;;;;;AAA8D;AAC9D;iBCIgB,QAAA,CAAS,KAAA,YAAiB,KAAK;;;;;;;;;;;;;;;;;iBAoB/B,OAAA,CAAQ,KAAsB;;;;;;;;;;iBAmB9B,UAAA,CAAW,KAAsB;;;ADzCqC;AAwBtF;;;;;;iBC8BgB,cAAA,CAAe,KAAA,YAAiB,KAAK;;;AD9BS;AAC9D;;;;;;iBC0CgB,SAAA,CAAU,KAAA,YAAiB,KAAK;;;;;;;;;;iBAahC,KAAA,CAAM,KAAA,YAAiB,KAAK"}

package/dist/index-CoCKuspw.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CoCKuspw.d.mts","names":[],"sources":["../src/function/call.ts","../src/function/branching.ts","../src/function/tap.ts","../src/function/flowAsync.ts"],"mappings":";;;;;;AAcA;;;;;;;;;;;iBAAgB,IAAA,kCAAsC,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,CAAA,KAAM,IAAA,EAAM,CAAA,GAAI,CAAA;;;;;;;;AAAC;AAgB3F;;;;iBAAsB,SAAA,kCACpB,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,CAAA,MACzB,IAAA,EAAM,CAAA,GACR,OAAA,CAAQ,CAAA;;;;;;AAnBX;;;;;;;iBCJgB,IAAA,IAAQ,SAAA,GAAY,KAAA,EAAO,CAAA,cAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,IAAK,KAAA,EAAO,CAAA,KAAM,CAAA;;;;;;;;;;;;ADIH;AAgB3F;iBCEgB,MAAA,IAAU,SAAA,GAAY,KAAA,EAAO,CAAA,cAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,IAAK,KAAA,EAAO,CAAA,KAAM,CAAA;;;;;;;;;;;;;;;iBAuBhF,MAAA,OACd,SAAA,GAAY,KAAA,EAAO,CAAA,cACnB,MAAA,GAAS,KAAA,EAAO,CAAA,KAAM,CAAA,EACtB,OAAA,GAAU,KAAA,EAAO,CAAA,KAAM,CAAA,IACrB,KAAA,EAAO,CAAA,KAAM,CAAA;;;;;;AD7CjB;;;;;;;;;;;iBEAgB,GAAA,IAAO,EAAA,GAAK,KAAA,EAAO,CAAA,gBAAiB,KAAA,EAAO,CAAA,KAAM,CAAA;;;KCZ5D,YAAA,MAAkB,CAAA,GAAI,OAAA,CAAQ,CAAA;;;AHYnC;;;;;;;;;;;;;;;iBGOgB,SAAA,mCACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,QAC5B,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA;AAAA,iBACnB,SAAA,uCACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,GACjC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,QAChC,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA;AAAA,iBACnB,SAAA,2CACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,GACjC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,QAChC,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA;AAAA,iBACnB,SAAA,+CACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,GACjC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,QAChC,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA;AAAA,iBACnB,SAAA,mDACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,GACjC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,QAChC,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA;AAAA,iBACnB,SAAA,uDACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,GACjC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,QAChC,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA;AAAA,iBACnB,SAAA,2DACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,EAAA,GACjC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,GACrC,EAAA,GAAK,CAAA,EAAG,OAAA,CAAQ,EAAA,MAAQ,YAAA,CAAa,EAAA,QAChC,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,EAAA"}

package/dist/index-D5qkz-H4.d.mts

@@ -1,20 +0,0 @@
-import { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys } from "es-toolkit/object";
-
-//#region src/object/evolve.d.ts
-/**
- * Applies a spec of transformation functions to matching keys of an object,
- * returning a new object. Keys not in the spec are copied as-is.
- *
- * @example
- * ```ts
- * evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {
- *   name: (s) => s.trim(),
- *   age: (n) => n + 1,
- * })
- * // { name: 'Alice', age: 30, role: 'admin' }
- * ```
- */
-declare function evolve<T extends Record<string, unknown>>(obj: T, spec: { [K in keyof T]?: (value: T[K]) => T[K] }): T;
-//#endregion
-export { toMerged as _, flattenObject as a, mapValues as c, omit as d, omitBy as f, toCamelCaseKeys as g, sortKeys as h, findKey as i, merge as l, pickBy as m, cloneDeep as n, invert as o, pick as p, cloneDeepWith as r, mapKeys as s, clone as t, mergeWith as u, toSnakeCaseKeys as v, evolve as y };
-//# sourceMappingURL=index-D5qkz-H4.d.mts.map

package/dist/index-D5qkz-H4.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-D5qkz-H4.d.mts","names":[],"sources":["../src/object/evolve.ts"],"mappings":";;;;;;AAaA;;;;;;;;;;iBAAgB,MAAA,WAAiB,MAAA,mBAC/B,GAAA,EAAK,CAAA,EACL,IAAA,gBAAoB,CAAA,KAAM,KAAA,EAAO,CAAA,CAAE,CAAA,MAAO,CAAA,CAAE,CAAA,MAC3C,CAAA"}

package/dist/index-DKEiLKtl.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DKEiLKtl.d.mts","names":[],"sources":["../src/control/attempt.ts","../src/control/result.ts","../src/control/todo.ts","../src/control/unimplemented.ts","../src/control/unreachable.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;;iBAAgB,OAAA,IAAW,EAAA,QAAU,CAAA,GAAI,MAAA,CAAO,CAAA;;AAAC;AAuBjD;;;;;;;;;;;;;iBAAsB,YAAA,IAAgB,EAAA,QAAU,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,MAAA,CAAO,CAAA;;;;;;AAvB5E;;;;;;;;;iBCmBgB,EAAA,IAAM,KAAA,EAAO,CAAA,GAAI,EAAA,CAAG,CAAA;;;;;ADnBa;AAuBjD;;;;;;;iBCYgB,GAAA,CAAI,KAAA,YAAiB,GAAG;;;;;;;;;;;ADZqC;;;;iBC8B7D,IAAA,IAAQ,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,EAAA,CAAG,CAAA;;;;;;;;;;;;;;AAlCpB;iBAoDrB,KAAA,IAAS,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,GAAA;;;;AApCf;AAkBxC;;;;;;;;;;;;;;iBAwCgB,MAAA,IAAU,MAAA,EAAQ,MAAA,CAAO,CAAA,GAAI,OAAA,YAAmB,CAAA;;;;;;;AD7FhE;;;;;;;;;;;;;iBECgB,IAAA,CAAK,OAAgB;;;;;;;AFDrC;;;;;;;;;;;;;;AAAiD;AAuBjD;;;;iBGhBgB,aAAA,CAAc,OAAgB;;;;;;;AHP9C;;;;;;;;;;;;;;AAAiD;AAuBjD;;iBIlBgB,WAAA,CAAY,OAAgB"}

package/dist/index-DPhfdSi7.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DPhfdSi7.d.mts","names":[],"sources":["../src/match/match.ts"],"mappings":";;;;;;;AAmD4B;AAK5B;;;;AAAyB;;;;;cAjBZ,GAAA,SAAU,CAAG;EAAK,EAAA;IAAM,EAAA;EAAA;EAAY,GAAA;IAAO,EAAA;EAAA;AAAA;;;;;;;KAY5C,EAAA,MAAQ,IAAM,CAAC,CAAA;;;;KAKf,GAAA,GAAM,KAAO"}

package/dist/match-uR6HPDRb.mjs

@@ -1,44 +0,0 @@
-import { NonExhaustiveError, P, Pattern, isMatching, match } from "ts-pattern";
-//#region src/match/match.ts
-/**
-* Extends ts-pattern's `P` namespace with `P.ok` and `P.err` — structural
-* patterns for matching a `Result` inside `match()`.
-*
-* Mirrors Rust's `Ok(value)` / `Err(error)` match arms, but uses the
-* namespace-property form (`P.ok` / `P.err`) so it doesn't collide with
-* the lowercase `ok()` / `err()` constructors from `massaman/control`.
-*
-* @example
-* ```ts
-* import { match, P, attempt } from 'massaman'
-*
-* match(attempt(() => JSON.parse(raw)))
-*   .with(P.ok, ({ value }) => use(value))
-*   .with(P.err, ({ error }) => log(error))
-*   .exhaustive()
-* ```
-*/
-const okPattern = { ok: true };
-const errPattern = { ok: false };
-/**
-* Extended ts-pattern `P` namespace. Carries everything ts-pattern exports
-* (`P.string`, `P.number`, `P.array`, `P.when`, …) plus `P.ok` / `P.err`
-* for matching `Result` values.
-*
-* Explicit literal-type annotations on the additions (rather than `as const`)
-* keep the values non-`readonly`, which ts-pattern's narrowing requires —
-* a `readonly` pattern collapses the remaining input to `never` after the
-* first arm, breaking exhaustiveness.
-*
-* For the `P.Pattern<T>` type shorthand, import `Pattern` standalone from
-* `massaman/match` — it's the form ts-pattern's own docs recommend.
-*/
-const P$1 = {
-	...P,
-	ok: okPattern,
-	err: errPattern
-};
-//#endregion
-export { P$1 as a, match as i, Pattern as n, isMatching as r, NonExhaustiveError as t };
-
-//# sourceMappingURL=match-uR6HPDRb.mjs.map

package/dist/match-uR6HPDRb.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"match-uR6HPDRb.mjs","names":["P","TsP"],"sources":["../src/match/match.ts"],"sourcesContent":["/**\n * Extends ts-pattern's `P` namespace with `P.ok` and `P.err` — structural\n * patterns for matching a `Result` inside `match()`.\n *\n * Mirrors Rust's `Ok(value)` / `Err(error)` match arms, but uses the\n * namespace-property form (`P.ok` / `P.err`) so it doesn't collide with\n * the lowercase `ok()` / `err()` constructors from `massaman/control`.\n *\n * @example\n * ```ts\n * import { match, P, attempt } from 'massaman'\n *\n * match(attempt(() => JSON.parse(raw)))\n *   .with(P.ok, ({ value }) => use(value))\n *   .with(P.err, ({ error }) => log(error))\n *   .exhaustive()\n * ```\n */\n\nimport { P as TsP } from 'ts-pattern'\n\nimport type { Err as ErrType, Ok as OkType } from '../control/types.js'\n\nconst okPattern: { ok: true } = { ok: true }\nconst errPattern: { ok: false } = { ok: false }\n\n/**\n * Extended ts-pattern `P` namespace. Carries everything ts-pattern exports\n * (`P.string`, `P.number`, `P.array`, `P.when`, …) plus `P.ok` / `P.err`\n * for matching `Result` values.\n *\n * Explicit literal-type annotations on the additions (rather than `as const`)\n * keep the values non-`readonly`, which ts-pattern's narrowing requires —\n * a `readonly` pattern collapses the remaining input to `never` after the\n * first arm, breaking exhaustiveness.\n *\n * For the `P.Pattern<T>` type shorthand, import `Pattern` standalone from\n * `massaman/match` — it's the form ts-pattern's own docs recommend.\n */\nexport const P: typeof TsP & { ok: { ok: true }; err: { ok: false } } = {\n  ...TsP,\n  ok: okPattern,\n  err: errPattern,\n}\n\n/**\n * The `Ok` variant of a `Result<T>`. Re-exported here so the value-side\n * patterns and the type-side `Ok<T>` live in one module — any consumer\n * import gets both type and value namespaces without cross-module merge\n * issues (TS2300).\n */\nexport type Ok<T> = OkType<T>\n\n/**\n * The `Err` variant of a `Result<T>`. See {@link Ok} for the co-location note.\n */\nexport type Err = ErrType\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,YAA0B,EAAE,IAAI,KAAK;AAC3C,MAAM,aAA4B,EAAE,IAAI,MAAM;;;;;;;;;;;;;;AAe9C,MAAaA,MAA2D;CACtE,GAAGC;CACH,IAAI;CACJ,KAAK;AACP"}

package/dist/object-DUAxOgHi.mjs

@@ -1,27 +0,0 @@
-import { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys } from "es-toolkit/object";
-//#region src/object/evolve.ts
-/**
-* Applies a spec of transformation functions to matching keys of an object,
-* returning a new object. Keys not in the spec are copied as-is.
-*
-* @example
-* ```ts
-* evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {
-*   name: (s) => s.trim(),
-*   age: (n) => n + 1,
-* })
-* // { name: 'Alice', age: 30, role: 'admin' }
-* ```
-*/
-function evolve(obj, spec) {
-	const result = { ...obj };
-	for (const key of Object.keys(spec)) {
-		const transform = spec[key];
-		if (transform != null && key in result) result[key] = transform(result[key]);
-	}
-	return result;
-}
-//#endregion
-export { toMerged as _, flattenObject as a, mapValues as c, omit as d, omitBy as f, toCamelCaseKeys as g, sortKeys as h, findKey as i, merge as l, pickBy as m, cloneDeep as n, invert as o, pick as p, cloneDeepWith as r, mapKeys as s, clone as t, mergeWith as u, toSnakeCaseKeys as v, evolve as y };
-
-//# sourceMappingURL=object-DUAxOgHi.mjs.map