@vielzeug/toolkit 1.0.12 → 1.0.14

package/dist/index.js

@@ -4,214 +4,238 @@ import { chunk as f } from "./array/chunk.js";
 import { compact as i } from "./array/compact.js";
 import { contains as a } from "./array/contains.js";
 import { every as _ } from "./array/every.js";
-import { filter as S } from "./array/filter.js";
-import { find as l } from "./array/find.js";
-import { findIndex as I } from "./array/findIndex.js";
-import { findLast as u } from "./array/findLast.js";
+import { filter as l } from "./array/filter.js";
+import { find as c } from "./array/find.js";
+import { findIndex as d } from "./array/findIndex.js";
+import { findLast as I } from "./array/findLast.js";
 import { flatten as M } from "./array/flatten.js";
-import { group as g } from "./array/group.js";
-import { list as N } from "./array/list.js";
-import { map as b } from "./array/map.js";
+import { group as y } from "./array/group.js";
+import { list as b } from "./array/list.js";
+import { map as v } from "./array/map.js";
 import { pick as k } from "./array/pick.js";
 import { reduce as T } from "./array/reduce.js";
-import { search as A } from "./array/search.js";
-import { select as D } from "./array/select.js";
-import { shift as U } from "./array/shift.js";
-import { some as w } from "./array/some.js";
-import { sort as J } from "./array/sort.js";
-import { sortBy as Y } from "./array/sortBy.js";
-import { substitute as H } from "./array/substitute.js";
-import { uniq as V } from "./array/uniq.js";
-import { expires as z } from "./date/expires.js";
-import { interval as X } from "./date/interval.js";
-import { timeDiff as rr } from "./date/timeDiff.js";
-import { assert as er } from "./function/assert.js";
-import { assertParams as mr } from "./function/assertParams.js";
-import { attempt as fr } from "./function/attempt.js";
-import { compare as ir } from "./function/compare.js";
-import { compareBy as ar } from "./function/compareBy.js";
-import { compose as _r } from "./function/compose.js";
-import { curry as Sr } from "./function/curry.js";
-import { debounce as lr } from "./function/debounce.js";
+import { remoteList as A } from "./array/remoteList.js";
+import { search as D } from "./array/search.js";
+import { select as U } from "./array/select.js";
+import { shift as w } from "./array/shift.js";
+import { some as J } from "./array/some.js";
+import { sort as Y } from "./array/sort.js";
+import { arrange as H } from "./array/arrange.js";
+import { substitute as V } from "./array/substitute.js";
+import { uniq as z } from "./array/uniq.js";
+import { expires as X } from "./date/expires.js";
+import { interval as rr } from "./date/interval.js";
+import { timeDiff as er } from "./date/timeDiff.js";
+import { assert as mr } from "./function/assert.js";
+import { assertParams as fr } from "./function/assertParams.js";
+import { attempt as ir } from "./function/attempt.js";
+import { compare as ar } from "./function/compare.js";
+import { compareBy as _r } from "./function/compareBy.js";
+import { compose as lr } from "./function/compose.js";
+import { curry as cr } from "./function/curry.js";
+import { debounce as dr } from "./function/debounce.js";
 import { delay as Ir } from "./function/delay.js";
-import { fp as ur } from "./function/fp.js";
-import { memo as Mr } from "./function/memo.js";
-import { once as gr } from "./function/once.js";
-import { pipe as Nr } from "./function/pipe.js";
-import { predict as br } from "./function/predict.js";
-import { proxy as kr } from "./function/proxy.js";
-import { retry as Tr } from "./function/retry.js";
-import { sleep as Ar } from "./function/sleep.js";
-import { throttle as Dr } from "./function/throttle.js";
-import { worker as Ur } from "./function/worker.js";
-import { average as wr } from "./math/average.js";
-import { boil as Jr } from "./math/boil.js";
-import { clamp as Yr } from "./math/clamp.js";
-import { max as Hr } from "./math/max.js";
-import { median as Vr } from "./math/median.js";
-import { min as zr } from "./math/min.js";
-import { range as Xr } from "./math/range.js";
-import { rate as ro } from "./math/rate.js";
-import { round as eo } from "./math/round.js";
-import { sum as mo } from "./math/sum.js";
-import { clone as fo } from "./object/clone.js";
-import { diff as io } from "./object/diff.js";
-import { entries as ao } from "./object/entries.js";
-import { keys as _o } from "./object/keys.js";
-import { merge as So } from "./object/merge.js";
-import { parseJSON as lo } from "./object/parseJSON.js";
-import { path as Io } from "./object/path.js";
-import { seek as uo } from "./object/seek.js";
-import { values as Go } from "./object/values.js";
-import { draw as yo } from "./random/draw.js";
-import { random as vo } from "./random/random.js";
-import { shuffle as ho } from "./random/shuffle.js";
-import { uuid as Po } from "./random/uuid.js";
-import { camelCase as Co } from "./string/camelCase.js";
-import { kebabCase as Bo } from "./string/kebabCase.js";
-import { pascalCase as Lo } from "./string/pascalCase.js";
-import { similarity as qo } from "./string/similarity.js";
-import { snakeCase as Fo } from "./string/snakeCase.js";
-import { truncate as Wo } from "./string/truncate.js";
-import { ge as jo } from "./typed/ge.js";
-import { gt as Qo } from "./typed/gt.js";
-import { is as Zo } from "./typed/is.js";
-import { IS_ARRAY_ERROR_MSG as Ko, isArray as Xo } from "./typed/isArray.js";
-import { isBoolean as re } from "./typed/isBoolean.js";
-import { IS_DATE_ERROR_MSG as ee, isDate as te } from "./typed/isDate.js";
-import { isDefined as pe } from "./typed/isDefined.js";
-import { IS_EMPTY_ERROR_MSG as xe, isEmpty as ie } from "./typed/isEmpty.js";
-import { IS_EQUAL_ERROR_MSG as ae, isEqual as Re } from "./typed/isEqual.js";
-import { isEven as ne } from "./typed/isEven.js";
-import { IS_FUNCTION_ERROR_MSG as ce, isFunction as le } from "./typed/isFunction.js";
-import { isNegative as Ie } from "./typed/isNegative.js";
-import { IS_NIL_ERROR_MSG as ue, isNil as de } from "./typed/isNil.js";
-import { IS_NUMBER_ERROR_MSG as Ge, isNumber as ge } from "./typed/isNumber.js";
-import { IS_OBJECT_ERROR_MSG as Ne, isObject as ve } from "./typed/isObject.js";
-import { isOdd as he } from "./typed/isOdd.js";
-import { isPositive as Pe } from "./typed/isPositive.js";
-import { IS_PRIMITIVE_ERROR_MSG as Ce, isPrimitive as Ae } from "./typed/isPrimitive.js";
-import { IS_PROMISE_ERROR_MSG as De, isPromise as Le } from "./typed/isPromise.js";
-import { isRegex as qe } from "./typed/isRegex.js";
-import { IS_STRING_ERROR_MSG as Fe, isString as Je } from "./typed/isString.js";
-import { IS_WITHIN_ERROR_MSG as Ye, isWithin as je } from "./typed/isWithin.js";
-import { isZero as Qe } from "./typed/isZero.js";
-import { le as Ze } from "./typed/le.js";
-import { lt as Ke } from "./typed/lt.js";
-import { typeOf as $e } from "./typed/typeOf.js";
+import { fp as Mr } from "./function/fp.js";
+import { memo as yr } from "./function/memo.js";
+import { once as br } from "./function/once.js";
+import { parallel as vr } from "./function/parallel.js";
+import { pipe as kr } from "./function/pipe.js";
+import { predict as Tr } from "./function/predict.js";
+import { proxy as Ar } from "./function/proxy.js";
+import { prune as Dr } from "./function/prune.js";
+import { retry as Ur } from "./function/retry.js";
+import { sleep as wr } from "./function/sleep.js";
+import { throttle as Jr } from "./function/throttle.js";
+import { worker as Yr } from "./function/worker.js";
+import { abs as Hr } from "./math/abs.js";
+import { add as Vr } from "./math/add.js";
+import { allocate as zr } from "./math/allocate.js";
+import { average as Xr } from "./math/average.js";
+import { boil as ro } from "./math/boil.js";
+import { clamp as eo } from "./math/clamp.js";
+import { distribute as mo } from "./math/distribute.js";
+import { divide as fo } from "./math/divide.js";
+import { max as io } from "./math/max.js";
+import { median as ao } from "./math/median.js";
+import { min as _o } from "./math/min.js";
+import { multiply as lo } from "./math/multiply.js";
+import { range as co } from "./math/range.js";
+import { rate as Eo } from "./math/rate.js";
+import { round as Oo } from "./math/round.js";
+import { subtract as go } from "./math/subtract.js";
+import { sum as Go } from "./math/sum.js";
+import { currency as No } from "./money/currency.js";
+import { exchange as ho } from "./money/exchange.js";
+import { clone as Po } from "./object/clone.js";
+import { diff as Co } from "./object/diff.js";
+import { entries as Bo } from "./object/entries.js";
+import { keys as Lo } from "./object/keys.js";
+import { merge as qo } from "./object/merge.js";
+import { parseJSON as Fo } from "./object/parseJSON.js";
+import { path as Wo } from "./object/path.js";
+import { seek as jo } from "./object/seek.js";
+import { values as Qo } from "./object/values.js";
+import { draw as Zo } from "./random/draw.js";
+import { random as Ko } from "./random/random.js";
+import { shuffle as $o } from "./random/shuffle.js";
+import { uuid as oe } from "./random/uuid.js";
+import { camelCase as te } from "./string/camelCase.js";
+import { kebabCase as pe } from "./string/kebabCase.js";
+import { pascalCase as xe } from "./string/pascalCase.js";
+import { similarity as se } from "./string/similarity.js";
+import { snakeCase as Re } from "./string/snakeCase.js";
+import { truncate as ne } from "./string/truncate.js";
+import { ge as Se } from "./typed/ge.js";
+import { gt as ue } from "./typed/gt.js";
+import { is as Ee } from "./typed/is.js";
+import { IS_ARRAY_ERROR_MSG as Oe, isArray as Me } from "./typed/isArray.js";
+import { isBoolean as ye } from "./typed/isBoolean.js";
+import { IS_DATE_ERROR_MSG as be, isDate as Ne } from "./typed/isDate.js";
+import { isDefined as he } from "./typed/isDefined.js";
+import { IS_EMPTY_ERROR_MSG as Pe, isEmpty as Te } from "./typed/isEmpty.js";
+import { IS_EQUAL_ERROR_MSG as Ae, isEqual as Be } from "./typed/isEqual.js";
+import { isEven as Le } from "./typed/isEven.js";
+import { IS_FUNCTION_ERROR_MSG as qe, isFunction as we } from "./typed/isFunction.js";
+import { isNegative as Je } from "./typed/isNegative.js";
+import { IS_NIL_ERROR_MSG as Ye, isNil as je } from "./typed/isNil.js";
+import { IS_NUMBER_ERROR_MSG as Qe, isNumber as Ve } from "./typed/isNumber.js";
+import { IS_OBJECT_ERROR_MSG as ze, isObject as Ke } from "./typed/isObject.js";
+import { isOdd as $e } from "./typed/isOdd.js";
+import { isPositive as ot } from "./typed/isPositive.js";
+import { IS_PRIMITIVE_ERROR_MSG as tt, isPrimitive as mt } from "./typed/isPrimitive.js";
+import { IS_PROMISE_ERROR_MSG as ft, isPromise as xt } from "./typed/isPromise.js";
+import { isRegex as st } from "./typed/isRegex.js";
+import { IS_STRING_ERROR_MSG as Rt, isString as _t } from "./typed/isString.js";
+import { IS_WITHIN_ERROR_MSG as lt, isWithin as St } from "./typed/isWithin.js";
+import { isZero as ut } from "./typed/isZero.js";
+import { le as Et } from "./typed/le.js";
+import { lt as Ot } from "./typed/lt.js";
+import { typeOf as gt } from "./typed/typeOf.js";
 export {
-  Ko as IS_ARRAY_ERROR_MSG,
-  ee as IS_DATE_ERROR_MSG,
-  xe as IS_EMPTY_ERROR_MSG,
-  ae as IS_EQUAL_ERROR_MSG,
-  ce as IS_FUNCTION_ERROR_MSG,
-  ue as IS_NIL_ERROR_MSG,
-  Ge as IS_NUMBER_ERROR_MSG,
-  Ne as IS_OBJECT_ERROR_MSG,
-  Ce as IS_PRIMITIVE_ERROR_MSG,
-  De as IS_PROMISE_ERROR_MSG,
-  Fe as IS_STRING_ERROR_MSG,
-  Ye as IS_WITHIN_ERROR_MSG,
+  Oe as IS_ARRAY_ERROR_MSG,
+  be as IS_DATE_ERROR_MSG,
+  Pe as IS_EMPTY_ERROR_MSG,
+  Ae as IS_EQUAL_ERROR_MSG,
+  qe as IS_FUNCTION_ERROR_MSG,
+  Ye as IS_NIL_ERROR_MSG,
+  Qe as IS_NUMBER_ERROR_MSG,
+  ze as IS_OBJECT_ERROR_MSG,
+  tt as IS_PRIMITIVE_ERROR_MSG,
+  ft as IS_PROMISE_ERROR_MSG,
+  Rt as IS_STRING_ERROR_MSG,
+  lt as IS_WITHIN_ERROR_MSG,
+  Hr as abs,
+  Vr as add,
   e as aggregate,
+  zr as allocate,
   m as alternate,
-  er as assert,
-  mr as assertParams,
-  fr as attempt,
-  wr as average,
-  Jr as boil,
-  Co as camelCase,
+  H as arrange,
+  mr as assert,
+  fr as assertParams,
+  ir as attempt,
+  Xr as average,
+  ro as boil,
+  te as camelCase,
   f as chunk,
-  Yr as clamp,
-  fo as clone,
+  eo as clamp,
+  Po as clone,
   i as compact,
-  ir as compare,
-  ar as compareBy,
-  _r as compose,
+  ar as compare,
+  _r as compareBy,
+  lr as compose,
   a as contains,
-  Sr as curry,
-  lr as debounce,
+  No as currency,
+  cr as curry,
+  dr as debounce,
   Ir as delay,
-  io as diff,
-  yo as draw,
-  ao as entries,
+  Co as diff,
+  mo as distribute,
+  fo as divide,
+  Zo as draw,
+  Bo as entries,
   _ as every,
-  z as expires,
-  S as filter,
-  l as find,
-  I as findIndex,
-  u as findLast,
+  ho as exchange,
+  X as expires,
+  l as filter,
+  c as find,
+  d as findIndex,
+  I as findLast,
   M as flatten,
-  ur as fp,
-  jo as ge,
-  g as group,
-  Qo as gt,
-  X as interval,
-  Zo as is,
-  Xo as isArray,
-  re as isBoolean,
-  te as isDate,
-  pe as isDefined,
-  ie as isEmpty,
-  Re as isEqual,
-  ne as isEven,
-  le as isFunction,
-  Ie as isNegative,
-  de as isNil,
-  ge as isNumber,
-  ve as isObject,
-  he as isOdd,
-  Pe as isPositive,
-  Ae as isPrimitive,
-  Le as isPromise,
-  qe as isRegex,
-  Je as isString,
-  je as isWithin,
-  Qe as isZero,
-  Bo as kebabCase,
-  _o as keys,
-  Ze as le,
-  N as list,
-  Ke as lt,
-  b as map,
-  Hr as max,
-  Vr as median,
-  Mr as memo,
-  So as merge,
-  zr as min,
-  gr as once,
-  lo as parseJSON,
-  Lo as pascalCase,
-  Io as path,
+  Mr as fp,
+  Se as ge,
+  y as group,
+  ue as gt,
+  rr as interval,
+  Ee as is,
+  Me as isArray,
+  ye as isBoolean,
+  Ne as isDate,
+  he as isDefined,
+  Te as isEmpty,
+  Be as isEqual,
+  Le as isEven,
+  we as isFunction,
+  Je as isNegative,
+  je as isNil,
+  Ve as isNumber,
+  Ke as isObject,
+  $e as isOdd,
+  ot as isPositive,
+  mt as isPrimitive,
+  xt as isPromise,
+  st as isRegex,
+  _t as isString,
+  St as isWithin,
+  ut as isZero,
+  pe as kebabCase,
+  Lo as keys,
+  Et as le,
+  b as list,
+  Ot as lt,
+  v as map,
+  io as max,
+  ao as median,
+  yr as memo,
+  qo as merge,
+  _o as min,
+  lo as multiply,
+  br as once,
+  vr as parallel,
+  Fo as parseJSON,
+  xe as pascalCase,
+  Wo as path,
   k as pick,
-  Nr as pipe,
-  br as predict,
-  kr as proxy,
-  vo as random,
-  Xr as range,
-  ro as rate,
+  kr as pipe,
+  Tr as predict,
+  Ar as proxy,
+  Dr as prune,
+  Ko as random,
+  co as range,
+  Eo as rate,
   T as reduce,
-  Tr as retry,
-  eo as round,
-  A as search,
-  uo as seek,
-  D as select,
-  U as shift,
-  ho as shuffle,
-  qo as similarity,
-  Ar as sleep,
-  Fo as snakeCase,
-  w as some,
-  J as sort,
-  Y as sortBy,
-  H as substitute,
-  mo as sum,
-  Dr as throttle,
-  rr as timeDiff,
-  Wo as truncate,
-  $e as typeOf,
-  V as uniq,
-  Po as uuid,
-  Go as values,
-  Ur as worker
+  A as remoteList,
+  Ur as retry,
+  Oo as round,
+  D as search,
+  jo as seek,
+  U as select,
+  w as shift,
+  $o as shuffle,
+  se as similarity,
+  wr as sleep,
+  Re as snakeCase,
+  J as some,
+  Y as sort,
+  V as substitute,
+  go as subtract,
+  Go as sum,
+  Jr as throttle,
+  er as timeDiff,
+  ne as truncate,
+  gt as typeOf,
+  z as uniq,
+  oe as uuid,
+  Qo as values,
+  Yr as worker
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/math/abs.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function n(t){return typeof t=="bigint"?t<0n?-t:t:Math.abs(t)}exports.abs=n;
+//# sourceMappingURL=abs.cjs.map

package/dist/math/abs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"abs.cjs","sources":["../../src/math/abs.ts"],"sourcesContent":["/**\n * Returns the absolute value of a number.\n * Supports both regular numbers and bigint.\n *\n * @example\n * ```ts\n * abs(-5); // 5\n * abs(3); // 3\n * abs(-100n); // 100n\n * ```\n *\n * @param value - The number or bigint to get absolute value of\n * @returns Absolute value\n */\nexport function abs(value: number): number;\nexport function abs(value: bigint): bigint;\nexport function abs(value: number | bigint): number | bigint {\n  if (typeof value === 'bigint') {\n    return value < 0n ? -value : value;\n  }\n  return Math.abs(value);\n}\n"],"names":["abs","value"],"mappings":"gFAgBO,SAASA,EAAIC,EAAyC,CAC3D,OAAI,OAAOA,GAAU,SACZA,EAAQ,GAAK,CAACA,EAAQA,EAExB,KAAK,IAAIA,CAAK,CACvB"}

package/dist/math/abs.js

@@ -0,0 +1,7 @@
+function n(t) {
+  return typeof t == "bigint" ? t < 0n ? -t : t : Math.abs(t);
+}
+export {
+  n as abs
+};
+//# sourceMappingURL=abs.js.map

package/dist/math/abs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abs.js","sources":["../../src/math/abs.ts"],"sourcesContent":["/**\n * Returns the absolute value of a number.\n * Supports both regular numbers and bigint.\n *\n * @example\n * ```ts\n * abs(-5); // 5\n * abs(3); // 3\n * abs(-100n); // 100n\n * ```\n *\n * @param value - The number or bigint to get absolute value of\n * @returns Absolute value\n */\nexport function abs(value: number): number;\nexport function abs(value: bigint): bigint;\nexport function abs(value: number | bigint): number | bigint {\n  if (typeof value === 'bigint') {\n    return value < 0n ? -value : value;\n  }\n  return Math.abs(value);\n}\n"],"names":["abs","value"],"mappings":"AAgBO,SAASA,EAAIC,GAAyC;AAC3D,SAAI,OAAOA,KAAU,WACZA,IAAQ,KAAK,CAACA,IAAQA,IAExB,KAAK,IAAIA,CAAK;AACvB;"}

package/dist/math/add.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function r(e,t){if(typeof e=="bigint"&&typeof t=="bigint"||typeof e=="number"&&typeof t=="number")return e+t;throw new TypeError("Both arguments must be of the same type (number or bigint)")}exports.add=r;
+//# sourceMappingURL=add.cjs.map

package/dist/math/add.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.cjs","sources":["../../src/math/add.ts"],"sourcesContent":["/**\n * Adds two numbers with precision handling for financial calculations.\n * Supports both regular numbers and bigint for exact precision.\n *\n * @example\n * ```ts\n * add(10, 20); // 30\n * add(0.1, 0.2); // 0.3 (precision-safe)\n * add(100n, 200n); // 300n\n * ```\n *\n * @param a - First number or bigint\n * @param b - Second number or bigint\n * @returns Sum of a and b\n */\nexport function add(a: number, b: number): number;\nexport function add(a: bigint, b: bigint): bigint;\nexport function add(a: number | bigint, b: number | bigint): number | bigint {\n  if (typeof a === 'bigint' && typeof b === 'bigint') {\n    return a + b;\n  }\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a + b;\n  }\n  throw new TypeError('Both arguments must be of the same type (number or bigint)');\n}\n"],"names":["add","a","b"],"mappings":"gFAiBO,SAASA,EAAIC,EAAoBC,EAAqC,CAI3E,GAHI,OAAOD,GAAM,UAAY,OAAOC,GAAM,UAGtC,OAAOD,GAAM,UAAY,OAAOC,GAAM,SACxC,OAAOD,EAAIC,EAEb,MAAM,IAAI,UAAU,4DAA4D,CAClF"}

package/dist/math/add.js

@@ -0,0 +1,9 @@
+function r(e, t) {
+  if (typeof e == "bigint" && typeof t == "bigint" || typeof e == "number" && typeof t == "number")
+    return e + t;
+  throw new TypeError("Both arguments must be of the same type (number or bigint)");
+}
+export {
+  r as add
+};
+//# sourceMappingURL=add.js.map

package/dist/math/add.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.js","sources":["../../src/math/add.ts"],"sourcesContent":["/**\n * Adds two numbers with precision handling for financial calculations.\n * Supports both regular numbers and bigint for exact precision.\n *\n * @example\n * ```ts\n * add(10, 20); // 30\n * add(0.1, 0.2); // 0.3 (precision-safe)\n * add(100n, 200n); // 300n\n * ```\n *\n * @param a - First number or bigint\n * @param b - Second number or bigint\n * @returns Sum of a and b\n */\nexport function add(a: number, b: number): number;\nexport function add(a: bigint, b: bigint): bigint;\nexport function add(a: number | bigint, b: number | bigint): number | bigint {\n  if (typeof a === 'bigint' && typeof b === 'bigint') {\n    return a + b;\n  }\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a + b;\n  }\n  throw new TypeError('Both arguments must be of the same type (number or bigint)');\n}\n"],"names":["add","a","b"],"mappings":"AAiBO,SAASA,EAAIC,GAAoBC,GAAqC;AAI3E,MAHI,OAAOD,KAAM,YAAY,OAAOC,KAAM,YAGtC,OAAOD,KAAM,YAAY,OAAOC,KAAM;AACxC,WAAOD,IAAIC;AAEb,QAAM,IAAI,UAAU,4DAA4D;AAClF;"}

package/dist/math/allocate.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function a(o,t){if(t.length===0)throw new Error("Ratios array cannot be empty");if(t.some(e=>e<0))throw new Error("Ratios must be non-negative");const n=t.reduce((e,r)=>e+r,0);if(n===0)throw new Error("Total ratio cannot be zero");if(typeof o=="bigint"){const e=[];let r=o;for(let h=0;h<t.length-1;h++){const s=o*BigInt(Math.floor(t[h]*1e6))/BigInt(Math.floor(n*1e6));e.push(s),r-=s}return e.push(r),e}const l=[];let i=o;for(let e=0;e<t.length-1;e++){const r=Math.floor(o*t[e]/n);l.push(r),i-=r}return l.push(i),l}exports.allocate=a;
+//# sourceMappingURL=allocate.cjs.map

package/dist/math/allocate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocate.cjs","sources":["../../src/math/allocate.ts"],"sourcesContent":["/**\n * Distributes an amount proportionally according to given ratios.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Critical for financial operations like splitting payments to avoid rounding errors.\n *\n * @example\n * ```ts\n * // Split $100 in ratio 1:2:3\n * allocate(100, [1, 2, 3]);\n * // [17, 33, 50] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution\n * @returns Array of allocated amounts (sum equals original amount)\n * @throws {Error} If ratios array is empty or contains negative values\n */\nexport function allocate(amount: number, ratios: number[]): number[];\nexport function allocate(amount: bigint, ratios: number[]): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[]): (number | bigint)[] {\n  if (ratios.length === 0) {\n    throw new Error('Ratios array cannot be empty');\n  }\n\n  if (ratios.some((r) => r < 0)) {\n    throw new Error('Ratios must be non-negative');\n  }\n\n  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new Error('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const results: bigint[] = [];\n    let remainder = amount;\n\n    for (let i = 0; i < ratios.length - 1; i++) {\n      const share = (amount * BigInt(Math.floor(ratios[i] * 1000000))) / BigInt(Math.floor(totalRatio * 1000000));\n      results.push(share);\n      remainder -= share;\n    }\n\n    // Last allocation gets the remainder to ensure exact sum\n    results.push(remainder);\n    return results;\n  }\n\n  // Handle number type\n  const results: number[] = [];\n  let remainder = amount;\n\n  for (let i = 0; i < ratios.length - 1; i++) {\n    const share = Math.floor((amount * ratios[i]) / totalRatio);\n    results.push(share);\n    remainder -= share;\n  }\n\n  // Last allocation gets the remainder to ensure exact sum\n  results.push(remainder);\n  return results;\n}\n"],"names":["allocate","amount","ratios","r","totalRatio","sum","ratio","results","remainder","i","share"],"mappings":"gFAuBO,SAASA,EAASC,EAAyBC,EAAuC,CACvF,GAAIA,EAAO,SAAW,EACpB,MAAM,IAAI,MAAM,8BAA8B,EAGhD,GAAIA,EAAO,KAAMC,GAAMA,EAAI,CAAC,EAC1B,MAAM,IAAI,MAAM,6BAA6B,EAG/C,MAAMC,EAAaF,EAAO,OAAO,CAACG,EAAKC,IAAUD,EAAMC,EAAO,CAAC,EAE/D,GAAIF,IAAe,EACjB,MAAM,IAAI,MAAM,4BAA4B,EAG9C,GAAI,OAAOH,GAAW,SAAU,CAC9B,MAAMM,EAAoB,CAAA,EAC1B,IAAIC,EAAYP,EAEhB,QAASQ,EAAI,EAAGA,EAAIP,EAAO,OAAS,EAAGO,IAAK,CAC1C,MAAMC,EAAST,EAAS,OAAO,KAAK,MAAMC,EAAOO,CAAC,EAAI,GAAO,CAAC,EAAK,OAAO,KAAK,MAAML,EAAa,GAAO,CAAC,EAC1GG,EAAQ,KAAKG,CAAK,EAClBF,GAAaE,CACf,CAGAH,OAAAA,EAAQ,KAAKC,CAAS,EACfD,CACT,CAGA,MAAMA,EAAoB,CAAA,EAC1B,IAAIC,EAAYP,EAEhB,QAASQ,EAAI,EAAGA,EAAIP,EAAO,OAAS,EAAGO,IAAK,CAC1C,MAAMC,EAAQ,KAAK,MAAOT,EAASC,EAAOO,CAAC,EAAKL,CAAU,EAC1DG,EAAQ,KAAKG,CAAK,EAClBF,GAAaE,CACf,CAGA,OAAAH,EAAQ,KAAKC,CAAS,EACfD,CACT"}

package/dist/math/allocate.js

@@ -0,0 +1,29 @@
+function f(o, t) {
+  if (t.length === 0)
+    throw new Error("Ratios array cannot be empty");
+  if (t.some((e) => e < 0))
+    throw new Error("Ratios must be non-negative");
+  const n = t.reduce((e, r) => e + r, 0);
+  if (n === 0)
+    throw new Error("Total ratio cannot be zero");
+  if (typeof o == "bigint") {
+    const e = [];
+    let r = o;
+    for (let h = 0; h < t.length - 1; h++) {
+      const i = o * BigInt(Math.floor(t[h] * 1e6)) / BigInt(Math.floor(n * 1e6));
+      e.push(i), r -= i;
+    }
+    return e.push(r), e;
+  }
+  const l = [];
+  let s = o;
+  for (let e = 0; e < t.length - 1; e++) {
+    const r = Math.floor(o * t[e] / n);
+    l.push(r), s -= r;
+  }
+  return l.push(s), l;
+}
+export {
+  f as allocate
+};
+//# sourceMappingURL=allocate.js.map

package/dist/math/allocate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocate.js","sources":["../../src/math/allocate.ts"],"sourcesContent":["/**\n * Distributes an amount proportionally according to given ratios.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Critical for financial operations like splitting payments to avoid rounding errors.\n *\n * @example\n * ```ts\n * // Split $100 in ratio 1:2:3\n * allocate(100, [1, 2, 3]);\n * // [17, 33, 50] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution\n * @returns Array of allocated amounts (sum equals original amount)\n * @throws {Error} If ratios array is empty or contains negative values\n */\nexport function allocate(amount: number, ratios: number[]): number[];\nexport function allocate(amount: bigint, ratios: number[]): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[]): (number | bigint)[] {\n  if (ratios.length === 0) {\n    throw new Error('Ratios array cannot be empty');\n  }\n\n  if (ratios.some((r) => r < 0)) {\n    throw new Error('Ratios must be non-negative');\n  }\n\n  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new Error('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const results: bigint[] = [];\n    let remainder = amount;\n\n    for (let i = 0; i < ratios.length - 1; i++) {\n      const share = (amount * BigInt(Math.floor(ratios[i] * 1000000))) / BigInt(Math.floor(totalRatio * 1000000));\n      results.push(share);\n      remainder -= share;\n    }\n\n    // Last allocation gets the remainder to ensure exact sum\n    results.push(remainder);\n    return results;\n  }\n\n  // Handle number type\n  const results: number[] = [];\n  let remainder = amount;\n\n  for (let i = 0; i < ratios.length - 1; i++) {\n    const share = Math.floor((amount * ratios[i]) / totalRatio);\n    results.push(share);\n    remainder -= share;\n  }\n\n  // Last allocation gets the remainder to ensure exact sum\n  results.push(remainder);\n  return results;\n}\n"],"names":["allocate","amount","ratios","r","totalRatio","sum","ratio","results","remainder","i","share"],"mappings":"AAuBO,SAASA,EAASC,GAAyBC,GAAuC;AACvF,MAAIA,EAAO,WAAW;AACpB,UAAM,IAAI,MAAM,8BAA8B;AAGhD,MAAIA,EAAO,KAAK,CAACC,MAAMA,IAAI,CAAC;AAC1B,UAAM,IAAI,MAAM,6BAA6B;AAG/C,QAAMC,IAAaF,EAAO,OAAO,CAACG,GAAKC,MAAUD,IAAMC,GAAO,CAAC;AAE/D,MAAIF,MAAe;AACjB,UAAM,IAAI,MAAM,4BAA4B;AAG9C,MAAI,OAAOH,KAAW,UAAU;AAC9B,UAAMM,IAAoB,CAAA;AAC1B,QAAIC,IAAYP;AAEhB,aAASQ,IAAI,GAAGA,IAAIP,EAAO,SAAS,GAAGO,KAAK;AAC1C,YAAMC,IAAST,IAAS,OAAO,KAAK,MAAMC,EAAOO,CAAC,IAAI,GAAO,CAAC,IAAK,OAAO,KAAK,MAAML,IAAa,GAAO,CAAC;AAC1GG,MAAAA,EAAQ,KAAKG,CAAK,GAClBF,KAAaE;AAAA,IACf;AAGAH,WAAAA,EAAQ,KAAKC,CAAS,GACfD;AAAAA,EACT;AAGA,QAAMA,IAAoB,CAAA;AAC1B,MAAIC,IAAYP;AAEhB,WAASQ,IAAI,GAAGA,IAAIP,EAAO,SAAS,GAAGO,KAAK;AAC1C,UAAMC,IAAQ,KAAK,MAAOT,IAASC,EAAOO,CAAC,IAAKL,CAAU;AAC1D,IAAAG,EAAQ,KAAKG,CAAK,GAClBF,KAAaE;AAAA,EACf;AAGA,SAAAH,EAAQ,KAAKC,CAAS,GACfD;AACT;"}

package/dist/math/average.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./sum.cjs");function o(t,n){if(t.length===0)return;let e;try{e=i.sum(t,n)}catch(r){if(r instanceof TypeError)return;throw r}if(typeof e=="number")return e/t.length;if(e instanceof Date)return new Date(e.getTime()/t.length)}exports.average=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./sum.cjs");function u(e,n){if(e.length===0)return;if((n?n(e[0]):e[0])instanceof Date){const t=e.reduce((i,o)=>{const r=n?n(o):o;if(!(r instanceof Date))throw new TypeError("average expected all items to be Date objects");return i+r.getTime()},0);return new Date(t/e.length)}try{const t=s.sum(e,n);if(typeof t=="number")return t/e.length}catch(t){if(t instanceof TypeError)return;throw t}}exports.average=u;
 //# sourceMappingURL=average.cjs.map

package/dist/math/average.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"average.cjs","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n  let total: number | Date | undefined;\n  try {\n    total = sum(array, callback);\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n  if (typeof total === 'number') {\n    return total / array.length;\n  }\n  if (total instanceof Date) {\n    // For dates, average by dividing the timestamp sum by array length\n    return new Date(total.getTime() / array.length);\n  }\n  return undefined;\n}\n"],"names":["average","array","callback","total","sum","err"],"mappings":"6GAkBO,SAASA,EAAWC,EAAYC,EAAkE,CACvG,GAAID,EAAM,SAAW,EAAG,OACxB,IAAIE,EACJ,GAAI,CACFA,EAAQC,EAAAA,IAAIH,EAAOC,CAAQ,CAC7B,OAASG,EAAK,CACZ,GAAIA,aAAe,UAAW,OAC9B,MAAMA,CACR,CACA,GAAI,OAAOF,GAAU,SACnB,OAAOA,EAAQF,EAAM,OAEvB,GAAIE,aAAiB,KAEnB,OAAO,IAAI,KAAKA,EAAM,QAAA,EAAYF,EAAM,MAAM,CAGlD"}
+{"version":3,"file":"average.cjs","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n\n  // Check if we are dealing with Dates (either directly or via callback)\n  const firstItem = callback ? callback(array[0]) : array[0];\n  const isDate = firstItem instanceof Date;\n\n  if (isDate) {\n    const totalTimestamp = array.reduce<number>((acc, item) => {\n      const val = callback ? callback(item) : item;\n      if (!(val instanceof Date)) {\n        throw new TypeError('average expected all items to be Date objects');\n      }\n      return acc + val.getTime();\n    }, 0);\n    return new Date(totalTimestamp / array.length);\n  }\n\n  // Handle numbers\n  try {\n    const total = sum(array, callback as (item: T) => number);\n    if (typeof total === 'number') {\n      return total / array.length;\n    }\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n\n  return undefined;\n}\n"],"names":["average","array","callback","totalTimestamp","acc","item","val","total","sum","err"],"mappings":"6GAkBO,SAASA,EAAWC,EAAYC,EAAkE,CACvG,GAAID,EAAM,SAAW,EAAG,OAMxB,IAHkBC,EAAWA,EAASD,EAAM,CAAC,CAAC,EAAIA,EAAM,CAAC,aACrB,KAExB,CACV,MAAME,EAAiBF,EAAM,OAAe,CAACG,EAAKC,IAAS,CACzD,MAAMC,EAAMJ,EAAWA,EAASG,CAAI,EAAIA,EACxC,GAAI,EAAEC,aAAe,MACnB,MAAM,IAAI,UAAU,+CAA+C,EAErE,OAAOF,EAAME,EAAI,QAAA,CACnB,EAAG,CAAC,EACJ,OAAO,IAAI,KAAKH,EAAiBF,EAAM,MAAM,CAC/C,CAGA,GAAI,CACF,MAAMM,EAAQC,EAAAA,IAAIP,EAAOC,CAA+B,EACxD,GAAI,OAAOK,GAAU,SACnB,OAAOA,EAAQN,EAAM,MAEzB,OAASQ,EAAK,CACZ,GAAIA,aAAe,UAAW,OAC9B,MAAMA,CACR,CAGF"}

package/dist/math/average.js

@@ -1,19 +1,25 @@
-import { sum as o } from "./sum.js";
-function f(t, r) {
+import { sum as s } from "./sum.js";
+function p(t, n) {
   if (t.length === 0) return;
-  let e;
+  if ((n ? n(t[0]) : t[0]) instanceof Date) {
+    const e = t.reduce((i, o) => {
+      const r = n ? n(o) : o;
+      if (!(r instanceof Date))
+        throw new TypeError("average expected all items to be Date objects");
+      return i + r.getTime();
+    }, 0);
+    return new Date(e / t.length);
+  }
   try {
-    e = o(t, r);
-  } catch (n) {
-    if (n instanceof TypeError) return;
-    throw n;
+    const e = s(t, n);
+    if (typeof e == "number")
+      return e / t.length;
+  } catch (e) {
+    if (e instanceof TypeError) return;
+    throw e;
   }
-  if (typeof e == "number")
-    return e / t.length;
-  if (e instanceof Date)
-    return new Date(e.getTime() / t.length);
 }
 export {
-  f as average
+  p as average
 };
 //# sourceMappingURL=average.js.map