@vielzeug/arsenal 1.1.2 → 2.0.1

package/dist/index.d.ts

@@ -1,119 +1,30 @@
-export { ArsenalError, ArsenalSerializationError, ArsenalValidationError } from './errors';
+export * from './errors';
 export * from './array/chunk';
-export * from './array/compact';
-export * from './array/compare';
-export * from './array/compareBy';
-export * from './array/contains';
-export * from './array/countBy';
-export * from './array/difference';
-export * from './array/drop';
-export * from './array/dropLast';
 export * from './array/filterMap';
-export * from './array/first';
-export * from './array/flatten';
 export * from './array/groupBy';
 export * from './array/indexBy';
-export * from './array/intersection';
-export * from './array/last';
 export * from './array/partition';
-export * from './array/replace';
-export * from './array/rotate';
-export * from './array/search';
 export * from './array/sort';
-export * from './array/take';
-export * from './array/takeLast';
-export * from './array/toggle';
-export * from './array/union';
 export * from './array/uniq';
-export * from './array/unzip';
-export * from './array/zip';
-export * from './async/abortError';
 export * from './async/attempt';
-export * from './async/backoff';
 export * from './async/parallel';
-export * from './async/queue';
 export * from './async/retry';
 export * from './async/sleep';
-export * from './async/waitFor';
-export * from './cache/memo';
-export * from './cache/stash';
-export * from './function/assert';
-export * from './function/constant';
 export * from './function/debounce';
-export * from './function/identity';
 export * from './function/once';
 export * from './function/pipe';
-export * from './function/runAll';
-export * from './function/tap';
 export * from './function/throttle';
 export * from './guards/combinators';
-export * from './guards/isAbortError';
-export * from './guards/isArray';
-export * from './guards/isBoolean';
-export * from './guards/isDate';
 export * from './guards/isDefined';
-export * from './guards/isEmpty';
 export * from './guards/isEqual';
-export * from './guards/isError';
-export * from './guards/isFunction';
-export * from './guards/isMatch';
 export * from './guards/isNil';
-export * from './guards/isNumber';
 export * from './guards/isPlainObject';
-export * from './guards/isPrimitive';
-export * from './guards/isPromise';
-export * from './guards/isRegex';
-export * from './guards/isString';
-export * from './guards/shallowEqual';
-export * from './math/abs';
-export * from './math/allocate';
-export * from './math/average';
 export * from './math/clamp';
-export * from './math/gcd';
-export * from './math/lcm';
-export * from './math/lerp';
-export * from './math/linspace';
-export * from './math/max';
-export * from './math/median';
-export * from './math/min';
-export * from './math/mod';
-export * from './math/normalize';
-export * from './math/percent';
 export * from './math/range';
-export * from './math/round';
-export * from './math/standardDeviation';
-export * from './math/sum';
-export * from './math/variance';
-export * from './object/defaults';
-export * from './object/diff';
-export * from './object/filterValues';
-export * from './object/flattenPaths';
 export * from './object/getPath';
-export * from './object/invert';
-export * from './object/mapKeys';
-export * from './object/mapValues';
-export * from './object/merge';
+export * from './object/hash';
 export * from './object/omit';
-export * from './object/parseJSON';
 export * from './object/pick';
-export * from './object/prune';
-export * from './object/hash';
-export * from './random/draw';
-export * from './random/random';
-export * from './random/shuffle';
 export * from './random/uuid';
 export * from './string/camelCase';
-export * from './string/endsWith';
-export * from './string/escape';
-export * from './string/kebabCase';
-export * from './string/pad';
-export * from './string/pascalCase';
-export * from './string/similarity';
-export * from './string/snakeCase';
-export * from './string/startsWith';
-export * from './string/titleCase';
-export * from './string/truncate';
-export * from './string/unescape';
-export * from './string/words';
-export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -1,118 +1,30 @@
-import { ArsenalError as e, ArsenalSerializationError as t, ArsenalValidationError as n } from "./errors.js";
-import { isString as r } from "./guards/isString.js";
-import { chunk as i } from "./array/chunk.js";
-import { compact as a } from "./array/compact.js";
-import { compare as o } from "./array/compare.js";
-import { compareBy as s } from "./array/compareBy.js";
-import { isEqual as c } from "./guards/isEqual.js";
-import { contains as l } from "./array/contains.js";
-import { countBy as u } from "./array/countBy.js";
-import { difference as d } from "./array/difference.js";
-import { drop as f } from "./array/drop.js";
-import { dropLast as p } from "./array/dropLast.js";
-import { filterMap as m } from "./array/filterMap.js";
-import { first as h } from "./array/first.js";
-import { flatten as g } from "./array/flatten.js";
-import { groupBy as _ } from "./array/groupBy.js";
-import { indexBy as v } from "./array/indexBy.js";
-import { intersection as y } from "./array/intersection.js";
-import { last as b } from "./array/last.js";
-import { partition as x } from "./array/partition.js";
-import { replace as S } from "./array/replace.js";
-import { rotate as C } from "./array/rotate.js";
-import { isNil as w } from "./guards/isNil.js";
-import { isNumber as T } from "./guards/isNumber.js";
-import { similarity as E } from "./string/similarity.js";
-import { fuzzy as D, fuzzyFilter as O, fuzzyScore as k } from "./array/search.js";
-import { sort as A } from "./array/sort.js";
-import { take as j } from "./array/take.js";
-import { takeLast as M } from "./array/takeLast.js";
-import { toggle as N } from "./array/toggle.js";
-import { union as P } from "./array/union.js";
-import { uniq as F } from "./array/uniq.js";
-import { unzip as I } from "./array/unzip.js";
-import { zip as L } from "./array/zip.js";
-import { abortError as R } from "./async/abortError.js";
-import { attempt as z, isFail as B, isOk as V } from "./async/attempt.js";
-import { backoff as H } from "./async/backoff.js";
-import { parallel as U } from "./async/parallel.js";
-import { queue as W } from "./async/queue.js";
-import { sleep as G } from "./async/sleep.js";
-import { retry as K } from "./async/retry.js";
-import { waitFor as q } from "./async/waitFor.js";
-import { memo as J } from "./cache/memo.js";
-import { isPromise as Y } from "./guards/isPromise.js";
-import { stash as X } from "./cache/stash.js";
-import { assert as Z } from "./function/assert.js";
-import { constant as Q } from "./function/constant.js";
-import { debounce as $ } from "./function/debounce.js";
-import { identity as ee } from "./function/identity.js";
-import { once as te } from "./function/once.js";
-import { pipe as ne } from "./function/pipe.js";
-import { runAll as re } from "./function/runAll.js";
-import { tap as ie } from "./function/tap.js";
-import { throttle as ae } from "./function/throttle.js";
-import { allOf as oe, anyOf as se, noneOf as ce, not as le } from "./guards/combinators.js";
-import { isAbortError as ue } from "./guards/isAbortError.js";
-import { isArray as de } from "./guards/isArray.js";
-import { isBoolean as fe } from "./guards/isBoolean.js";
-import { isDate as pe } from "./guards/isDate.js";
-import { isDefined as me } from "./guards/isDefined.js";
-import { isPlainObject as he } from "./guards/isPlainObject.js";
-import { isEmpty as ge } from "./guards/isEmpty.js";
-import { isError as _e } from "./guards/isError.js";
-import { isFunction as ve } from "./guards/isFunction.js";
-import { isMatch as ye } from "./guards/isMatch.js";
-import { isPrimitive as be } from "./guards/isPrimitive.js";
-import { isRegex as xe } from "./guards/isRegex.js";
-import { shallowEqual as Se } from "./guards/shallowEqual.js";
-import { abs as Ce } from "./math/abs.js";
-import { allocate as we } from "./math/allocate.js";
-import { sum as Te } from "./math/sum.js";
-import { average as Ee } from "./math/average.js";
-import { clamp as De } from "./math/clamp.js";
-import { gcd as Oe } from "./math/gcd.js";
-import { lcm as ke } from "./math/lcm.js";
-import { lerp as Ae } from "./math/lerp.js";
-import { linspace as je } from "./math/linspace.js";
-import { max as Me } from "./math/max.js";
-import { median as Ne } from "./math/median.js";
-import { min as Pe } from "./math/min.js";
-import { mod as Fe } from "./math/mod.js";
-import { normalize as Ie } from "./math/normalize.js";
-import { percent as Le } from "./math/percent.js";
-import { range as Re } from "./math/range.js";
-import { round as ze } from "./math/round.js";
-import { variance as Be } from "./math/variance.js";
-import { standardDeviation as Ve } from "./math/standardDeviation.js";
-import { defaults as He } from "./object/defaults.js";
-import { diff as Ue, diffArrays as We } from "./object/diff.js";
-import { filterValues as Ge } from "./object/filterValues.js";
-import { flattenPaths as Ke, unflattenPaths as qe } from "./object/flattenPaths.js";
-import { getPath as Je } from "./object/getPath.js";
-import { invert as Ye } from "./object/invert.js";
-import { mapKeys as Xe } from "./object/mapKeys.js";
-import { mapValues as Ze } from "./object/mapValues.js";
-import { deepMerge as Qe, shallowMerge as $e } from "./object/merge.js";
-import { omit as et } from "./object/omit.js";
-import { parseJSON as tt } from "./object/parseJSON.js";
-import { pick as nt } from "./object/pick.js";
-import { prune as rt } from "./object/prune.js";
-import { hash as it } from "./object/hash.js";
-import { random as at } from "./random/random.js";
-import { draw as ot, drawMany as st } from "./random/draw.js";
-import { shuffle as ct } from "./random/shuffle.js";
-import { uuid as lt } from "./random/uuid.js";
-import { camelCase as ut } from "./string/camelCase.js";
-import { endsWith as dt } from "./string/endsWith.js";
-import { escape as ft } from "./string/escape.js";
-import { kebabCase as pt } from "./string/kebabCase.js";
-import { pad as mt } from "./string/pad.js";
-import { pascalCase as ht } from "./string/pascalCase.js";
-import { snakeCase as gt } from "./string/snakeCase.js";
-import { startsWith as _t } from "./string/startsWith.js";
-import { words as vt } from "./string/words.js";
-import { titleCase as yt } from "./string/titleCase.js";
-import { truncate as bt } from "./string/truncate.js";
-import { unescape as xt } from "./string/unescape.js";
-export { e as ArsenalError, t as ArsenalSerializationError, n as ArsenalValidationError, R as abortError, Ce as abs, oe as allOf, we as allocate, se as anyOf, Z as assert, z as attempt, Ee as average, H as backoff, ut as camelCase, i as chunk, De as clamp, a as compact, o as compare, s as compareBy, Q as constant, l as contains, u as countBy, $ as debounce, Qe as deepMerge, He as defaults, Ue as diff, We as diffArrays, d as difference, ot as draw, st as drawMany, f as drop, p as dropLast, dt as endsWith, ft as escape, m as filterMap, Ge as filterValues, h as first, g as flatten, Ke as flattenPaths, D as fuzzy, O as fuzzyFilter, k as fuzzyScore, Oe as gcd, Je as getPath, _ as groupBy, it as hash, ee as identity, v as indexBy, y as intersection, Ye as invert, ue as isAbortError, de as isArray, fe as isBoolean, pe as isDate, me as isDefined, ge as isEmpty, c as isEqual, _e as isError, B as isFail, ve as isFunction, ye as isMatch, w as isNil, T as isNumber, V as isOk, he as isPlainObject, be as isPrimitive, Y as isPromise, xe as isRegex, r as isString, pt as kebabCase, b as last, ke as lcm, Ae as lerp, je as linspace, Xe as mapKeys, Ze as mapValues, Me as max, Ne as median, J as memo, Pe as min, Fe as mod, ce as noneOf, Ie as normalize, le as not, et as omit, te as once, mt as pad, U as parallel, tt as parseJSON, x as partition, ht as pascalCase, Le as percent, nt as pick, ne as pipe, rt as prune, W as queue, at as random, Re as range, S as replace, K as retry, C as rotate, ze as round, re as runAll, Se as shallowEqual, $e as shallowMerge, ct as shuffle, E as similarity, G as sleep, gt as snakeCase, A as sort, Ve as standardDeviation, _t as startsWith, X as stash, Te as sum, j as take, M as takeLast, ie as tap, ae as throttle, yt as titleCase, N as toggle, bt as truncate, xt as unescape, qe as unflattenPaths, P as union, F as uniq, I as unzip, lt as uuid, Be as variance, q as waitFor, vt as words, L as zip };
+import { chunk as e } from "./array/chunk.js";
+import { isEqual as t } from "./guards/isEqual.js";
+import { filterMap as n } from "./array/filterMap.js";
+import { groupBy as r } from "./array/groupBy.js";
+import { indexBy as i } from "./array/indexBy.js";
+import { partition as a } from "./array/partition.js";
+import { sort as o } from "./array/sort.js";
+import { uniq as s } from "./array/uniq.js";
+import { attempt as c, isFail as l, isOk as u } from "./async/attempt.js";
+import { parallel as d } from "./async/parallel.js";
+import { sleep as f } from "./async/sleep.js";
+import { retry as p } from "./async/retry.js";
+import { ArsenalError as m, ArsenalSerializationError as h } from "./errors.js";
+import { debounce as g } from "./function/debounce.js";
+import { once as _ } from "./function/once.js";
+import { pipe as v } from "./function/pipe.js";
+import { throttle as y } from "./function/throttle.js";
+import { allOf as b, anyOf as x, noneOf as S, not as C } from "./guards/combinators.js";
+import { isDefined as w } from "./guards/isDefined.js";
+import { isNil as T } from "./guards/isNil.js";
+import { isPlainObject as E } from "./guards/isPlainObject.js";
+import { clamp as D } from "./math/clamp.js";
+import { range as O } from "./math/range.js";
+import { getPath as k, getPathOr as A, requirePath as j } from "./object/getPath.js";
+import { hash as M } from "./object/hash.js";
+import { omit as N } from "./object/omit.js";
+import { pick as P } from "./object/pick.js";
+import { uuid as F } from "./random/uuid.js";
+import { camelCase as I } from "./string/camelCase.js";
+export { m as ArsenalError, h as ArsenalSerializationError, b as allOf, x as anyOf, c as attempt, I as camelCase, e as chunk, D as clamp, g as debounce, n as filterMap, k as getPath, A as getPathOr, r as groupBy, M as hash, i as indexBy, w as isDefined, t as isEqual, l as isFail, T as isNil, u as isOk, E as isPlainObject, S as noneOf, C as not, N as omit, _ as once, d as parallel, a as partition, P as pick, v as pipe, O as range, j as requirePath, p as retry, f as sleep, o as sort, y as throttle, s as uniq, F as uuid };

package/dist/math/allocate.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs");function t(t,n){if(typeof n==`number`&&(!Number.isInteger(n)||n<1))throw new e.ArsenalValidationError(`Parts must be a positive integer, got ${n}`);let r=Array.isArray(n)?n:Array(n).fill(1);if(r.length===0)throw new e.ArsenalValidationError(`Ratios array cannot be empty`);if(r.some(e=>e<0))throw new e.ArsenalValidationError(`Ratios must be non-negative`);let i=r.reduce((e,t)=>e+t,0);if(i===0)throw new e.ArsenalValidationError(`Total ratio cannot be zero`);if(typeof t==`bigint`){let e=BigInt(i),n=Array.from({length:r.length-1},(n,i)=>t*BigInt(r[i])/e);return n.push(t-n.reduce((e,t)=>e+t,0n)),n}let a=Array.from({length:r.length-1},(e,n)=>Math.floor(t*r[n]/i));return a.push(t-a.reduce((e,t)=>e+t,0)),a}exports.allocate=t;
+function e(e,t){if(typeof t==`number`&&(!Number.isInteger(t)||t<1))throw RangeError(`allocate: parts must be a positive integer, got ${t}`);let n=Array.isArray(t)?t:Array(t).fill(1);if(n.length===0)throw RangeError(`Ratios array cannot be empty`);if(n.some(e=>e<0))throw RangeError(`Ratios must be non-negative`);let r=n.reduce((e,t)=>e+t,0);if(r===0)throw RangeError(`Total ratio cannot be zero`);if(typeof e==`bigint`){let t=BigInt(r),i=Array.from({length:n.length-1},(r,i)=>e*BigInt(n[i])/t);return i.push(e-i.reduce((e,t)=>e+t,0n)),i}let i=Array.from({length:n.length-1},(t,i)=>Math.floor(e*n[i]/r));return i.push(e-i.reduce((e,t)=>e+t,0)),i}exports.allocate=e;
 //# sourceMappingURL=allocate.cjs.map

package/dist/math/allocate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"allocate.cjs","names":[],"sources":["../../src/math/allocate.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\n * Distributes an amount proportionally according to given ratios.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * The indivisible remainder is allocated to the last bucket.\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 (total ratio = 6)\n * allocate(100, [1, 2, 3]);\n * // [16, 33, 51] - sum is exactly 100\n *\n * // Split $100 evenly among 3 parts\n * allocate(100, 3);\n * // [33, 33, 34] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3333n, 3333n, 3334n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution or number of equal parts\n * @returns Array of allocated amounts with remainder applied to last bucket (sum equals original amount)\n * @throws {ArsenalValidationError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer\n */\nexport function allocate(amount: number, ratios: number[] | number): number[];\nexport function allocate(amount: bigint, ratios: number[] | number): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[] | number): (number | bigint)[] {\n  // If second param is a number, validate and treat it as number of equal parts\n  if (typeof ratios === 'number') {\n    if (!Number.isInteger(ratios) || ratios < 1) {\n      throw new ArsenalValidationError(`Parts must be a positive integer, got ${ratios}`);\n    }\n  }\n\n  const actualRatios = Array.isArray(ratios) ? ratios : Array(ratios).fill(1);\n\n  if (actualRatios.length === 0) {\n    throw new ArsenalValidationError('Ratios array cannot be empty');\n  }\n\n  if (actualRatios.some((r) => r < 0)) {\n    throw new ArsenalValidationError('Ratios must be non-negative');\n  }\n\n  const totalRatio = actualRatios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new ArsenalValidationError('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const totalRatioBigInt = BigInt(totalRatio);\n    const results = Array.from(\n      { length: actualRatios.length - 1 },\n      (_, i) => (amount * BigInt(actualRatios[i])) / totalRatioBigInt,\n    );\n\n    results.push(amount - results.reduce((s, v) => s + v, 0n));\n\n    return results;\n  }\n\n  // For number type, use proportional allocation for all ratios uniformly\n  const results = Array.from({ length: actualRatios.length - 1 }, (_, i) =>\n    Math.floor((amount * actualRatios[i]) / totalRatio),\n  );\n\n  results.push(amount - results.reduce((s, v) => s + v, 0));\n\n  return results;\n}\n"],"mappings":"iCA8BA,SAAgB,EAAS,EAAyB,EAAgD,CAEhG,GAAI,OAAO,GAAW,WAChB,CAAC,OAAO,UAAU,CAAM,GAAK,EAAS,GACxC,MAAM,IAAI,EAAA,uBAAuB,yCAAyC,GAAQ,EAItF,IAAM,EAAe,MAAM,QAAQ,CAAM,EAAI,EAAS,MAAM,CAAM,CAAC,CAAC,KAAK,CAAC,EAE1E,GAAI,EAAa,SAAW,EAC1B,MAAM,IAAI,EAAA,uBAAuB,8BAA8B,EAGjE,GAAI,EAAa,KAAM,GAAM,EAAI,CAAC,EAChC,MAAM,IAAI,EAAA,uBAAuB,6BAA6B,EAGhE,IAAM,EAAa,EAAa,QAAQ,EAAK,IAAU,EAAM,EAAO,CAAC,EAErE,GAAI,IAAe,EACjB,MAAM,IAAI,EAAA,uBAAuB,4BAA4B,EAG/D,GAAI,OAAO,GAAW,SAAU,CAC9B,IAAM,EAAmB,OAAO,CAAU,EACpC,EAAU,MAAM,KACpB,CAAE,OAAQ,EAAa,OAAS,CAAE,GACjC,EAAG,IAAO,EAAS,OAAO,EAAa,EAAE,EAAK,CACjD,EAIA,OAFA,EAAQ,KAAK,EAAS,EAAQ,QAAQ,EAAG,IAAM,EAAI,EAAG,EAAE,CAAC,EAElD,CACT,CAGA,IAAM,EAAU,MAAM,KAAK,CAAE,OAAQ,EAAa,OAAS,CAAE,GAAI,EAAG,IAClE,KAAK,MAAO,EAAS,EAAa,GAAM,CAAU,CACpD,EAIA,OAFA,EAAQ,KAAK,EAAS,EAAQ,QAAQ,EAAG,IAAM,EAAI,EAAG,CAAC,CAAC,EAEjD,CACT"}
+{"version":3,"file":"allocate.cjs","names":[],"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 * The indivisible remainder is allocated to the last bucket.\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 (total ratio = 6)\n * allocate(100, [1, 2, 3]);\n * // [16, 33, 51] - sum is exactly 100\n *\n * // Split $100 evenly among 3 parts\n * allocate(100, 3);\n * // [33, 33, 34] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3333n, 3333n, 3334n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution or number of equal parts\n * @returns Array of allocated amounts with remainder applied to last bucket (sum equals original amount)\n * @throws {RangeError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer.\n */\nexport function allocate(amount: number, ratios: number[] | number): number[];\nexport function allocate(amount: bigint, ratios: number[] | number): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[] | number): (number | bigint)[] {\n  // If second param is a number, validate and treat it as number of equal parts\n  if (typeof ratios === 'number') {\n    if (!Number.isInteger(ratios) || ratios < 1) {\n      throw new RangeError(`allocate: parts must be a positive integer, got ${ratios}`);\n    }\n  }\n\n  const actualRatios = Array.isArray(ratios) ? ratios : Array(ratios).fill(1);\n\n  if (actualRatios.length === 0) {\n    throw new RangeError('Ratios array cannot be empty');\n  }\n\n  if (actualRatios.some((r) => r < 0)) {\n    throw new RangeError('Ratios must be non-negative');\n  }\n\n  const totalRatio = actualRatios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new RangeError('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const totalRatioBigInt = BigInt(totalRatio);\n    const results = Array.from(\n      { length: actualRatios.length - 1 },\n      (_, i) => (amount * BigInt(actualRatios[i])) / totalRatioBigInt,\n    );\n\n    results.push(amount - results.reduce((s, v) => s + v, 0n));\n\n    return results;\n  }\n\n  // For number type, use proportional allocation for all ratios uniformly\n  const results = Array.from({ length: actualRatios.length - 1 }, (_, i) =>\n    Math.floor((amount * actualRatios[i]) / totalRatio),\n  );\n\n  results.push(amount - results.reduce((s, v) => s + v, 0));\n\n  return results;\n}\n"],"mappings":"AA4BA,SAAgB,EAAS,EAAyB,EAAgD,CAEhG,GAAI,OAAO,GAAW,WAChB,CAAC,OAAO,UAAU,CAAM,GAAK,EAAS,GACxC,MAAU,WAAW,mDAAmD,GAAQ,EAIpF,IAAM,EAAe,MAAM,QAAQ,CAAM,EAAI,EAAS,MAAM,CAAM,CAAC,CAAC,KAAK,CAAC,EAE1E,GAAI,EAAa,SAAW,EAC1B,MAAU,WAAW,8BAA8B,EAGrD,GAAI,EAAa,KAAM,GAAM,EAAI,CAAC,EAChC,MAAU,WAAW,6BAA6B,EAGpD,IAAM,EAAa,EAAa,QAAQ,EAAK,IAAU,EAAM,EAAO,CAAC,EAErE,GAAI,IAAe,EACjB,MAAU,WAAW,4BAA4B,EAGnD,GAAI,OAAO,GAAW,SAAU,CAC9B,IAAM,EAAmB,OAAO,CAAU,EACpC,EAAU,MAAM,KACpB,CAAE,OAAQ,EAAa,OAAS,CAAE,GACjC,EAAG,IAAO,EAAS,OAAO,EAAa,EAAE,EAAK,CACjD,EAIA,OAFA,EAAQ,KAAK,EAAS,EAAQ,QAAQ,EAAG,IAAM,EAAI,EAAG,EAAE,CAAC,EAElD,CACT,CAGA,IAAM,EAAU,MAAM,KAAK,CAAE,OAAQ,EAAa,OAAS,CAAE,GAAI,EAAG,IAClE,KAAK,MAAO,EAAS,EAAa,GAAM,CAAU,CACpD,EAIA,OAFA,EAAQ,KAAK,EAAS,EAAQ,QAAQ,EAAG,IAAM,EAAI,EAAG,CAAC,CAAC,EAEjD,CACT"}

package/dist/math/allocate.d.ts

@@ -22,7 +22,7 @@
  * @param amount - Total amount to allocate
  * @param ratios - Array of ratios for distribution or number of equal parts
  * @returns Array of allocated amounts with remainder applied to last bucket (sum equals original amount)
- * @throws {ArsenalValidationError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer
+ * @throws {RangeError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer.
  */
 export declare function allocate(amount: number, ratios: number[] | number): number[];
 export declare function allocate(amount: bigint, ratios: number[] | number): bigint[];

package/dist/math/allocate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"allocate.d.ts","sourceRoot":"","sources":["../../src/math/allocate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC"}
+{"version":3,"file":"allocate.d.ts","sourceRoot":"","sources":["../../src/math/allocate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC"}

package/dist/math/allocate.js

@@ -1,20 +1,19 @@
-import { ArsenalValidationError as e } from "../errors.js";
 //#region src/math/allocate.ts
-function t(t, n) {
-	if (typeof n == "number" && (!Number.isInteger(n) || n < 1)) throw new e(`Parts must be a positive integer, got ${n}`);
-	let r = Array.isArray(n) ? n : Array(n).fill(1);
-	if (r.length === 0) throw new e("Ratios array cannot be empty");
-	if (r.some((e) => e < 0)) throw new e("Ratios must be non-negative");
-	let i = r.reduce((e, t) => e + t, 0);
-	if (i === 0) throw new e("Total ratio cannot be zero");
-	if (typeof t == "bigint") {
-		let e = BigInt(i), n = Array.from({ length: r.length - 1 }, (n, i) => t * BigInt(r[i]) / e);
-		return n.push(t - n.reduce((e, t) => e + t, 0n)), n;
+function e(e, t) {
+	if (typeof t == "number" && (!Number.isInteger(t) || t < 1)) throw RangeError(`allocate: parts must be a positive integer, got ${t}`);
+	let n = Array.isArray(t) ? t : Array(t).fill(1);
+	if (n.length === 0) throw RangeError("Ratios array cannot be empty");
+	if (n.some((e) => e < 0)) throw RangeError("Ratios must be non-negative");
+	let r = n.reduce((e, t) => e + t, 0);
+	if (r === 0) throw RangeError("Total ratio cannot be zero");
+	if (typeof e == "bigint") {
+		let t = BigInt(r), i = Array.from({ length: n.length - 1 }, (r, i) => e * BigInt(n[i]) / t);
+		return i.push(e - i.reduce((e, t) => e + t, 0n)), i;
 	}
-	let a = Array.from({ length: r.length - 1 }, (e, n) => Math.floor(t * r[n] / i));
-	return a.push(t - a.reduce((e, t) => e + t, 0)), a;
+	let i = Array.from({ length: n.length - 1 }, (t, i) => Math.floor(e * n[i] / r));
+	return i.push(e - i.reduce((e, t) => e + t, 0)), i;
 }
 //#endregion
-export { t as allocate };
+export { e as allocate };
 
 //# sourceMappingURL=allocate.js.map

package/dist/math/allocate.js.map

@@ -1 +1 @@
-{"version":3,"file":"allocate.js","names":[],"sources":["../../src/math/allocate.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\n * Distributes an amount proportionally according to given ratios.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * The indivisible remainder is allocated to the last bucket.\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 (total ratio = 6)\n * allocate(100, [1, 2, 3]);\n * // [16, 33, 51] - sum is exactly 100\n *\n * // Split $100 evenly among 3 parts\n * allocate(100, 3);\n * // [33, 33, 34] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3333n, 3333n, 3334n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution or number of equal parts\n * @returns Array of allocated amounts with remainder applied to last bucket (sum equals original amount)\n * @throws {ArsenalValidationError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer\n */\nexport function allocate(amount: number, ratios: number[] | number): number[];\nexport function allocate(amount: bigint, ratios: number[] | number): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[] | number): (number | bigint)[] {\n  // If second param is a number, validate and treat it as number of equal parts\n  if (typeof ratios === 'number') {\n    if (!Number.isInteger(ratios) || ratios < 1) {\n      throw new ArsenalValidationError(`Parts must be a positive integer, got ${ratios}`);\n    }\n  }\n\n  const actualRatios = Array.isArray(ratios) ? ratios : Array(ratios).fill(1);\n\n  if (actualRatios.length === 0) {\n    throw new ArsenalValidationError('Ratios array cannot be empty');\n  }\n\n  if (actualRatios.some((r) => r < 0)) {\n    throw new ArsenalValidationError('Ratios must be non-negative');\n  }\n\n  const totalRatio = actualRatios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new ArsenalValidationError('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const totalRatioBigInt = BigInt(totalRatio);\n    const results = Array.from(\n      { length: actualRatios.length - 1 },\n      (_, i) => (amount * BigInt(actualRatios[i])) / totalRatioBigInt,\n    );\n\n    results.push(amount - results.reduce((s, v) => s + v, 0n));\n\n    return results;\n  }\n\n  // For number type, use proportional allocation for all ratios uniformly\n  const results = Array.from({ length: actualRatios.length - 1 }, (_, i) =>\n    Math.floor((amount * actualRatios[i]) / totalRatio),\n  );\n\n  results.push(amount - results.reduce((s, v) => s + v, 0));\n\n  return results;\n}\n"],"mappings":";;AA8BA,SAAgB,EAAS,GAAyB,GAAgD;CAEhG,IAAI,OAAO,KAAW,aAChB,CAAC,OAAO,UAAU,CAAM,KAAK,IAAS,IACxC,MAAM,IAAI,EAAuB,yCAAyC,GAAQ;CAItF,IAAM,IAAe,MAAM,QAAQ,CAAM,IAAI,IAAS,MAAM,CAAM,CAAC,CAAC,KAAK,CAAC;CAE1E,IAAI,EAAa,WAAW,GAC1B,MAAM,IAAI,EAAuB,8BAA8B;CAGjE,IAAI,EAAa,MAAM,MAAM,IAAI,CAAC,GAChC,MAAM,IAAI,EAAuB,6BAA6B;CAGhE,IAAM,IAAa,EAAa,QAAQ,GAAK,MAAU,IAAM,GAAO,CAAC;CAErE,IAAI,MAAe,GACjB,MAAM,IAAI,EAAuB,4BAA4B;CAG/D,IAAI,OAAO,KAAW,UAAU;EAC9B,IAAM,IAAmB,OAAO,CAAU,GACpC,IAAU,MAAM,KACpB,EAAE,QAAQ,EAAa,SAAS,EAAE,IACjC,GAAG,MAAO,IAAS,OAAO,EAAa,EAAE,IAAK,CACjD;EAIA,OAFA,EAAQ,KAAK,IAAS,EAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,EAAE,CAAC,GAElD;CACT;CAGA,IAAM,IAAU,MAAM,KAAK,EAAE,QAAQ,EAAa,SAAS,EAAE,IAAI,GAAG,MAClE,KAAK,MAAO,IAAS,EAAa,KAAM,CAAU,CACpD;CAIA,OAFA,EAAQ,KAAK,IAAS,EAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,CAAC,GAEjD;AACT"}
+{"version":3,"file":"allocate.js","names":[],"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 * The indivisible remainder is allocated to the last bucket.\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 (total ratio = 6)\n * allocate(100, [1, 2, 3]);\n * // [16, 33, 51] - sum is exactly 100\n *\n * // Split $100 evenly among 3 parts\n * allocate(100, 3);\n * // [33, 33, 34] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3333n, 3333n, 3334n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution or number of equal parts\n * @returns Array of allocated amounts with remainder applied to last bucket (sum equals original amount)\n * @throws {RangeError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer.\n */\nexport function allocate(amount: number, ratios: number[] | number): number[];\nexport function allocate(amount: bigint, ratios: number[] | number): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[] | number): (number | bigint)[] {\n  // If second param is a number, validate and treat it as number of equal parts\n  if (typeof ratios === 'number') {\n    if (!Number.isInteger(ratios) || ratios < 1) {\n      throw new RangeError(`allocate: parts must be a positive integer, got ${ratios}`);\n    }\n  }\n\n  const actualRatios = Array.isArray(ratios) ? ratios : Array(ratios).fill(1);\n\n  if (actualRatios.length === 0) {\n    throw new RangeError('Ratios array cannot be empty');\n  }\n\n  if (actualRatios.some((r) => r < 0)) {\n    throw new RangeError('Ratios must be non-negative');\n  }\n\n  const totalRatio = actualRatios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new RangeError('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const totalRatioBigInt = BigInt(totalRatio);\n    const results = Array.from(\n      { length: actualRatios.length - 1 },\n      (_, i) => (amount * BigInt(actualRatios[i])) / totalRatioBigInt,\n    );\n\n    results.push(amount - results.reduce((s, v) => s + v, 0n));\n\n    return results;\n  }\n\n  // For number type, use proportional allocation for all ratios uniformly\n  const results = Array.from({ length: actualRatios.length - 1 }, (_, i) =>\n    Math.floor((amount * actualRatios[i]) / totalRatio),\n  );\n\n  results.push(amount - results.reduce((s, v) => s + v, 0));\n\n  return results;\n}\n"],"mappings":";AA4BA,SAAgB,EAAS,GAAyB,GAAgD;CAEhG,IAAI,OAAO,KAAW,aAChB,CAAC,OAAO,UAAU,CAAM,KAAK,IAAS,IACxC,MAAU,WAAW,mDAAmD,GAAQ;CAIpF,IAAM,IAAe,MAAM,QAAQ,CAAM,IAAI,IAAS,MAAM,CAAM,CAAC,CAAC,KAAK,CAAC;CAE1E,IAAI,EAAa,WAAW,GAC1B,MAAU,WAAW,8BAA8B;CAGrD,IAAI,EAAa,MAAM,MAAM,IAAI,CAAC,GAChC,MAAU,WAAW,6BAA6B;CAGpD,IAAM,IAAa,EAAa,QAAQ,GAAK,MAAU,IAAM,GAAO,CAAC;CAErE,IAAI,MAAe,GACjB,MAAU,WAAW,4BAA4B;CAGnD,IAAI,OAAO,KAAW,UAAU;EAC9B,IAAM,IAAmB,OAAO,CAAU,GACpC,IAAU,MAAM,KACpB,EAAE,QAAQ,EAAa,SAAS,EAAE,IACjC,GAAG,MAAO,IAAS,OAAO,EAAa,EAAE,IAAK,CACjD;EAIA,OAFA,EAAQ,KAAK,IAAS,EAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,EAAE,CAAC,GAElD;CACT;CAGA,IAAM,IAAU,MAAM,KAAK,EAAE,QAAQ,EAAa,SAAS,EAAE,IAAI,GAAG,MAClE,KAAK,MAAO,IAAS,EAAa,KAAM,CAAU,CACpD;CAIA,OAFA,EAAQ,KAAK,IAAS,EAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,CAAC,GAEjD;AACT"}

package/dist/math/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./clamp.cjs"),t=require("./range.cjs"),n=require("./allocate.cjs"),r=require("./sum.cjs"),i=require("./average.cjs"),a=require("./gcd.cjs"),o=require("./lcm.cjs"),s=require("./lerp.cjs"),c=require("./linspace.cjs"),l=require("./median.cjs"),u=require("./mod.cjs"),d=require("./normalize.cjs"),f=require("./percent.cjs"),p=require("./round.cjs"),m=require("./variance.cjs"),h=require("./standardDeviation.cjs");exports.allocate=n.allocate,exports.average=i.average,exports.clamp=e.clamp,exports.gcd=a.gcd,exports.lcm=o.lcm,exports.lerp=s.lerp,exports.linspace=c.linspace,exports.median=l.median,exports.mod=u.mod,exports.normalize=d.normalize,exports.percent=f.percent,exports.range=t.range,exports.round=p.round,exports.standardDeviation=h.standardDeviation,exports.sum=r.sum,exports.variance=m.variance;

package/dist/math/index.d.ts

@@ -1,4 +1,3 @@
-export * from './abs';
 export * from './allocate';
 export * from './average';
 export * from './clamp';
@@ -6,9 +5,7 @@ export * from './gcd';
 export * from './lcm';
 export * from './lerp';
 export * from './linspace';
-export * from './max';
 export * from './median';
-export * from './min';
 export * from './mod';
 export * from './normalize';
 export * from './percent';

package/dist/math/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC"}

package/dist/math/index.js

@@ -0,0 +1,17 @@
+import { clamp as e } from "./clamp.js";
+import { range as t } from "./range.js";
+import { allocate as n } from "./allocate.js";
+import { sum as r } from "./sum.js";
+import { average as i } from "./average.js";
+import { gcd as a } from "./gcd.js";
+import { lcm as o } from "./lcm.js";
+import { lerp as s } from "./lerp.js";
+import { linspace as c } from "./linspace.js";
+import { median as l } from "./median.js";
+import { mod as u } from "./mod.js";
+import { normalize as d } from "./normalize.js";
+import { percent as f } from "./percent.js";
+import { round as p } from "./round.js";
+import { variance as m } from "./variance.js";
+import { standardDeviation as h } from "./standardDeviation.js";
+export { n as allocate, i as average, e as clamp, a as gcd, o as lcm, s as lerp, c as linspace, l as median, u as mod, d as normalize, f as percent, t as range, p as round, h as standardDeviation, r as sum, m as variance };

package/dist/math/mod.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs");function t(t,n){if(n===0)throw new e.ArsenalValidationError(`mod: divisor cannot be 0`);return(t%n+n)%n}exports.mod=t;
+function e(e,t){if(t===0)throw RangeError(`mod: divisor cannot be 0`);return(e%t+t)%t}exports.mod=e;
 //# sourceMappingURL=mod.cjs.map

package/dist/math/mod.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mod.cjs","names":[],"sources":["../../src/math/mod.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\n * Sign-correct modulo — unlike the native `%` operator, the result always has the same sign\n * as the divisor `b` (e.g. `mod(-1, 4)` is `3`, not `-1`).\n *\n * @example\n * ```ts\n * mod(-1, 4); // 3\n * mod(5, 3); // 2\n * ```\n *\n * @param a - The dividend.\n * @param b - The divisor. Must not be `0`.\n * @returns The sign-correct modulo of `a` by `b`.\n *\n * @throws {ArsenalValidationError} If `b` is `0`.\n */\nexport function mod(a: number, b: number): number {\n  if (b === 0) throw new ArsenalValidationError('mod: divisor cannot be 0');\n\n  return ((a % b) + b) % b;\n}\n"],"mappings":"iCAkBA,SAAgB,EAAI,EAAW,EAAmB,CAChD,GAAI,IAAM,EAAG,MAAM,IAAI,EAAA,uBAAuB,0BAA0B,EAExE,OAAS,EAAI,EAAK,GAAK,CACzB"}
+{"version":3,"file":"mod.cjs","names":[],"sources":["../../src/math/mod.ts"],"sourcesContent":["/**\n * Sign-correct modulo — unlike the native `%` operator, the result always has the same sign\n * as the divisor `b` (e.g. `mod(-1, 4)` is `3`, not `-1`).\n *\n * @example\n * ```ts\n * mod(-1, 4); // 3\n * mod(5, 3); // 2\n * ```\n *\n * @param a - The dividend.\n * @param b - The divisor. Must not be `0`.\n * @returns The sign-correct modulo of `a` by `b`.\n *\n * @throws {RangeError} If `b` is `0`.\n */\nexport function mod(a: number, b: number): number {\n  if (b === 0) throw new RangeError('mod: divisor cannot be 0');\n\n  return ((a % b) + b) % b;\n}\n"],"mappings":"AAgBA,SAAgB,EAAI,EAAW,EAAmB,CAChD,GAAI,IAAM,EAAG,MAAU,WAAW,0BAA0B,EAE5D,OAAS,EAAI,EAAK,GAAK,CACzB"}

package/dist/math/mod.d.ts

@@ -12,7 +12,7 @@
  * @param b - The divisor. Must not be `0`.
  * @returns The sign-correct modulo of `a` by `b`.
  *
- * @throws {ArsenalValidationError} If `b` is `0`.
+ * @throws {RangeError} If `b` is `0`.
  */
 export declare function mod(a: number, b: number): number;
 //# sourceMappingURL=mod.d.ts.map

package/dist/math/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/math/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhD"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/math/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhD"}

package/dist/math/mod.js

@@ -1,10 +1,9 @@
-import { ArsenalValidationError as e } from "../errors.js";
 //#region src/math/mod.ts
-function t(t, n) {
-	if (n === 0) throw new e("mod: divisor cannot be 0");
-	return (t % n + n) % n;
+function e(e, t) {
+	if (t === 0) throw RangeError("mod: divisor cannot be 0");
+	return (e % t + t) % t;
 }
 //#endregion
-export { t as mod };
+export { e as mod };
 
 //# sourceMappingURL=mod.js.map

package/dist/math/mod.js.map

@@ -1 +1 @@
-{"version":3,"file":"mod.js","names":[],"sources":["../../src/math/mod.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\n * Sign-correct modulo — unlike the native `%` operator, the result always has the same sign\n * as the divisor `b` (e.g. `mod(-1, 4)` is `3`, not `-1`).\n *\n * @example\n * ```ts\n * mod(-1, 4); // 3\n * mod(5, 3); // 2\n * ```\n *\n * @param a - The dividend.\n * @param b - The divisor. Must not be `0`.\n * @returns The sign-correct modulo of `a` by `b`.\n *\n * @throws {ArsenalValidationError} If `b` is `0`.\n */\nexport function mod(a: number, b: number): number {\n  if (b === 0) throw new ArsenalValidationError('mod: divisor cannot be 0');\n\n  return ((a % b) + b) % b;\n}\n"],"mappings":";;AAkBA,SAAgB,EAAI,GAAW,GAAmB;CAChD,IAAI,MAAM,GAAG,MAAM,IAAI,EAAuB,0BAA0B;CAExE,QAAS,IAAI,IAAK,KAAK;AACzB"}
+{"version":3,"file":"mod.js","names":[],"sources":["../../src/math/mod.ts"],"sourcesContent":["/**\n * Sign-correct modulo — unlike the native `%` operator, the result always has the same sign\n * as the divisor `b` (e.g. `mod(-1, 4)` is `3`, not `-1`).\n *\n * @example\n * ```ts\n * mod(-1, 4); // 3\n * mod(5, 3); // 2\n * ```\n *\n * @param a - The dividend.\n * @param b - The divisor. Must not be `0`.\n * @returns The sign-correct modulo of `a` by `b`.\n *\n * @throws {RangeError} If `b` is `0`.\n */\nexport function mod(a: number, b: number): number {\n  if (b === 0) throw new RangeError('mod: divisor cannot be 0');\n\n  return ((a % b) + b) % b;\n}\n"],"mappings":";AAgBA,SAAgB,EAAI,GAAW,GAAmB;CAChD,IAAI,MAAM,GAAG,MAAU,WAAW,0BAA0B;CAE5D,QAAS,IAAI,IAAK,KAAK;AACzB"}

package/dist/math/range.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs");function t(t,n,r){let[i,a,o]=n===void 0?[0,t,1]:r===void 0?[t,n,1]:[t,n,r];if(!Number.isFinite(i)||!Number.isFinite(a)||!Number.isFinite(o))throw new e.ArsenalValidationError(`range: start, stop, and step must be finite numbers`);if(o===0)throw new e.ArsenalValidationError(`range: step cannot be 0`);if(i===a)return[];let s=(a-i)/o,c=Math.max(0,Number.isInteger(s)?s:Math.ceil(s+2**-52));if(c>1e7)throw new e.ArsenalValidationError(`range: exceeds maximum allowed size of 10,000,000`);return Array.from({length:c},(e,t)=>i+t*o)}exports.range=t;
+function e(e,t,n){let[r,i,a]=t===void 0?[0,e,1]:n===void 0?[e,t,1]:[e,t,n];if(!Number.isFinite(r)||!Number.isFinite(i)||!Number.isFinite(a))throw RangeError(`range: start, stop, and step must be finite numbers`);if(a===0)throw RangeError(`range: step cannot be 0`);if(r===i)return[];let o=(i-r)/a,s=Math.max(0,Number.isInteger(o)?o:Math.ceil(o+2**-52));if(s>1e7)throw RangeError(`range: exceeds maximum allowed size of 10,000,000`);return Array.from({length:s},(e,t)=>r+t*a)}exports.range=e;
 //# sourceMappingURL=range.cjs.map

package/dist/math/range.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"range.cjs","names":[],"sources":["../../src/math/range.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\n * Creates an array of numbers from `0` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(5) // [0, 1, 2, 3, 4]\n * ```\n */\nexport function range(stop: number): number[];\n/**\n * Creates an array of numbers from `start` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(2, 6) // [2, 3, 4, 5]\n * ```\n */\nexport function range(start: number, stop: number): number[];\n/**\n * Creates an array of numbers progressing from `start` up to, but not including, `stop` with a given `step`.\n *\n * @example\n * ```ts\n * range(0, 10, 2) // [0, 2, 4, 6, 8]\n * range(10, 0, -2) // [10, 8, 6, 4, 2]\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range (exclusive).\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {ArsenalValidationError} If start, stop, or step are not finite numbers, step is 0, or range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number): number[];\nexport function range(startOrStop: number, stop?: number, step?: number): number[] {\n  const [resolvedStart, resolvedStop, resolvedStep] =\n    stop === undefined ? [0, startOrStop, 1] : step === undefined ? [startOrStop, stop, 1] : [startOrStop, stop, step];\n\n  if (!Number.isFinite(resolvedStart) || !Number.isFinite(resolvedStop) || !Number.isFinite(resolvedStep)) {\n    throw new ArsenalValidationError('range: start, stop, and step must be finite numbers');\n  }\n\n  if (resolvedStep === 0) throw new ArsenalValidationError('range: step cannot be 0');\n\n  if (resolvedStart === resolvedStop) {\n    return [];\n  }\n\n  const raw = (resolvedStop - resolvedStart) / resolvedStep;\n  const length = Math.max(0, Number.isInteger(raw) ? raw : Math.ceil(raw + Number.EPSILON));\n\n  if (length > 10_000_000) throw new ArsenalValidationError('range: exceeds maximum allowed size of 10,000,000');\n\n  return Array.from({ length }, (_, i) => resolvedStart + i * resolvedStep);\n}\n"],"mappings":"iCAsCA,SAAgB,EAAM,EAAqB,EAAe,EAAyB,CACjF,GAAM,CAAC,EAAe,EAAc,GAClC,IAAS,IAAA,GAAY,CAAC,EAAG,EAAa,CAAC,EAAI,IAAS,IAAA,GAAY,CAAC,EAAa,EAAM,CAAC,EAAI,CAAC,EAAa,EAAM,CAAI,EAEnH,GAAI,CAAC,OAAO,SAAS,CAAa,GAAK,CAAC,OAAO,SAAS,CAAY,GAAK,CAAC,OAAO,SAAS,CAAY,EACpG,MAAM,IAAI,EAAA,uBAAuB,qDAAqD,EAGxF,GAAI,IAAiB,EAAG,MAAM,IAAI,EAAA,uBAAuB,yBAAyB,EAElF,GAAI,IAAkB,EACpB,MAAO,CAAC,EAGV,IAAM,GAAO,EAAe,GAAiB,EACvC,EAAS,KAAK,IAAI,EAAG,OAAO,UAAU,CAAG,EAAI,EAAM,KAAK,KAAK,QAAoB,CAAC,EAExF,GAAI,EAAS,IAAY,MAAM,IAAI,EAAA,uBAAuB,mDAAmD,EAE7G,OAAO,MAAM,KAAK,CAAE,QAAO,GAAI,EAAG,IAAM,EAAgB,EAAI,CAAY,CAC1E"}
+{"version":3,"file":"range.cjs","names":[],"sources":["../../src/math/range.ts"],"sourcesContent":["/**\n * Creates an array of numbers from `0` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(5) // [0, 1, 2, 3, 4]\n * ```\n */\nexport function range(stop: number): number[];\n/**\n * Creates an array of numbers from `start` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(2, 6) // [2, 3, 4, 5]\n * ```\n */\nexport function range(start: number, stop: number): number[];\n/**\n * Creates an array of numbers progressing from `start` up to, but not including, `stop` with a given `step`.\n *\n * @example\n * ```ts\n * range(0, 10, 2) // [0, 2, 4, 6, 8]\n * range(10, 0, -2) // [10, 8, 6, 4, 2]\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range (exclusive).\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {RangeError} If start, stop, or step are not finite numbers, step is 0, or range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number): number[];\nexport function range(startOrStop: number, stop?: number, step?: number): number[] {\n  const [resolvedStart, resolvedStop, resolvedStep] =\n    stop === undefined ? [0, startOrStop, 1] : step === undefined ? [startOrStop, stop, 1] : [startOrStop, stop, step];\n\n  if (!Number.isFinite(resolvedStart) || !Number.isFinite(resolvedStop) || !Number.isFinite(resolvedStep)) {\n    throw new RangeError('range: start, stop, and step must be finite numbers');\n  }\n\n  if (resolvedStep === 0) throw new RangeError('range: step cannot be 0');\n\n  if (resolvedStart === resolvedStop) {\n    return [];\n  }\n\n  const raw = (resolvedStop - resolvedStart) / resolvedStep;\n  const length = Math.max(0, Number.isInteger(raw) ? raw : Math.ceil(raw + Number.EPSILON));\n\n  if (length > 10_000_000) throw new RangeError('range: exceeds maximum allowed size of 10,000,000');\n\n  return Array.from({ length }, (_, i) => resolvedStart + i * resolvedStep);\n}\n"],"mappings":"AAoCA,SAAgB,EAAM,EAAqB,EAAe,EAAyB,CACjF,GAAM,CAAC,EAAe,EAAc,GAClC,IAAS,IAAA,GAAY,CAAC,EAAG,EAAa,CAAC,EAAI,IAAS,IAAA,GAAY,CAAC,EAAa,EAAM,CAAC,EAAI,CAAC,EAAa,EAAM,CAAI,EAEnH,GAAI,CAAC,OAAO,SAAS,CAAa,GAAK,CAAC,OAAO,SAAS,CAAY,GAAK,CAAC,OAAO,SAAS,CAAY,EACpG,MAAU,WAAW,qDAAqD,EAG5E,GAAI,IAAiB,EAAG,MAAU,WAAW,yBAAyB,EAEtE,GAAI,IAAkB,EACpB,MAAO,CAAC,EAGV,IAAM,GAAO,EAAe,GAAiB,EACvC,EAAS,KAAK,IAAI,EAAG,OAAO,UAAU,CAAG,EAAI,EAAM,KAAK,KAAK,QAAoB,CAAC,EAExF,GAAI,EAAS,IAAY,MAAU,WAAW,mDAAmD,EAEjG,OAAO,MAAM,KAAK,CAAE,QAAO,GAAI,EAAG,IAAM,EAAgB,EAAI,CAAY,CAC1E"}

package/dist/math/range.d.ts

@@ -31,7 +31,7 @@ export declare function range(start: number, stop: number): number[];
  *
  * @returns The range of numbers.
  *
- * @throws {ArsenalValidationError} If start, stop, or step are not finite numbers, step is 0, or range exceeds maximum size.
+ * @throws {RangeError} If start, stop, or step are not finite numbers, step is 0, or range exceeds maximum size.
  */
 export declare function range(start: number, stop: number, step: number): number[];
 //# sourceMappingURL=range.d.ts.map

package/dist/math/range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/math/range.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9C;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC7D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC"}
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/math/range.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9C;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC7D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC"}

package/dist/math/range.js

@@ -1,27 +1,26 @@
-import { ArsenalValidationError as e } from "../errors.js";
 //#region src/math/range.ts
-function t(t, n, r) {
-	let [i, a, o] = n === void 0 ? [
+function e(e, t, n) {
+	let [r, i, a] = t === void 0 ? [
 		0,
-		t,
+		e,
 		1
-	] : r === void 0 ? [
+	] : n === void 0 ? [
+		e,
 		t,
-		n,
 		1
 	] : [
+		e,
 		t,
-		n,
-		r
+		n
 	];
-	if (!Number.isFinite(i) || !Number.isFinite(a) || !Number.isFinite(o)) throw new e("range: start, stop, and step must be finite numbers");
-	if (o === 0) throw new e("range: step cannot be 0");
-	if (i === a) return [];
-	let s = (a - i) / o, c = Math.max(0, Number.isInteger(s) ? s : Math.ceil(s + 2 ** -52));
-	if (c > 1e7) throw new e("range: exceeds maximum allowed size of 10,000,000");
-	return Array.from({ length: c }, (e, t) => i + t * o);
+	if (!Number.isFinite(r) || !Number.isFinite(i) || !Number.isFinite(a)) throw RangeError("range: start, stop, and step must be finite numbers");
+	if (a === 0) throw RangeError("range: step cannot be 0");
+	if (r === i) return [];
+	let o = (i - r) / a, s = Math.max(0, Number.isInteger(o) ? o : Math.ceil(o + 2 ** -52));
+	if (s > 1e7) throw RangeError("range: exceeds maximum allowed size of 10,000,000");
+	return Array.from({ length: s }, (e, t) => r + t * a);
 }
 //#endregion
-export { t as range };
+export { e as range };
 
 //# sourceMappingURL=range.js.map

package/dist/math/range.js.map

@@ -1 +1 @@
-{"version":3,"file":"range.js","names":[],"sources":["../../src/math/range.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\n * Creates an array of numbers from `0` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(5) // [0, 1, 2, 3, 4]\n * ```\n */\nexport function range(stop: number): number[];\n/**\n * Creates an array of numbers from `start` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(2, 6) // [2, 3, 4, 5]\n * ```\n */\nexport function range(start: number, stop: number): number[];\n/**\n * Creates an array of numbers progressing from `start` up to, but not including, `stop` with a given `step`.\n *\n * @example\n * ```ts\n * range(0, 10, 2) // [0, 2, 4, 6, 8]\n * range(10, 0, -2) // [10, 8, 6, 4, 2]\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range (exclusive).\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {ArsenalValidationError} If start, stop, or step are not finite numbers, step is 0, or range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number): number[];\nexport function range(startOrStop: number, stop?: number, step?: number): number[] {\n  const [resolvedStart, resolvedStop, resolvedStep] =\n    stop === undefined ? [0, startOrStop, 1] : step === undefined ? [startOrStop, stop, 1] : [startOrStop, stop, step];\n\n  if (!Number.isFinite(resolvedStart) || !Number.isFinite(resolvedStop) || !Number.isFinite(resolvedStep)) {\n    throw new ArsenalValidationError('range: start, stop, and step must be finite numbers');\n  }\n\n  if (resolvedStep === 0) throw new ArsenalValidationError('range: step cannot be 0');\n\n  if (resolvedStart === resolvedStop) {\n    return [];\n  }\n\n  const raw = (resolvedStop - resolvedStart) / resolvedStep;\n  const length = Math.max(0, Number.isInteger(raw) ? raw : Math.ceil(raw + Number.EPSILON));\n\n  if (length > 10_000_000) throw new ArsenalValidationError('range: exceeds maximum allowed size of 10,000,000');\n\n  return Array.from({ length }, (_, i) => resolvedStart + i * resolvedStep);\n}\n"],"mappings":";;AAsCA,SAAgB,EAAM,GAAqB,GAAe,GAAyB;CACjF,IAAM,CAAC,GAAe,GAAc,KAClC,MAAS,KAAA,IAAY;EAAC;EAAG;EAAa;CAAC,IAAI,MAAS,KAAA,IAAY;EAAC;EAAa;EAAM;CAAC,IAAI;EAAC;EAAa;EAAM;CAAI;CAEnH,IAAI,CAAC,OAAO,SAAS,CAAa,KAAK,CAAC,OAAO,SAAS,CAAY,KAAK,CAAC,OAAO,SAAS,CAAY,GACpG,MAAM,IAAI,EAAuB,qDAAqD;CAGxF,IAAI,MAAiB,GAAG,MAAM,IAAI,EAAuB,yBAAyB;CAElF,IAAI,MAAkB,GACpB,OAAO,CAAC;CAGV,IAAM,KAAO,IAAe,KAAiB,GACvC,IAAS,KAAK,IAAI,GAAG,OAAO,UAAU,CAAG,IAAI,IAAM,KAAK,KAAK,YAAoB,CAAC;CAExF,IAAI,IAAS,KAAY,MAAM,IAAI,EAAuB,mDAAmD;CAE7G,OAAO,MAAM,KAAK,EAAE,UAAO,IAAI,GAAG,MAAM,IAAgB,IAAI,CAAY;AAC1E"}
+{"version":3,"file":"range.js","names":[],"sources":["../../src/math/range.ts"],"sourcesContent":["/**\n * Creates an array of numbers from `0` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(5) // [0, 1, 2, 3, 4]\n * ```\n */\nexport function range(stop: number): number[];\n/**\n * Creates an array of numbers from `start` up to, but not including, `stop` with step `1`.\n *\n * @example\n * ```ts\n * range(2, 6) // [2, 3, 4, 5]\n * ```\n */\nexport function range(start: number, stop: number): number[];\n/**\n * Creates an array of numbers progressing from `start` up to, but not including, `stop` with a given `step`.\n *\n * @example\n * ```ts\n * range(0, 10, 2) // [0, 2, 4, 6, 8]\n * range(10, 0, -2) // [10, 8, 6, 4, 2]\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range (exclusive).\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {RangeError} If start, stop, or step are not finite numbers, step is 0, or range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number): number[];\nexport function range(startOrStop: number, stop?: number, step?: number): number[] {\n  const [resolvedStart, resolvedStop, resolvedStep] =\n    stop === undefined ? [0, startOrStop, 1] : step === undefined ? [startOrStop, stop, 1] : [startOrStop, stop, step];\n\n  if (!Number.isFinite(resolvedStart) || !Number.isFinite(resolvedStop) || !Number.isFinite(resolvedStep)) {\n    throw new RangeError('range: start, stop, and step must be finite numbers');\n  }\n\n  if (resolvedStep === 0) throw new RangeError('range: step cannot be 0');\n\n  if (resolvedStart === resolvedStop) {\n    return [];\n  }\n\n  const raw = (resolvedStop - resolvedStart) / resolvedStep;\n  const length = Math.max(0, Number.isInteger(raw) ? raw : Math.ceil(raw + Number.EPSILON));\n\n  if (length > 10_000_000) throw new RangeError('range: exceeds maximum allowed size of 10,000,000');\n\n  return Array.from({ length }, (_, i) => resolvedStart + i * resolvedStep);\n}\n"],"mappings":";AAoCA,SAAgB,EAAM,GAAqB,GAAe,GAAyB;CACjF,IAAM,CAAC,GAAe,GAAc,KAClC,MAAS,KAAA,IAAY;EAAC;EAAG;EAAa;CAAC,IAAI,MAAS,KAAA,IAAY;EAAC;EAAa;EAAM;CAAC,IAAI;EAAC;EAAa;EAAM;CAAI;CAEnH,IAAI,CAAC,OAAO,SAAS,CAAa,KAAK,CAAC,OAAO,SAAS,CAAY,KAAK,CAAC,OAAO,SAAS,CAAY,GACpG,MAAU,WAAW,qDAAqD;CAG5E,IAAI,MAAiB,GAAG,MAAU,WAAW,yBAAyB;CAEtE,IAAI,MAAkB,GACpB,OAAO,CAAC;CAGV,IAAM,KAAO,IAAe,KAAiB,GACvC,IAAS,KAAK,IAAI,GAAG,OAAO,UAAU,CAAG,IAAI,IAAM,KAAK,KAAK,YAAoB,CAAC;CAExF,IAAI,IAAS,KAAY,MAAU,WAAW,mDAAmD;CAEjG,OAAO,MAAM,KAAK,EAAE,UAAO,IAAI,GAAG,MAAM,IAAgB,IAAI,CAAY;AAC1E"}

package/dist/math/sum.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs");function t(t,n){return t.length===0?0:t.reduce((t,r)=>{let i=n?n(r):r;if(typeof i!=`number`||Number.isNaN(i))throw new e.ArsenalValidationError(`sum: encountered a non-numeric value; provide a callback to map non-number items`);return t+i},0)}exports.sum=t;
+function e(e,t){return e.length===0?0:e.reduce((e,n)=>{let r=t?t(n):n;if(typeof r!=`number`||Number.isNaN(r))throw TypeError(`sum: encountered a non-numeric value; provide a callback to map non-number items`);return e+r},0)}exports.sum=e;
 //# sourceMappingURL=sum.cjs.map