massaman 0.0.1-rc.0

package/dist/conversion-ByBXBR5i.mjs

@@ -0,0 +1,189 @@
+import { isError, isMap, isNil, isPrimitive, isSet, isString } from "es-toolkit/predicate";
+//#region src/conversion/convert.ts
+/**
+* Coerces an unknown thrown value into a proper `Error` instance.
+*
+* Handles the common cases where libraries throw non-`Error` values
+* (e.g. plain API response bodies, arrays, Maps) that would otherwise
+* serialize as `[object Object]` in error messages.
+*
+* @param thrown - The caught value from a `catch` block.
+* @returns An `Error` with a meaningful `.message`. If `thrown` is
+*   already an `Error`, it is returned as-is. The original value is
+*   preserved as `.cause` for debugging.
+*
+* @example
+* ```ts
+* try {
+*   await riskyCall()
+* } catch (thrown) {
+*   const error = toError(thrown)
+*   console.error(error.message)
+* }
+* ```
+*/
+function toError(thrown) {
+	if (isError(thrown)) return thrown;
+	if (isString(thrown)) return new Error(thrown);
+	return new Error(stringify(thrown), { cause: thrown });
+}
+/**
+* Produces a human-readable string from any unknown value.
+*
+* Uses `JSON.stringify` for structured types (plain objects, arrays)
+* so the message contains actual content instead of `[object Object]`.
+* Maps and Sets are converted to their array representation first.
+* Falls back to `String()` for primitives or when serialization fails
+* (e.g. circular references).
+*
+* @param value - The value to stringify.
+* @returns A meaningful string representation.
+*
+* @example
+* ```ts
+* stringify({ status: 400 })          // '{"status":400}'
+* stringify(new Map([['k', 'v']]))    // '[["k","v"]]'
+* stringify(null)                     // 'null'
+* stringify(42)                       // '42'
+* ```
+*/
+function stringify(value) {
+	if (isNil(value) || isPrimitive(value)) return String(value);
+	try {
+		return JSON.stringify(toSerializable(value));
+	} catch {
+		return String(value);
+	}
+}
+/**
+* Convert types that `JSON.stringify` handles poorly into
+* serializable equivalents, recursively walking objects and arrays.
+*
+* - `Map` -> array of `[key, value]` entries (recursed)
+* - `Set` -> array of values (recursed)
+* - `Error` -> plain object with `name`, `message`, `stack`, and enumerable props
+* - Arrays and plain objects are recursed
+* - Uses a `WeakSet` to detect and break circular references
+*/
+function toSerializable(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isNil(value) || isPrimitive(value)) return value;
+	const obj = value;
+	if (seen.has(obj)) return "[Circular]";
+	seen.add(obj);
+	if (isError(value)) {
+		const errorObj = {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		for (const key of Object.keys(value)) errorObj[key] = toSerializable(value[key], seen);
+		return errorObj;
+	}
+	if (isMap(value)) return Array.from(value.entries()).map(([k, v]) => [toSerializable(k, seen), toSerializable(v, seen)]);
+	if (isSet(value)) return Array.from(value).map((v) => toSerializable(v, seen));
+	if (Array.isArray(value)) return value.map((v) => toSerializable(v, seen));
+	const result = {};
+	for (const key of Object.keys(value)) result[key] = toSerializable(value[key], seen);
+	return result;
+}
+/**
+* Converts a value to a number.
+*
+* Thin wrapper over `Number(value)` — kept as a stable surface so callers
+* don't depend directly on the global constructor's semantics (which have
+* shifted in the past, e.g. `Number(BigInt)`, and may again).
+*
+* @example
+* ```ts
+* toNumber('42') // 42
+* toNumber(null) // 0
+* ```
+*/
+function toNumber(value) {
+	return Number(value);
+}
+/**
+* Converts a value to a string.
+*
+* Thin wrapper over `String(value)` — kept as a stable surface against
+* future global-constructor changes.
+*
+* @example
+* ```ts
+* toString(42) // '42'
+* toString(null) // 'null'
+* ```
+*/
+function toString(value) {
+	return String(value);
+}
+/**
+* Converts a value to an integer by calling {@link toNumber} and truncating.
+*
+* @example
+* ```ts
+* toInteger('4.9') // 4
+* toInteger(null) // 0
+* ```
+*/
+function toInteger(value) {
+	return Math.trunc(toNumber(value));
+}
+/**
+* Converts a value to a finite number.
+*
+* Returns `0` for non-finite results (`NaN`, `Infinity`, `-Infinity`).
+*
+* @example
+* ```ts
+* toFinite('3.14') // 3.14
+* toFinite(Infinity) // 0
+* ```
+*/
+function toFinite(value) {
+	const n = Number(value);
+	if (Number.isFinite(n)) return n;
+	return 0;
+}
+/**
+* Converts a value to an array.
+*
+* - Arrays are returned as-is.
+* - Iterables (strings, Sets, Maps) are spread into an array.
+* - `null` / `undefined` return `[]`.
+* - All other values are wrapped in a single-element array.
+*
+* @example
+* ```ts
+* toArray(new Set([1, 2])) // [1, 2]
+* toArray('abc') // ['a', 'b', 'c']
+* toArray(null) // []
+* toArray(42) // [42]
+* ```
+*/
+function toArray(value) {
+	if (value == null) return [];
+	if (Array.isArray(value)) return value;
+	if (typeof value[Symbol.iterator] === "function") return Array.from(value);
+	return [value];
+}
+/**
+* Converts a value to a boolean.
+*
+* Thin wrapper over `Boolean(value)` — kept as a stable surface against
+* future global-constructor changes.
+*
+* @example
+* ```ts
+* toBoolean(1) // true
+* toBoolean(0) // false
+* toBoolean('') // false
+* ```
+*/
+function toBoolean(value) {
+	return Boolean(value);
+}
+//#endregion
+export { toFinite as a, toString as c, toError as i, toArray as n, toInteger as o, toBoolean as r, toNumber as s, stringify as t };
+
+//# sourceMappingURL=conversion-ByBXBR5i.mjs.map

package/dist/conversion-ByBXBR5i.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion-ByBXBR5i.mjs","names":[],"sources":["../src/conversion/convert.ts"],"sourcesContent":["import { isError, isMap, isNil, isPrimitive, isSet, isString } from 'es-toolkit/predicate'\n\n/**\n * Coerces an unknown thrown value into a proper `Error` instance.\n *\n * Handles the common cases where libraries throw non-`Error` values\n * (e.g. plain API response bodies, arrays, Maps) that would otherwise\n * serialize as `[object Object]` in error messages.\n *\n * @param thrown - The caught value from a `catch` block.\n * @returns An `Error` with a meaningful `.message`. If `thrown` is\n *   already an `Error`, it is returned as-is. The original value is\n *   preserved as `.cause` for debugging.\n *\n * @example\n * ```ts\n * try {\n *   await riskyCall()\n * } catch (thrown) {\n *   const error = toError(thrown)\n *   console.error(error.message)\n * }\n * ```\n */\nexport function toError(thrown: unknown): Error {\n  if (isError(thrown)) {\n    return thrown\n  }\n  if (isString(thrown)) {\n    return new Error(thrown)\n  }\n  return new Error(stringify(thrown), { cause: thrown })\n}\n\n/**\n * Produces a human-readable string from any unknown value.\n *\n * Uses `JSON.stringify` for structured types (plain objects, arrays)\n * so the message contains actual content instead of `[object Object]`.\n * Maps and Sets are converted to their array representation first.\n * Falls back to `String()` for primitives or when serialization fails\n * (e.g. circular references).\n *\n * @param value - The value to stringify.\n * @returns A meaningful string representation.\n *\n * @example\n * ```ts\n * stringify({ status: 400 })          // '{\"status\":400}'\n * stringify(new Map([['k', 'v']]))    // '[[\"k\",\"v\"]]'\n * stringify(null)                     // 'null'\n * stringify(42)                       // '42'\n * ```\n */\nexport function stringify(value: unknown): string {\n  if (isNil(value) || isPrimitive(value)) {\n    return String(value)\n  }\n  try {\n    return JSON.stringify(toSerializable(value))\n  } catch {\n    return String(value)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// private helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Convert types that `JSON.stringify` handles poorly into\n * serializable equivalents, recursively walking objects and arrays.\n *\n * - `Map` -> array of `[key, value]` entries (recursed)\n * - `Set` -> array of values (recursed)\n * - `Error` -> plain object with `name`, `message`, `stack`, and enumerable props\n * - Arrays and plain objects are recursed\n * - Uses a `WeakSet` to detect and break circular references\n */\nfunction toSerializable(value: unknown, seen: WeakSet<object> = new WeakSet()): unknown {\n  if (isNil(value) || isPrimitive(value)) {\n    return value\n  }\n\n  const obj = value as object\n  if (seen.has(obj)) {\n    return '[Circular]'\n  }\n  seen.add(obj)\n\n  if (isError(value)) {\n    const errorObj: Record<string, unknown> = {\n      name: value.name,\n      message: value.message,\n      stack: value.stack,\n    }\n    for (const key of Object.keys(value)) {\n      // oxlint-disable-next-line security/detect-object-injection -- safe: key from Object.keys\n      errorObj[key] = toSerializable((value as unknown as Record<string, unknown>)[key], seen)\n    }\n    return errorObj\n  }\n\n  if (isMap(value)) {\n    return Array.from(value.entries()).map(([k, v]) => [\n      toSerializable(k, seen),\n      toSerializable(v, seen),\n    ])\n  }\n\n  if (isSet(value)) {\n    return Array.from(value).map((v) => toSerializable(v, seen))\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((v) => toSerializable(v, seen))\n  }\n\n  const result: Record<string, unknown> = {}\n  for (const key of Object.keys(value as Record<string, unknown>)) {\n    // oxlint-disable-next-line security/detect-object-injection -- safe: key from Object.keys\n    result[key] = toSerializable((value as Record<string, unknown>)[key], seen)\n  }\n  return result\n}\n\n/**\n * Converts a value to a number.\n *\n * Thin wrapper over `Number(value)` — kept as a stable surface so callers\n * don't depend directly on the global constructor's semantics (which have\n * shifted in the past, e.g. `Number(BigInt)`, and may again).\n *\n * @example\n * ```ts\n * toNumber('42') // 42\n * toNumber(null) // 0\n * ```\n */\nexport function toNumber(value: unknown): number {\n  return Number(value)\n}\n\n/**\n * Converts a value to a string.\n *\n * Thin wrapper over `String(value)` — kept as a stable surface against\n * future global-constructor changes.\n *\n * @example\n * ```ts\n * toString(42) // '42'\n * toString(null) // 'null'\n * ```\n */\nexport function toString(value: unknown): string {\n  return String(value)\n}\n\n/**\n * Converts a value to an integer by calling {@link toNumber} and truncating.\n *\n * @example\n * ```ts\n * toInteger('4.9') // 4\n * toInteger(null) // 0\n * ```\n */\nexport function toInteger(value: unknown): number {\n  return Math.trunc(toNumber(value))\n}\n\n/**\n * Converts a value to a finite number.\n *\n * Returns `0` for non-finite results (`NaN`, `Infinity`, `-Infinity`).\n *\n * @example\n * ```ts\n * toFinite('3.14') // 3.14\n * toFinite(Infinity) // 0\n * ```\n */\nexport function toFinite(value: unknown): number {\n  const n = Number(value)\n  if (Number.isFinite(n)) {\n    return n\n  }\n  return 0\n}\n\n/**\n * Converts a value to an array.\n *\n * - Arrays are returned as-is.\n * - Iterables (strings, Sets, Maps) are spread into an array.\n * - `null` / `undefined` return `[]`.\n * - All other values are wrapped in a single-element array.\n *\n * @example\n * ```ts\n * toArray(new Set([1, 2])) // [1, 2]\n * toArray('abc') // ['a', 'b', 'c']\n * toArray(null) // []\n * toArray(42) // [42]\n * ```\n */\nexport function toArray<T>(value: Iterable<T> | T | null | undefined): T[] {\n  if (value == null) {\n    return []\n  }\n  if (Array.isArray(value)) {\n    return value as T[]\n  }\n  if (typeof (value as unknown as Record<symbol, unknown>)[Symbol.iterator] === 'function') {\n    return Array.from(value as Iterable<T>)\n  }\n  return [value as T]\n}\n\n/**\n * Converts a value to a boolean.\n *\n * Thin wrapper over `Boolean(value)` — kept as a stable surface against\n * future global-constructor changes.\n *\n * @example\n * ```ts\n * toBoolean(1) // true\n * toBoolean(0) // false\n * toBoolean('') // false\n * ```\n */\nexport function toBoolean(value: unknown): boolean {\n  return Boolean(value)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,QAAQ,QAAwB;CAC9C,IAAI,QAAQ,OAAO,EACjB,OAAO;CAET,IAAI,SAAS,OAAO,EAClB,OAAO,IAAI,MAAM,OAAO;CAE1B,OAAO,IAAI,MAAM,UAAU,OAAO,EAAE,EAAE,OAAO,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuBxD,SAAgB,UAAU,OAAwB;CAChD,IAAI,MAAM,MAAM,IAAI,YAAY,MAAM,EACpC,OAAO,OAAO,MAAM;CAEtB,IAAI;EACF,OAAO,KAAK,UAAU,eAAe,MAAM,CAAC;SACtC;EACN,OAAO,OAAO,MAAM;;;;;;;;;;;;;AAkBxB,SAAS,eAAe,OAAgB,uBAAwB,IAAI,SAAS,EAAW;CACtF,IAAI,MAAM,MAAM,IAAI,YAAY,MAAM,EACpC,OAAO;CAGT,MAAM,MAAM;CACZ,IAAI,KAAK,IAAI,IAAI,EACf,OAAO;CAET,KAAK,IAAI,IAAI;CAEb,IAAI,QAAQ,MAAM,EAAE;EAClB,MAAM,WAAoC;GACxC,MAAM,MAAM;GACZ,SAAS,MAAM;GACf,OAAO,MAAM;GACd;EACD,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,EAElC,SAAS,OAAO,eAAgB,MAA6C,MAAM,KAAK;EAE1F,OAAO;;CAGT,IAAI,MAAM,MAAM,EACd,OAAO,MAAM,KAAK,MAAM,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CACjD,eAAe,GAAG,KAAK,EACvB,eAAe,GAAG,KAAK,CACxB,CAAC;CAGJ,IAAI,MAAM,MAAM,EACd,OAAO,MAAM,KAAK,MAAM,CAAC,KAAK,MAAM,eAAe,GAAG,KAAK,CAAC;CAG9D,IAAI,MAAM,QAAQ,MAAM,EACtB,OAAO,MAAM,KAAK,MAAM,eAAe,GAAG,KAAK,CAAC;CAGlD,MAAM,SAAkC,EAAE;CAC1C,KAAK,MAAM,OAAO,OAAO,KAAK,MAAiC,EAE7D,OAAO,OAAO,eAAgB,MAAkC,MAAM,KAAK;CAE7E,OAAO;;;;;;;;;;;;;;;AAgBT,SAAgB,SAAS,OAAwB;CAC/C,OAAO,OAAO,MAAM;;;;;;;;;;;;;;AAetB,SAAgB,SAAS,OAAwB;CAC/C,OAAO,OAAO,MAAM;;;;;;;;;;;AAYtB,SAAgB,UAAU,OAAwB;CAChD,OAAO,KAAK,MAAM,SAAS,MAAM,CAAC;;;;;;;;;;;;;AAcpC,SAAgB,SAAS,OAAwB;CAC/C,MAAM,IAAI,OAAO,MAAM;CACvB,IAAI,OAAO,SAAS,EAAE,EACpB,OAAO;CAET,OAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,QAAW,OAAgD;CACzE,IAAI,SAAS,MACX,OAAO,EAAE;CAEX,IAAI,MAAM,QAAQ,MAAM,EACtB,OAAO;CAET,IAAI,OAAQ,MAA6C,OAAO,cAAc,YAC5E,OAAO,MAAM,KAAK,MAAqB;CAEzC,OAAO,CAAC,MAAW;;;;;;;;;;;;;;;AAgBrB,SAAgB,UAAU,OAAyB;CACjD,OAAO,QAAQ,MAAM"}

package/dist/error/index.d.mts

@@ -0,0 +1,2 @@
+import { AbortError, TimeoutError } from "es-toolkit/error";
+export { AbortError, TimeoutError };

package/dist/error/index.mjs

@@ -0,0 +1,2 @@
+import { AbortError, TimeoutError } from "es-toolkit/error";
+export { AbortError, TimeoutError };

package/dist/function/index.d.mts

@@ -0,0 +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-DqsBQ7Pp.mjs";
+export { DebounceOptions, DebouncedFunction, MemoizeCache, ThrottleOptions, 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/function/index.mjs

@@ -0,0 +1,2 @@
+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-2-6QB4m7.mjs";
+export { 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/function-2-6QB4m7.mjs

@@ -0,0 +1,122 @@
+import { 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.ts
+/**
+* Invokes a function with the provided arguments and returns the result.
+*
+* Equivalent to `fn(...args)` — exists as a stable, named surface for the
+* "apply function to args" operation. Use inside `.map(call)` over arrays
+* of thunks, or anywhere a value-position function-call is clearer than an
+* inline arrow.
+*
+* @example
+* ```ts
+* call(Math.max, 1, 2, 3) // 3
+* [getUser, getAccount, getPrefs].map((fn) => call(fn))
+* ```
+*/
+function call(fn, ...args) {
+	return fn(...args);
+}
+/**
+* Invokes a function returning a Promise with the provided arguments.
+*
+* Async-typed sibling of {@link call} — equivalent to `fn(...args)` for
+* promise-returning functions, but the signature constrains the return to
+* `Promise<R>` so it composes cleanly inside async pipelines.
+*
+* @example
+* ```ts
+* const user = await callAsync(fetchUser, 'user-123')
+* ```
+*/
+async function callAsync(fn, ...args) {
+	return fn(...args);
+}
+//#endregion
+//#region src/function/branching.ts
+/**
+* Returns a function that applies a transform only when a predicate passes,
+* otherwise returns the value unchanged.
+*
+* @example
+* ```ts
+* const trimIfString = when(isString, (s: string) => s.trim())
+* trimIfString('  hello  ') // 'hello'
+* ```
+*/
+function when(predicate, fn) {
+	return (value) => {
+		if (predicate(value)) return fn(value);
+		return value;
+	};
+}
+/**
+* Returns a function that applies a transform only when a predicate fails,
+* otherwise returns the value unchanged.
+*
+* Complement of {@link when}.
+*
+* @example
+* ```ts
+* const ensureArray = unless(Array.isArray, (v) => [v])
+* ensureArray(42) // [42]
+* ensureArray([1]) // [1]
+* ```
+*/
+function unless(predicate, fn) {
+	return (value) => {
+		if (predicate(value)) return value;
+		return fn(value);
+	};
+}
+/**
+* Returns a function that branches between two functions based on a predicate.
+*
+* @example
+* ```ts
+* const format = ifElse(
+*   (n: number) => n > 0,
+*   (n) => `+${n}`,
+*   (n) => `${n}`,
+* )
+* format(5)  // '+5'
+* format(-3) // '-3'
+* ```
+*/
+function ifElse(predicate, onTrue, onFalse) {
+	return (value) => {
+		if (predicate(value)) return onTrue(value);
+		return onFalse(value);
+	};
+}
+//#endregion
+//#region src/function/tap.ts
+/**
+* Returns a function that runs a side-effect and returns the value unchanged.
+*
+* Useful for debugging inside `flow` pipelines without breaking the chain.
+*
+* @example
+* ```ts
+* const process = flow(
+*   fetchUsers,
+*   tap(users => console.log('count:', users.length)),
+*   filterActive,
+* )
+* ```
+*/
+function tap(fn) {
+	return (value) => {
+		fn(value);
+		return value;
+	};
+}
+//#endregion
+//#region src/function/flowAsync.ts
+function flowAsync(first, ...rest) {
+	return async (...args) => rest.reduce(async (acc, fn) => fn(await acc), Promise.resolve(first(...args)));
+}
+//#endregion
+export { tap as C, call as D, when as E, callAsync as O, flowAsync as S, unless as T, rest as _, curry as a, throttle as b, flow as c, memoize as d, negate as f, partialRight as g, partial as h, before as i, flowRight as l, once as m, ary as n, curryRight as o, noop as p, asyncNoop as r, debounce as s, after as t, identity as u, retry as v, ifElse as w, unary as x, spread as y };
+
+//# sourceMappingURL=function-2-6QB4m7.mjs.map

package/dist/function-2-6QB4m7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-2-6QB4m7.mjs","names":[],"sources":["../src/function/call.ts","../src/function/branching.ts","../src/function/tap.ts","../src/function/flowAsync.ts"],"sourcesContent":["/**\n * Invokes a function with the provided arguments and returns the result.\n *\n * Equivalent to `fn(...args)` — exists as a stable, named surface for the\n * \"apply function to args\" operation. Use inside `.map(call)` over arrays\n * of thunks, or anywhere a value-position function-call is clearer than an\n * inline arrow.\n *\n * @example\n * ```ts\n * call(Math.max, 1, 2, 3) // 3\n * [getUser, getAccount, getPrefs].map((fn) => call(fn))\n * ```\n */\nexport function call<A extends readonly unknown[], R>(fn: (...args: A) => R, ...args: A): R {\n  return fn(...args)\n}\n\n/**\n * Invokes a function returning a Promise with the provided arguments.\n *\n * Async-typed sibling of {@link call} — equivalent to `fn(...args)` for\n * promise-returning functions, but the signature constrains the return to\n * `Promise<R>` so it composes cleanly inside async pipelines.\n *\n * @example\n * ```ts\n * const user = await callAsync(fetchUser, 'user-123')\n * ```\n */\nexport async function callAsync<A extends readonly unknown[], R>(\n  fn: (...args: A) => Promise<R>,\n  ...args: A\n): Promise<R> {\n  return fn(...args)\n}\n","/**\n * Returns a function that applies a transform only when a predicate passes,\n * otherwise returns the value unchanged.\n *\n * @example\n * ```ts\n * const trimIfString = when(isString, (s: string) => s.trim())\n * trimIfString('  hello  ') // 'hello'\n * ```\n */\nexport function when<T>(predicate: (value: T) => boolean, fn: (value: T) => T): (value: T) => T {\n  return (value: T) => {\n    if (predicate(value)) {\n      return fn(value)\n    }\n    return value\n  }\n}\n\n/**\n * Returns a function that applies a transform only when a predicate fails,\n * otherwise returns the value unchanged.\n *\n * Complement of {@link when}.\n *\n * @example\n * ```ts\n * const ensureArray = unless(Array.isArray, (v) => [v])\n * ensureArray(42) // [42]\n * ensureArray([1]) // [1]\n * ```\n */\nexport function unless<T>(predicate: (value: T) => boolean, fn: (value: T) => T): (value: T) => T {\n  return (value: T) => {\n    if (predicate(value)) {\n      return value\n    }\n    return fn(value)\n  }\n}\n\n/**\n * Returns a function that branches between two functions based on a predicate.\n *\n * @example\n * ```ts\n * const format = ifElse(\n *   (n: number) => n > 0,\n *   (n) => `+${n}`,\n *   (n) => `${n}`,\n * )\n * format(5)  // '+5'\n * format(-3) // '-3'\n * ```\n */\nexport function ifElse<T, R>(\n  predicate: (value: T) => boolean,\n  onTrue: (value: T) => R,\n  onFalse: (value: T) => R\n): (value: T) => R {\n  return (value: T) => {\n    if (predicate(value)) {\n      return onTrue(value)\n    }\n    return onFalse(value)\n  }\n}\n","/**\n * Returns a function that runs a side-effect and returns the value unchanged.\n *\n * Useful for debugging inside `flow` pipelines without breaking the chain.\n *\n * @example\n * ```ts\n * const process = flow(\n *   fetchUsers,\n *   tap(users => console.log('count:', users.length)),\n *   filterActive,\n * )\n * ```\n */\nexport function tap<T>(fn: (value: T) => unknown): (value: T) => T {\n  return (value: T) => {\n    fn(value)\n    return value\n  }\n}\n","import type { DangerouslyAllowAny } from '../types/internal.js'\n\ntype MaybePromise<T> = T | Promise<T>\n\n/**\n * Creates an async pipeline that awaits each step before passing the result\n * to the next function. Like {@link flow} from es-toolkit but async-aware.\n *\n * Each function can return a value or a Promise — `flowAsync` always returns\n * a Promise that resolves to the final step's awaited result.\n *\n * @example\n * ```ts\n * const getUsername = flowAsync(\n *   (id: string) => fetchUser(id),  // Promise<User>\n *   (user) => user.name,            // string\n *   (name) => name.toUpperCase(),\n * )\n * await getUsername('123') // 'ALICE'\n * ```\n */\nexport function flowAsync<A extends readonly unknown[], R1>(\n  f1: (...args: A) => MaybePromise<R1>\n): (...args: A) => Promise<Awaited<R1>>\nexport function flowAsync<A extends readonly unknown[], R1, R2>(\n  f1: (...args: A) => MaybePromise<R1>,\n  f2: (a: Awaited<R1>) => MaybePromise<R2>\n): (...args: A) => Promise<Awaited<R2>>\nexport function flowAsync<A extends readonly unknown[], R1, R2, R3>(\n  f1: (...args: A) => MaybePromise<R1>,\n  f2: (a: Awaited<R1>) => MaybePromise<R2>,\n  f3: (a: Awaited<R2>) => MaybePromise<R3>\n): (...args: A) => Promise<Awaited<R3>>\nexport function flowAsync<A extends readonly unknown[], R1, R2, R3, R4>(\n  f1: (...args: A) => MaybePromise<R1>,\n  f2: (a: Awaited<R1>) => MaybePromise<R2>,\n  f3: (a: Awaited<R2>) => MaybePromise<R3>,\n  f4: (a: Awaited<R3>) => MaybePromise<R4>\n): (...args: A) => Promise<Awaited<R4>>\nexport function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5>(\n  f1: (...args: A) => MaybePromise<R1>,\n  f2: (a: Awaited<R1>) => MaybePromise<R2>,\n  f3: (a: Awaited<R2>) => MaybePromise<R3>,\n  f4: (a: Awaited<R3>) => MaybePromise<R4>,\n  f5: (a: Awaited<R4>) => MaybePromise<R5>\n): (...args: A) => Promise<Awaited<R5>>\nexport function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5, R6>(\n  f1: (...args: A) => MaybePromise<R1>,\n  f2: (a: Awaited<R1>) => MaybePromise<R2>,\n  f3: (a: Awaited<R2>) => MaybePromise<R3>,\n  f4: (a: Awaited<R3>) => MaybePromise<R4>,\n  f5: (a: Awaited<R4>) => MaybePromise<R5>,\n  f6: (a: Awaited<R5>) => MaybePromise<R6>\n): (...args: A) => Promise<Awaited<R6>>\nexport function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5, R6, R7>(\n  f1: (...args: A) => MaybePromise<R1>,\n  f2: (a: Awaited<R1>) => MaybePromise<R2>,\n  f3: (a: Awaited<R2>) => MaybePromise<R3>,\n  f4: (a: Awaited<R3>) => MaybePromise<R4>,\n  f5: (a: Awaited<R4>) => MaybePromise<R5>,\n  f6: (a: Awaited<R5>) => MaybePromise<R6>,\n  f7: (a: Awaited<R6>) => MaybePromise<R7>\n): (...args: A) => Promise<Awaited<R7>>\nexport function flowAsync(\n  first: (...args: readonly DangerouslyAllowAny[]) => unknown,\n  ...rest: ReadonlyArray<(arg: DangerouslyAllowAny) => unknown>\n): (...args: readonly unknown[]) => Promise<unknown> {\n  return async (...args: readonly unknown[]) =>\n    rest.reduce<Promise<unknown>>(async (acc, fn) => fn(await acc), Promise.resolve(first(...args)))\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,SAAgB,KAAsC,IAAuB,GAAG,MAAY;CAC1F,OAAO,GAAG,GAAG,KAAK;;;;;;;;;;;;;;AAepB,eAAsB,UACpB,IACA,GAAG,MACS;CACZ,OAAO,GAAG,GAAG,KAAK;;;;;;;;;;;;;;ACxBpB,SAAgB,KAAQ,WAAkC,IAAsC;CAC9F,QAAQ,UAAa;EACnB,IAAI,UAAU,MAAM,EAClB,OAAO,GAAG,MAAM;EAElB,OAAO;;;;;;;;;;;;;;;;AAiBX,SAAgB,OAAU,WAAkC,IAAsC;CAChG,QAAQ,UAAa;EACnB,IAAI,UAAU,MAAM,EAClB,OAAO;EAET,OAAO,GAAG,MAAM;;;;;;;;;;;;;;;;;AAkBpB,SAAgB,OACd,WACA,QACA,SACiB;CACjB,QAAQ,UAAa;EACnB,IAAI,UAAU,MAAM,EAClB,OAAO,OAAO,MAAM;EAEtB,OAAO,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;AClDzB,SAAgB,IAAO,IAA4C;CACjE,QAAQ,UAAa;EACnB,GAAG,MAAM;EACT,OAAO;;;;;AC8CX,SAAgB,UACd,OACA,GAAG,MACgD;CACnD,OAAO,OAAO,GAAG,SACf,KAAK,OAAyB,OAAO,KAAK,OAAO,GAAG,MAAM,IAAI,EAAE,QAAQ,QAAQ,MAAM,GAAG,KAAK,CAAC,CAAC"}

package/dist/index-BkyNt8th.d.mts

@@ -0,0 +1,20 @@
+import { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, 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 { toSnakeCaseKeys as _, flattenObject as a, mapValues as c, omit as d, omitBy as f, toMerged as g, toCamelCaseKeys 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, evolve as v };
+//# sourceMappingURL=index-BkyNt8th.d.mts.map

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

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

package/dist/index-Br9PO6mU.d.mts

@@ -0,0 +1,155 @@
+import { assert, invariant } from "es-toolkit/util";
+
+//#region src/control/types.d.ts
+/**
+ * Success result containing a value.
+ *
+ * @example
+ * ```ts
+ * const result: Ok<number> = { ok: true, value: 42 }
+ * ```
+ */
+interface Ok<T> {
+  readonly ok: true;
+  readonly value: T;
+  readonly error: null;
+}
+/**
+ * Failure result containing an error.
+ *
+ * @example
+ * ```ts
+ * const result: Err = { ok: false, error: new Error('fail') }
+ * ```
+ */
+interface Err {
+  readonly ok: false;
+  readonly value: null;
+  readonly error: Error;
+}
+/**
+ * Discriminated union representing either success (`Ok`) or failure (`Err`).
+ * Inspired by Rust's `Result<T, E>`, but errors are always `Error`.
+ *
+ * @example
+ * ```ts
+ * function divide(a: number, b: number): Result<number> {
+ *   return b === 0 ? err('division by zero') : ok(a / b)
+ * }
+ * ```
+ */
+type Result<T> = Ok<T> | Err;
+//#endregion
+//#region src/control/attempt.d.ts
+/**
+ * Executes a synchronous function and wraps the outcome in a `Result`.
+ * Returns `Ok` with the return value on success, `Err` with the thrown value on failure.
+ *
+ * @param fn - The function to execute
+ * @returns A `Result` containing either the value or the error
+ *
+ * @example
+ * ```ts
+ * const result = attempt(() => JSON.parse('{"a":1}'))
+ * if (isOk(result)) {
+ *   console.log(result.value) // { a: 1 }
+ * }
+ * ```
+ */
+declare function attempt<T>(fn: () => T): Result<T>;
+/**
+ * Executes an asynchronous function and wraps the outcome in a `Result`.
+ * Returns `Ok` with the resolved value on success, `Err` with the rejection reason on failure.
+ *
+ * @param fn - The async function to execute
+ * @returns A promise resolving to a `Result` containing either the value or the error
+ *
+ * @example
+ * ```ts
+ * const result = await attemptAsync(() => fetch('/api/data'))
+ * if (isErr(result)) {
+ *   console.error(result.error)
+ * }
+ * ```
+ */
+declare function attemptAsync<T>(fn: () => Promise<T>): Promise<Result<T>>;
+//#endregion
+//#region src/control/result.d.ts
+/**
+ * Creates a success result wrapping the given value.
+ *
+ * @param value - The success value
+ * @returns An `Ok` result containing the value
+ *
+ * @example
+ * ```ts
+ * const result = ok(42)
+ * // { ok: true, value: 42 }
+ * ```
+ */
+declare function ok<T>(value: T): Ok<T>;
+/**
+ * Creates a failure result wrapping the given error.
+ *
+ * @param error - The error value
+ * @returns An `Err` result containing the error
+ *
+ * @example
+ * ```ts
+ * const result = err(new Error('fail'))
+ * // { ok: false, error: Error('fail') }
+ * ```
+ */
+declare function err(error: unknown): Err;
+/**
+ * Type guard that narrows a `Result` to `Ok`.
+ *
+ * @param result - The result to check
+ * @returns `true` if the result is `Ok`
+ *
+ * @example
+ * ```ts
+ * const result = attempt(() => JSON.parse('{}'))
+ * if (isOk(result)) {
+ *   console.log(result.value)
+ * }
+ * ```
+ */
+declare function isOk<T>(result: Result<T>): result is Ok<T>;
+/**
+ * Type guard that narrows a `Result` to `Err`.
+ *
+ * @param result - The result to check
+ * @returns `true` if the result is `Err`
+ *
+ * @example
+ * ```ts
+ * const result = attempt(() => JSON.parse('bad'))
+ * if (isErr(result)) {
+ *   console.error(result.error)
+ * }
+ * ```
+ */
+declare function isErr<T>(result: Result<T>): result is Err;
+/**
+ * Extract the value from an `Ok` result, or throw on `Err`.
+ *
+ * When called without a message, throws the original error.
+ * When called with a message, throws a new Error with that message
+ * and the original error as `cause` (like Rust's `expect`).
+ *
+ * @param result - The result to unwrap
+ * @param message - Optional custom error message (Rust `expect` behavior)
+ * @returns The unwrapped value
+ *
+ * @example
+ * ```ts
+ * const value = unwrap(ok(42))           // 42
+ * unwrap(err('fail'))                    // throws Error('fail')
+ * unwrap(err('fail'), 'config required') // throws Error('config required', { cause: Error('fail') })
+ * ```
+ */
+declare function unwrap<T>(result: Result<T>, message?: string): T;
+//#endregion
+export { isOk as a, attempt as c, Ok as d, Result as f, isErr as i, attemptAsync as l, invariant as n, ok as o, err as r, unwrap as s, assert as t, Err as u };
+//# sourceMappingURL=index-Br9PO6mU.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Br9PO6mU.d.mts","names":[],"sources":["../src/control/types.ts","../src/control/attempt.ts","../src/control/result.ts"],"mappings":";;;;;;AAQA;;;;;UAAiB,EAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA,EAAO,CAAA;EAAA,SACP,KAAA;AAAA;;AAWX;;;;;;;UAAiB,GAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,KAAA,EAAO,KAAA;AAAA;;;;;;;;;;;;KAcN,MAAA,MAAY,EAAA,CAAG,CAAA,IAAK,GAAA;;;;;AA/BhC;;;;;;;;;;;AAcA;;iBCJgB,OAAA,GAAA,CAAW,EAAA,QAAU,CAAA,GAAI,MAAA,CAAO,CAAA;;;;;;;;ADqBhD;;;;;;;;iBCEsB,YAAA,GAAA,CAAgB,EAAA,QAAU,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,MAAA,CAAO,CAAA;;;;;ADjC5E;;;;;;;;;;iBE6BgB,EAAA,GAAA,CAAM,KAAA,EAAO,CAAA,GAAI,EAAA,CAAG,CAAA;AFfpC;;;;;;;;;;AAiBA;;AAjBA,iBE+BgB,GAAA,CAAI,KAAA,YAAiB,GAAA;;;;;;;;;;;;;;;iBAkBrB,IAAA,GAAA,CAAQ,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,EAAA,CAAG,CAAA;;;;;;;;;;;;;;;iBAkBzC,KAAA,GAAA,CAAS,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,GAAA;;;;;;;;;;;;;;;;;;;iBAsBvC,MAAA,GAAA,CAAU,MAAA,EAAQ,MAAA,CAAO,CAAA,GAAI,OAAA,YAAmB,CAAA"}