massaman 0.0.1-rc.0

package/dist/index-BuBpCB73.d.mts

@@ -0,0 +1,197 @@
+import { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError as isError$1, isFile, isFunction, 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.
+ *
+ * The `typescript/no-explicit-any` lint rule is configured as an error, so raw
+ * `any` is banned. Use this alias only when `unknown` genuinely will not work —
+ * almost always in conditional types that need to match function signatures with
+ * arbitrary parameter types, where contravariance makes `unknown` reject narrow
+ * predicates like `(n: number) => boolean`.
+ *
+ * Reach for this last. If you can use `unknown`, use `unknown`.
+ *
+ * @example
+ * ```ts
+ * // Generic over a tuple of predicates with arbitrary input types:
+ * type Guarded<P> = P extends (value: DangerouslyAllowAny) => value is infer X ? X : never
+ * ```
+ */
+type DangerouslyAllowAny = any;
+//#endregion
+//#region src/predicate/combinators.d.ts
+/**
+ * Extracts the narrowed target type from a type-guard predicate.
+ * Returns `never` for plain `boolean` predicates so they don't pollute
+ * the union/intersection downstream.
+ *
+ * `DangerouslyAllowAny` is required here: this conditional needs to match
+ * predicate signatures with arbitrary input types (`(n: number) => …`,
+ * `(s: string) => …`, etc.). `unknown` would reject those by contravariance.
+ */
+type Guarded<P> = P extends ((value: DangerouslyAllowAny) => value is infer X) ? X : never;
+/**
+ * Extracts the input type from a tuple of predicates. Uses `infer V` in
+ * contravariant position so multiple predicates with the same input type
+ * collapse to that type. Return-position is `unknown` (covariant, accepts
+ * any return value).
+ */
+type InferInput<Ps> = Ps extends ReadonlyArray<(value: infer V) => unknown> ? V : never;
+/**
+ * Converts a union `A | B | C` to an intersection `A & B & C`.
+ * Standard contravariant-position trick.
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Returns a predicate that checks if a value satisfies ALL predicates.
+ *
+ * When every input is a type guard, the result narrows to the intersection
+ * of every guard's target type. Plain `boolean` predicates contribute nothing
+ * to the narrowing (they fall back to no-op).
+ *
+ * @example
+ * ```ts
+ * const isPositiveEven = allPass([(n: number) => n > 0, (n: number) => n % 2 === 0])
+ * isPositiveEven(4) // true
+ *
+ * const isNonEmptyString = allPass([isString, isNotEmpty])
+ * if (isNonEmptyString(x)) {
+ *   // x is narrowed to string here
+ * }
+ * ```
+ */
+declare function allPass<T>(predicates: readonly []): (value: T) => true;
+declare function allPass<Ps extends ReadonlyArray<(value: DangerouslyAllowAny) => boolean>>(predicates: Ps): (value: InferInput<Ps>) => value is InferInput<Ps> & UnionToIntersection<Guarded<Ps[number]>>;
+/**
+ * Returns a predicate that checks if a value satisfies ANY predicate.
+ *
+ * When every input is a type guard, the result narrows to the union of every
+ * guard's target type (since only one needs to match).
+ *
+ * @example
+ * ```ts
+ * const isAdminOrOwner = anyPass([isAdmin, isOwner])
+ * isAdminOrOwner(user)
+ *
+ * const isStringOrNumber = anyPass([isString, isNumber])
+ * if (isStringOrNumber(x)) {
+ *   // x is narrowed to string | number here
+ * }
+ * ```
+ */
+declare function anyPass<T>(predicates: readonly []): (value: T) => false;
+declare function anyPass<Ps extends ReadonlyArray<(value: DangerouslyAllowAny) => boolean>>(predicates: Ps): (value: InferInput<Ps>) => value is InferInput<Ps> & Guarded<Ps[number]>;
+/**
+ * Returns a predicate that checks if a value satisfies both predicates.
+ *
+ * Binary AND combinator — shorthand for `allPass([f, g])`. When both inputs
+ * are type guards, the result narrows to the intersection of their target types.
+ *
+ * @example
+ * ```ts
+ * const isPositiveEven = both((n: number) => n > 0, (n: number) => n % 2 === 0)
+ * isPositiveEven(4)
+ * ```
+ */
+declare function both<T, A extends T, B extends T>(f: (value: T) => value is A, g: (value: T) => value is B): (value: T) => value is A & B;
+declare function both<T>(f: (value: T) => boolean, g: (value: T) => boolean): (value: T) => boolean;
+/**
+ * Returns a predicate that checks if a value satisfies either predicate.
+ *
+ * Binary OR combinator — shorthand for `anyPass([f, g])`. When both inputs
+ * are type guards, the result narrows to the union of their target types.
+ *
+ * @example
+ * ```ts
+ * const isNilOrEmpty = either(isNil, (s: string) => s === '')
+ * isNilOrEmpty(null)
+ * ```
+ */
+declare function either<T, A extends T, B extends T>(f: (value: T) => value is A, g: (value: T) => value is B): (value: T) => value is A | B;
+declare function either<T>(f: (value: T) => boolean, g: (value: T) => boolean): (value: T) => boolean;
+//#endregion
+//#region src/predicate/guards.d.ts
+/**
+ * Checks if a value is an array.
+ *
+ * @example
+ * ```ts
+ * isArray([1, 2]) // true
+ * isArray('hello') // false
+ * ```
+ */
+declare const isArray: (arg: any) => arg is any[];
+/**
+ * Checks if a value is a non-null object.
+ *
+ * Returns `true` for plain objects, arrays, class instances, etc.
+ * Returns `false` for `null`, primitives, and functions.
+ *
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject(null) // false
+ * ```
+ */
+declare function isObject(value: unknown): value is object;
+/**
+ * Checks if a value is empty.
+ *
+ * - Strings: `''`
+ * - Arrays: `length === 0`
+ * - Maps/Sets: `size === 0`
+ * - Objects: no own enumerable keys
+ *
+ * @example
+ * ```ts
+ * isEmpty('') // true
+ * isEmpty([]) // true
+ * isEmpty({}) // true
+ * isEmpty(new Map()) // true
+ * ```
+ */
+declare function isEmpty(value: string | object): boolean;
+/**
+ * Checks if a value is not empty. Complement of {@link isEmpty}.
+ *
+ * @example
+ * ```ts
+ * isNotEmpty('hello') // true
+ * isNotEmpty([]) // false
+ * ```
+ */
+declare function isNotEmpty(value: string | object): boolean;
+/**
+ * Checks if a value is a finite number.
+ *
+ * @example
+ * ```ts
+ * isFiniteNumber(42) // true
+ * isFiniteNumber(Infinity) // false
+ * ```
+ */
+declare const isFiniteNumber: (value: unknown) => boolean;
+/**
+ * Checks if a value is an integer.
+ *
+ * @example
+ * ```ts
+ * isInteger(42) // true
+ * isInteger(4.2) // false
+ * ```
+ */
+declare const isInteger: (value: unknown) => boolean;
+/**
+ * Checks if a value is NaN.
+ *
+ * @example
+ * ```ts
+ * isNaN(NaN) // true
+ * isNaN(42) // false
+ * ```
+ */
+declare const isNaN: (value: unknown) => boolean;
+//#endregion
+export { isSymbol as A, isNotEmpty as B, isNumber as C, isRegExp as D, isPromise as E, isArray as F, either as G, allPass as H, isEmpty as I, isFiniteNumber as L, isUndefined as M, isWeakMap as N, isSet$1 as O, isWeakSet as P, isInteger as R, isNull as S, isPrimitive$1 as T, anyPass as U, isObject as V, both as W, isLength as _, isBuffer as a, isNode as b, isEqual as c, isFile as d, isFunction as f, isJSONValue as g, isJSONObject as h, isBrowser as i, isTypedArray as j, isString$1 as k, isEqualWith as l, isJSONArray as m, isBlob as n, isDate as o, isJSON as p, isBoolean as r, isEmptyObject as s, isArrayBuffer as t, isError$1 as u, isMap$1 as v, isPlainObject as w, isNotNil as x, isNil$1 as y, isNaN as z };
+//# sourceMappingURL=index-BuBpCB73.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BuBpCB73.d.mts","names":[],"sources":["../src/types/internal.ts","../src/predicate/combinators.ts","../src/predicate/guards.ts"],"mappings":";;;;;;AAmBA;;;;;;;;ACnB+D;;;;;;KDmBnD,mBAAA;;;;;AAAZ;;;;;;;KCRK,OAAA,MAAa,CAAA,WAAY,KAAA,EAAO,mBAAA,KAAwB,KAAA,eAAoB,CAAA;AAXlB;;;;;;AAAA,KAmB1D,UAAA,OAAiB,EAAA,SAAW,aAAA,EAAe,KAAA,yBAA8B,CAAA;;;;;KAMzE,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAA,6BACrD,CAAA,sBAEE,CAAA;;AAjB8E;;;;;;;;;;;;AAQH;;;;;iBA8B/D,OAAA,GAAA,CAAW,UAAA,iBAA2B,KAAA,EAAO,CAAA;AAAA,iBAC7C,OAAA,YAAmB,aAAA,EAAe,KAAA,EAAO,mBAAA,cAAA,CACvD,UAAA,EAAY,EAAA,IACV,KAAA,EAAO,UAAA,CAAW,EAAA,MAAQ,KAAA,IAAS,UAAA,CAAW,EAAA,IAAM,mBAAA,CAAoB,OAAA,CAAQ,EAAA;;;;;;;AAHpF;;;;;;;;;;AACA;iBA0BgB,OAAA,GAAA,CAAW,UAAA,iBAA2B,KAAA,EAAO,CAAA;AAAA,iBAC7C,OAAA,YAAmB,aAAA,EAAe,KAAA,EAAO,mBAAA,cAAA,CACvD,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,CAAA,CAC7C,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,GAAA,CAAQ,CAAA,GAAI,KAAA,EAAO,CAAA,cAAe,CAAA,GAAI,KAAA,EAAO,CAAA,gBAAiB,KAAA,EAAO,CAAA;;;;;;;;;;;;;iBAiBrE,MAAA,cAAoB,CAAA,YAAa,CAAA,CAAA,CAC/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,GAAA,CAAU,CAAA,GAAI,KAAA,EAAO,CAAA,cAAe,CAAA,GAAI,KAAA,EAAO,CAAA,gBAAiB,KAAA,EAAO,CAAA;;;;;;ADxGvF;;;;;;cEVa,OAAA,GAAO,GAAA,UAAA,GAAA;;ADT2C;;;;;;;;;;;iBCuB/C,QAAA,CAAS,KAAA,YAAiB,KAAA;;ADZwC;;;;;;;;;;;;AAQH;;;iBCwB/D,OAAA,CAAQ,KAAA;;;;;;;;;;iBAmBR,UAAA,CAAW,KAAA;;;;;;;;;;cAad,cAAA,GAAiB,KAAA;;;;;;;;;;cAWjB,SAAA,GAAY,KAAA;;;;;;;;;;cAWZ,KAAA,GAAQ,KAAA"}

package/dist/index-COFf0Pih.d.mts

@@ -0,0 +1,128 @@
+//#region src/conversion/convert.d.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)
+ * }
+ * ```
+ */
+declare function toError(thrown: unknown): Error;
+/**
+ * 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'
+ * ```
+ */
+declare function stringify(value: unknown): string;
+/**
+ * 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
+ * ```
+ */
+declare function toNumber(value: unknown): number;
+/**
+ * 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'
+ * ```
+ */
+declare function toString(value: unknown): string;
+/**
+ * Converts a value to an integer by calling {@link toNumber} and truncating.
+ *
+ * @example
+ * ```ts
+ * toInteger('4.9') // 4
+ * toInteger(null) // 0
+ * ```
+ */
+declare function toInteger(value: unknown): number;
+/**
+ * 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
+ * ```
+ */
+declare function toFinite(value: unknown): number;
+/**
+ * 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]
+ * ```
+ */
+declare function toArray<T>(value: Iterable<T> | T | null | undefined): T[];
+/**
+ * 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
+ * ```
+ */
+declare function toBoolean(value: unknown): boolean;
+//#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=index-COFf0Pih.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-COFf0Pih.d.mts","names":[],"sources":["../src/conversion/convert.ts"],"mappings":";;AAwBA;;;;;AA8BA;;;;;AAqFA;;;;;AAgBA;;;;;AAaA;iBAhJgB,OAAA,CAAQ,MAAA,YAAkB,KAAA;;;;AA+J1C;;;;;AAwBA;;;;;;;;;;;;iBAzJgB,SAAA,CAAU,KAAA;;;;;AAmL1B;;;;;;;;;iBA9FgB,QAAA,CAAS,KAAA;;;;;;;;;;;;;iBAgBT,QAAA,CAAS,KAAA;;;;;;;;;;iBAaT,SAAA,CAAU,KAAA;;;;;;;;;;;;iBAeV,QAAA,CAAS,KAAA;;;;;;;;;;;;;;;;;iBAwBT,OAAA,GAAA,CAAW,KAAA,EAAO,QAAA,CAAS,CAAA,IAAK,CAAA,sBAAuB,CAAA;;;;;;;;;;;;;;iBA0BvD,SAAA,CAAU,KAAA"}

package/dist/index-DqsBQ7Pp.d.mts

@@ -0,0 +1,120 @@
+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.
+ *
+ * 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))
+ * ```
+ */
+declare function call<A extends readonly unknown[], R>(fn: (...args: A) => R, ...args: A): R;
+/**
+ * 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')
+ * ```
+ */
+declare function callAsync<A extends readonly unknown[], R>(fn: (...args: A) => Promise<R>, ...args: A): Promise<R>;
+//#endregion
+//#region src/function/branching.d.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'
+ * ```
+ */
+declare function when<T>(predicate: (value: T) => boolean, fn: (value: T) => T): (value: T) => T;
+/**
+ * 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]
+ * ```
+ */
+declare function unless<T>(predicate: (value: T) => boolean, fn: (value: T) => T): (value: T) => T;
+/**
+ * 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'
+ * ```
+ */
+declare function ifElse<T, R>(predicate: (value: T) => boolean, onTrue: (value: T) => R, onFalse: (value: T) => R): (value: T) => R;
+//#endregion
+//#region src/function/tap.d.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,
+ * )
+ * ```
+ */
+declare function tap<T>(fn: (value: T) => unknown): (value: T) => T;
+//#endregion
+//#region src/function/flowAsync.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Creates an async pipeline that awaits each step before passing the result
+ * to the next function. Like {@link flow} from es-toolkit but async-aware.
+ *
+ * Each function can return a value or a Promise — `flowAsync` always returns
+ * a Promise that resolves to the final step's awaited result.
+ *
+ * @example
+ * ```ts
+ * const getUsername = flowAsync(
+ *   (id: string) => fetchUser(id),  // Promise<User>
+ *   (user) => user.name,            // string
+ *   (name) => name.toUpperCase(),
+ * )
+ * await getUsername('123') // 'ALICE'
+ * ```
+ */
+declare function flowAsync<A extends readonly unknown[], R1>(f1: (...args: A) => MaybePromise<R1>): (...args: A) => Promise<Awaited<R1>>;
+declare function flowAsync<A extends readonly unknown[], R1, R2>(f1: (...args: A) => MaybePromise<R1>, f2: (a: Awaited<R1>) => MaybePromise<R2>): (...args: A) => Promise<Awaited<R2>>;
+declare function flowAsync<A extends readonly unknown[], R1, R2, R3>(f1: (...args: A) => MaybePromise<R1>, f2: (a: Awaited<R1>) => MaybePromise<R2>, f3: (a: Awaited<R2>) => MaybePromise<R3>): (...args: A) => Promise<Awaited<R3>>;
+declare function flowAsync<A extends readonly unknown[], R1, R2, R3, R4>(f1: (...args: A) => MaybePromise<R1>, f2: (a: Awaited<R1>) => MaybePromise<R2>, f3: (a: Awaited<R2>) => MaybePromise<R3>, f4: (a: Awaited<R3>) => MaybePromise<R4>): (...args: A) => Promise<Awaited<R4>>;
+declare function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5>(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>): (...args: A) => Promise<Awaited<R5>>;
+declare function flowAsync<A extends readonly unknown[], R1, R2, R3, R4, R5, R6>(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>): (...args: A) => Promise<Awaited<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-DqsBQ7Pp.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DqsBQ7Pp.d.mts","names":[],"sources":["../src/function/call.ts","../src/function/branching.ts","../src/function/tap.ts","../src/function/flowAsync.ts"],"mappings":"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"}

package/dist/index-Dw_tuZdb.d.mts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dw_tuZdb.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,GAAA,CAAU,KAAA,WAAgB,CAAA,IAAK,KAAA,UAAe,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,CAAA;;;;;;AAApF;;;;;;;;;;;;;;;iBCMgB,WAAA,GAAA,CAAe,KAAA,WAAgB,CAAA,KAAM,CAAA;;;;;;ADNrD;;;;;;;;;;;;;;;;iBESgB,WAAA,MAAA,CACd,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;;;;;;AFdH;;;;;;;;;iBGAgB,IAAA,MAAA,CACd,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,GAAA,CAAU,EAAA,GAAK,KAAA,EAAO,CAAA,wBAAyB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA;;;;;;;;;iBAsBxD,OAAA,GAAA,CAAW,EAAA,GAAK,KAAA,EAAO,CAAA,wBAAyB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA;;;;;;;;;AHZzE;;;;;;iBGwCgB,QAAA,GAAA,CACd,KAAA,WAAgB,CAAA,IAChB,WAAA,EAAa,aAAA,EAAe,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACpC,CAAA;;;;;;AJjDH;;;;;;;;;;;;;;;;iBKSgB,MAAA,MAAA,CAAa,EAAA,GAAK,IAAA,EAAM,CAAA,MAAO,CAAA,EAAG,CAAA,WAAY,IAAA,EAAM,CAAA,GAAI,CAAA"}

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { $ as unionWith, A as last, B as remove, C as initial, D as isSubset, E as intersectionWith, F as orderBy, G as tail, H as sampleSize, I as partition, J as takeRightWhile, K as take, L as pull, M as mapAsync, N as maxBy, O as isSubsetWith, P as minBy, Q as unionBy, R as pullAt, S as head, T as intersectionBy, U as shuffle, V as sample, W as sortBy, X as toFilled, Y as takeWhile, Z as union, _ as flatten, _t as scan, a as difference, at as windowed, b as forEachRight, bt as adjust, c as drop, ct as xorBy, d as dropWhile, dt as zipObject, et as uniq, f as fill, ft as zipWith, g as flatMapDeep, gt as sortWith, h as flatMapAsync, ht as descend, i as countBy, it as unzipWith, j as limitAsync, k as keyBy, l as dropRight, lt as xorWith, m as flatMap, mt as ascend, n as chunk, nt as uniqWith, o as differenceBy, ot as without, p as filterAsync, pt as unfold, q as takeRight, r as compact, rt as unzip, s as differenceWith, st as xor, t as at, tt as uniqBy, u as dropRightWhile, ut as zip, v as flattenDeep, vt as reduceWhile, w as intersection, x as groupBy, y as forEachAsync, yt as dropRepeats, z as reduceAsync } from "./index-Dw_tuZdb.mjs";
+import { a as isOk, c as attempt, d as Ok, f as Result, i as isErr, l as attemptAsync, n as invariant, o as ok, r as err, s as unwrap, t as assert, u as Err } from "./index-Br9PO6mU.mjs";
+import { a as toFinite, c as toString, i as toError, n as toArray, o as toInteger, r as toBoolean, s as toNumber, t as stringify } from "./index-COFf0Pih.mjs";
+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-DqsBQ7Pp.mjs";
+import { clamp, inRange, mean, meanBy, median, medianBy, random, randomInt, range, rangeRight, round, sum, sumBy } from "./math/index.mjs";
+import { _ as toSnakeCaseKeys, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toMerged, h as toCamelCaseKeys, 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 evolve } from "./index-BkyNt8th.mjs";
+import { A as isSymbol, B as isNotEmpty, C as isNumber, D as isRegExp, E as isPromise, F as isArray, G as either, H as allPass, I as isEmpty, L as isFiniteNumber, M as isUndefined, N as isWeakMap, O as isSet, P as isWeakSet, R as isInteger, S as isNull, T as isPrimitive, U as anyPass, V as isObject, W as both, _ as isLength, a as isBuffer, b as isNode, c as isEqual, d as isFile, f as isFunction, g as isJSONValue, h as isJSONObject, i as isBrowser, j as isTypedArray, k as isString, l as isEqualWith, m as isJSONArray, n as isBlob, o as isDate, p as isJSON, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isMap, w as isPlainObject, x as isNotNil, y as isNil, z as isNaN } from "./index-BuBpCB73.mjs";
+import { Mutex, Semaphore, 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 { NonExhaustiveError, P, Pattern, isMatching, match } from "./pattern/index.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, allPass, anyPass, ary, ascend, assert, asyncNoop, at, attempt, attemptAsync, before, both, call, callAsync, camelCase, capitalize, chunk, clamp, clone, cloneDeep, cloneDeepWith, 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, 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, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, reduceWhile, remove, rest, retry, reverseString, round, sample, sampleSize, scan, shuffle, snakeCase, sortBy, 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, trim, trimEnd, trimStart, unary, unescape, unfold, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unless, unwrap, unzip, unzipWith, upperCase, upperFirst, when, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { $ as unionWith, A as last, B as remove, C as initial, D as isSubset, E as intersectionWith, F as orderBy, G as tail, H as sampleSize, I as partition, J as takeRightWhile, K as take, L as pull, M as mapAsync, N as maxBy, O as isSubsetWith, P as minBy, Q as unionBy, R as pullAt, S as head, T as intersectionBy, U as shuffle, V as sample, W as sortBy, X as toFilled, Y as takeWhile, Z as union, _ as flatten, _t as scan, a as difference, at as windowed, b as forEachRight, bt as adjust, c as drop, ct as xorBy, d as dropWhile, dt as zipObject, et as uniq, f as fill, ft as zipWith, g as flatMapDeep, gt as sortWith, h as flatMapAsync, ht as descend, i as countBy, it as unzipWith, j as limitAsync, k as keyBy, l as dropRight, lt as xorWith, m as flatMap, mt as ascend, n as chunk, nt as uniqWith, o as differenceBy, ot as without, p as filterAsync, pt as unfold, q as takeRight, r as compact, rt as unzip, s as differenceWith, st as xor, t as at, tt as uniqBy, u as dropRightWhile, ut as zip, v as flattenDeep, vt as reduceWhile, w as intersection, x as groupBy, y as forEachAsync, yt as dropRepeats, z as reduceAsync } from "./array-C8MqjyiP.mjs";
+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-2-6QB4m7.mjs";
+import { clamp, inRange, mean, meanBy, median, medianBy, random, randomInt, range, rangeRight, round, sum, sumBy } from "./math/index.mjs";
+import { _ as toSnakeCaseKeys, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toMerged, h as toCamelCaseKeys, 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 evolve } from "./object-BHnp9Sr9.mjs";
+import { A as isSymbol, B as isNotEmpty, C as isNumber, D as isRegExp, E as isPromise, F as isArray, G as either, H as allPass, I as isEmpty, L as isFiniteNumber, M as isUndefined, N as isWeakMap, O as isSet, P as isWeakSet, R as isInteger, S as isNull, T as isPrimitive, U as anyPass, V as isObject, W as both, _ as isLength, a as isBuffer, b as isNode, c as isEqual, d as isFile, f as isFunction, g as isJSONValue, h as isJSONObject, i as isBrowser, j as isTypedArray, k as isString, l as isEqualWith, m as isJSONArray, n as isBlob, o as isDate, p as isJSON, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isMap, w as isPlainObject, x as isNotNil, y as isNil, z as isNaN } from "./predicate-CYzSOMLW.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-ByBXBR5i.mjs";
+import { Mutex, Semaphore, 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, c as ok, i as attemptAsync, l as unwrap, n as invariant, o as isErr, r as attempt, s as isOk, t as assert } from "./control-B4mDPBn6.mjs";
+import { NonExhaustiveError, P, Pattern, isMatching, match } from "./pattern/index.mjs";
+export { AbortError, Mutex, NonExhaustiveError, P, Pattern, Semaphore, TimeoutError, adjust, after, allPass, anyPass, ary, ascend, assert, asyncNoop, at, attempt, attemptAsync, before, both, call, callAsync, camelCase, capitalize, chunk, clamp, clone, cloneDeep, cloneDeepWith, 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, 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, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, reduceWhile, remove, rest, retry, reverseString, round, sample, sampleSize, scan, shuffle, snakeCase, sortBy, 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, trim, trimEnd, trimStart, unary, unescape, unfold, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unless, unwrap, unzip, unzipWith, upperCase, upperFirst, when, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/math/index.d.mts

@@ -0,0 +1,2 @@
+import { clamp, inRange, mean, meanBy, median, medianBy, random, randomInt, range, rangeRight, round, sum, sumBy } from "es-toolkit/math";
+export { clamp, inRange, mean, meanBy, median, medianBy, random, randomInt, range, rangeRight, round, sum, sumBy };

package/dist/math/index.mjs

@@ -0,0 +1,2 @@
+import { clamp, inRange, mean, meanBy, median, medianBy, random, randomInt, range, rangeRight, round, sum, sumBy } from "es-toolkit/math";
+export { clamp, inRange, mean, meanBy, median, medianBy, random, randomInt, range, rangeRight, round, sum, sumBy };

package/dist/object/index.d.mts

@@ -0,0 +1,2 @@
+import { _ as toSnakeCaseKeys, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toMerged, h as toCamelCaseKeys, 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 evolve } from "../index-BkyNt8th.mjs";
+export { clone, cloneDeep, cloneDeepWith, evolve, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, toCamelCaseKeys, toMerged, toSnakeCaseKeys };