@vielzeug/arsenal 3.0.0 → 26.10.0

package/dist/math/gcd.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"gcd.cjs","names":[],"sources":["../../src/math/gcd.ts"],"sourcesContent":["/**\n * Computes the greatest common divisor of two integers using the Euclidean algorithm.\n * The sign of the inputs is ignored — the result is always non-negative.\n *\n * @example\n * ```ts\n * gcd(12, 18); // 6\n * gcd(-12, 18); // 6\n * gcd(0, 5); // 5\n * gcd(0, 0); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The greatest common divisor of `a` and `b`.\n */\nexport function gcd(a: number, b: number): number {\n  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b)) {\n    throw new RangeError('gcd: inputs must be safe integers');\n  }\n\n  let x = Math.abs(a);\n  let y = Math.abs(b);\n\n  while (y !== 0) {\n    const temp = y;\n\n    y = x % y;\n    x = temp;\n  }\n\n  return x;\n}\n"],"mappings":"AAgBA,SAAgB,EAAI,EAAW,EAAmB,CAChD,GAAI,CAAC,OAAO,cAAc,CAAC,GAAK,CAAC,OAAO,cAAc,CAAC,EACrD,MAAU,WAAW,mCAAmC,EAG1D,IAAI,EAAI,KAAK,IAAI,CAAC,EACd,EAAI,KAAK,IAAI,CAAC,EAElB,KAAO,IAAM,GAAG,CACd,IAAM,EAAO,EAEb,EAAI,EAAI,EACR,EAAI,CACN,CAEA,OAAO,CACT"}
+{"version":3,"file":"gcd.cjs","names":[],"sources":["../../src/math/gcd.ts"],"sourcesContent":["/**\n * Computes the greatest common divisor of two integers using the Euclidean algorithm.\n * The sign of the inputs is ignored — the result is always non-negative.\n *\n * @example\n * ```ts\n * gcd(12, 18); // 6\n * gcd(-12, 18); // 6\n * gcd(0, 5); // 5\n * gcd(0, 0); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The greatest common divisor of `a` and `b`.\n */\nexport function gcd(a: number, b: number): number {\n  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b)) {\n    throw new RangeError('gcd: inputs must be safe integers');\n  }\n\n  let x = Math.abs(a);\n  let y = Math.abs(b);\n\n  while (y !== 0) {\n    const temp = y;\n\n    y = x % y;\n    x = temp;\n  }\n\n  return x;\n}\n"],"mappings":"AAgBA,SAAgB,IAAI,EAAW,EAAmB,CAChD,GAAI,CAAC,OAAO,cAAc,CAAC,GAAK,CAAC,OAAO,cAAc,CAAC,EACrD,MAAU,WAAW,mCAAmC,EAG1D,IAAI,EAAI,KAAK,IAAI,CAAC,EACd,EAAI,KAAK,IAAI,CAAC,EAElB,KAAO,IAAM,GAAG,CACd,IAAM,EAAO,EAEb,EAAI,EAAI,EACR,EAAI,CACN,CAEA,OAAO,CACT"}

package/dist/math/gcd.js

@@ -1,14 +1,2 @@
-//#region src/math/gcd.ts
-function e(e, t) {
-	if (!Number.isSafeInteger(e) || !Number.isSafeInteger(t)) throw RangeError("gcd: inputs must be safe integers");
-	let n = Math.abs(e), r = Math.abs(t);
-	for (; r !== 0;) {
-		let e = r;
-		r = n % r, n = e;
-	}
-	return n;
-}
-//#endregion
-export { e as gcd };
-
+function gcd(e,t){if(!Number.isSafeInteger(e)||!Number.isSafeInteger(t))throw RangeError(`gcd: inputs must be safe integers`);let n=Math.abs(e),r=Math.abs(t);for(;r!==0;){let e=r;r=n%r,n=e}return n}export{gcd};
 //# sourceMappingURL=gcd.js.map

package/dist/math/gcd.js.map

@@ -1 +1 @@
-{"version":3,"file":"gcd.js","names":[],"sources":["../../src/math/gcd.ts"],"sourcesContent":["/**\n * Computes the greatest common divisor of two integers using the Euclidean algorithm.\n * The sign of the inputs is ignored — the result is always non-negative.\n *\n * @example\n * ```ts\n * gcd(12, 18); // 6\n * gcd(-12, 18); // 6\n * gcd(0, 5); // 5\n * gcd(0, 0); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The greatest common divisor of `a` and `b`.\n */\nexport function gcd(a: number, b: number): number {\n  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b)) {\n    throw new RangeError('gcd: inputs must be safe integers');\n  }\n\n  let x = Math.abs(a);\n  let y = Math.abs(b);\n\n  while (y !== 0) {\n    const temp = y;\n\n    y = x % y;\n    x = temp;\n  }\n\n  return x;\n}\n"],"mappings":";AAgBA,SAAgB,EAAI,GAAW,GAAmB;CAChD,IAAI,CAAC,OAAO,cAAc,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,GACrD,MAAU,WAAW,mCAAmC;CAG1D,IAAI,IAAI,KAAK,IAAI,CAAC,GACd,IAAI,KAAK,IAAI,CAAC;CAElB,OAAO,MAAM,IAAG;EACd,IAAM,IAAO;EAGb,AADA,IAAI,IAAI,GACR,IAAI;CACN;CAEA,OAAO;AACT"}
+{"version":3,"file":"gcd.js","names":[],"sources":["../../src/math/gcd.ts"],"sourcesContent":["/**\n * Computes the greatest common divisor of two integers using the Euclidean algorithm.\n * The sign of the inputs is ignored — the result is always non-negative.\n *\n * @example\n * ```ts\n * gcd(12, 18); // 6\n * gcd(-12, 18); // 6\n * gcd(0, 5); // 5\n * gcd(0, 0); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The greatest common divisor of `a` and `b`.\n */\nexport function gcd(a: number, b: number): number {\n  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b)) {\n    throw new RangeError('gcd: inputs must be safe integers');\n  }\n\n  let x = Math.abs(a);\n  let y = Math.abs(b);\n\n  while (y !== 0) {\n    const temp = y;\n\n    y = x % y;\n    x = temp;\n  }\n\n  return x;\n}\n"],"mappings":"AAgBA,SAAgB,IAAI,EAAW,EAAmB,CAChD,GAAI,CAAC,OAAO,cAAc,CAAC,GAAK,CAAC,OAAO,cAAc,CAAC,EACrD,MAAU,WAAW,mCAAmC,EAG1D,IAAI,EAAI,KAAK,IAAI,CAAC,EACd,EAAI,KAAK,IAAI,CAAC,EAElB,KAAO,IAAM,GAAG,CACd,IAAM,EAAO,EAEb,EAAI,EAAI,EACR,EAAI,CACN,CAEA,OAAO,CACT"}

package/dist/math/index.js

@@ -1,16 +1 @@
-import { allocate as e } from "./allocate.js";
-import { clamp as t } from "./clamp.js";
-import { range as n } from "./range.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 { round as f } from "./round.js";
-import { variance as p } from "./variance.js";
-import { standardDeviation as m } from "./standardDeviation.js";
-export { e as allocate, i as average, t as clamp, a as gcd, o as lcm, s as lerp, c as linspace, l as median, u as mod, d as normalize, n as range, f as round, m as standardDeviation, r as sum, p as variance };
+import{allocate as e}from"./allocate.js";import{clamp as t}from"./clamp.js";import{range as n}from"./range.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{round as f}from"./round.js";import{variance as p}from"./variance.js";import{standardDeviation as m}from"./standardDeviation.js";export{e as allocate,i as average,t as clamp,a as gcd,o as lcm,s as lerp,c as linspace,l as median,u as mod,d as normalize,n as range,f as round,m as standardDeviation,r as sum,p as variance};

package/dist/math/lcm.cjs

@@ -1,2 +1,2 @@
-const e=require("./gcd.cjs");function t(t,n){let r=e.gcd(t,n);if(r===0)return 0;let i=Math.abs(t/r*n);if(!Number.isSafeInteger(i))throw RangeError(`lcm: result exceeds the safe integer range`);return i}exports.lcm=t;
+const e=require("./gcd.cjs");function lcm(t,n){let r=e.gcd(t,n);if(r===0)return 0;let i=Math.abs(t/r*n);if(!Number.isSafeInteger(i))throw RangeError(`lcm: result exceeds the safe integer range`);return i}exports.lcm=lcm;
 //# sourceMappingURL=lcm.cjs.map

package/dist/math/lcm.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lcm.cjs","names":[],"sources":["../../src/math/lcm.ts"],"sourcesContent":["import { gcd } from './gcd';\n\n/**\n * Computes the least common multiple of two integers.\n *\n * @example\n * ```ts\n * lcm(4, 6); // 12\n * lcm(0, 5); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The least common multiple of `a` and `b`, or `0` if either is `0`.\n */\nexport function lcm(a: number, b: number): number {\n  const divisor = gcd(a, b);\n\n  if (divisor === 0) return 0;\n\n  const result = Math.abs((a / divisor) * b);\n\n  if (!Number.isSafeInteger(result)) throw new RangeError('lcm: result exceeds the safe integer range');\n\n  return result;\n}\n"],"mappings":"6BAeA,SAAgB,EAAI,EAAW,EAAmB,CAChD,IAAM,EAAU,EAAA,IAAI,EAAG,CAAC,EAExB,GAAI,IAAY,EAAG,MAAO,GAE1B,IAAM,EAAS,KAAK,IAAK,EAAI,EAAW,CAAC,EAEzC,GAAI,CAAC,OAAO,cAAc,CAAM,EAAG,MAAU,WAAW,4CAA4C,EAEpG,OAAO,CACT"}
+{"version":3,"file":"lcm.cjs","names":[],"sources":["../../src/math/lcm.ts"],"sourcesContent":["import { gcd } from './gcd';\n\n/**\n * Computes the least common multiple of two integers.\n *\n * @example\n * ```ts\n * lcm(4, 6); // 12\n * lcm(0, 5); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The least common multiple of `a` and `b`, or `0` if either is `0`.\n */\nexport function lcm(a: number, b: number): number {\n  const divisor = gcd(a, b);\n\n  if (divisor === 0) return 0;\n\n  const result = Math.abs((a / divisor) * b);\n\n  if (!Number.isSafeInteger(result)) throw new RangeError('lcm: result exceeds the safe integer range');\n\n  return result;\n}\n"],"mappings":"6BAeA,SAAgB,IAAI,EAAW,EAAmB,CAChD,IAAM,EAAU,EAAA,IAAI,EAAG,CAAC,EAExB,GAAI,IAAY,EAAG,MAAO,GAE1B,IAAM,EAAS,KAAK,IAAK,EAAI,EAAW,CAAC,EAEzC,GAAI,CAAC,OAAO,cAAc,CAAM,EAAG,MAAU,WAAW,4CAA4C,EAEpG,OAAO,CACT"}

package/dist/math/lcm.js

@@ -1,13 +1,2 @@
-import { gcd as e } from "./gcd.js";
-//#region src/math/lcm.ts
-function t(t, n) {
-	let r = e(t, n);
-	if (r === 0) return 0;
-	let i = Math.abs(t / r * n);
-	if (!Number.isSafeInteger(i)) throw RangeError("lcm: result exceeds the safe integer range");
-	return i;
-}
-//#endregion
-export { t as lcm };
-
+import{gcd as e}from"./gcd.js";function lcm(t,n){let r=e(t,n);if(r===0)return 0;let i=Math.abs(t/r*n);if(!Number.isSafeInteger(i))throw RangeError(`lcm: result exceeds the safe integer range`);return i}export{lcm};
 //# sourceMappingURL=lcm.js.map

package/dist/math/lcm.js.map

@@ -1 +1 @@
-{"version":3,"file":"lcm.js","names":[],"sources":["../../src/math/lcm.ts"],"sourcesContent":["import { gcd } from './gcd';\n\n/**\n * Computes the least common multiple of two integers.\n *\n * @example\n * ```ts\n * lcm(4, 6); // 12\n * lcm(0, 5); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The least common multiple of `a` and `b`, or `0` if either is `0`.\n */\nexport function lcm(a: number, b: number): number {\n  const divisor = gcd(a, b);\n\n  if (divisor === 0) return 0;\n\n  const result = Math.abs((a / divisor) * b);\n\n  if (!Number.isSafeInteger(result)) throw new RangeError('lcm: result exceeds the safe integer range');\n\n  return result;\n}\n"],"mappings":";;AAeA,SAAgB,EAAI,GAAW,GAAmB;CAChD,IAAM,IAAU,EAAI,GAAG,CAAC;CAExB,IAAI,MAAY,GAAG,OAAO;CAE1B,IAAM,IAAS,KAAK,IAAK,IAAI,IAAW,CAAC;CAEzC,IAAI,CAAC,OAAO,cAAc,CAAM,GAAG,MAAU,WAAW,4CAA4C;CAEpG,OAAO;AACT"}
+{"version":3,"file":"lcm.js","names":[],"sources":["../../src/math/lcm.ts"],"sourcesContent":["import { gcd } from './gcd';\n\n/**\n * Computes the least common multiple of two integers.\n *\n * @example\n * ```ts\n * lcm(4, 6); // 12\n * lcm(0, 5); // 0\n * ```\n *\n * @param a - The first integer.\n * @param b - The second integer.\n * @returns The least common multiple of `a` and `b`, or `0` if either is `0`.\n */\nexport function lcm(a: number, b: number): number {\n  const divisor = gcd(a, b);\n\n  if (divisor === 0) return 0;\n\n  const result = Math.abs((a / divisor) * b);\n\n  if (!Number.isSafeInteger(result)) throw new RangeError('lcm: result exceeds the safe integer range');\n\n  return result;\n}\n"],"mappings":"+BAeA,SAAgB,IAAI,EAAW,EAAmB,CAChD,IAAM,EAAU,EAAI,EAAG,CAAC,EAExB,GAAI,IAAY,EAAG,MAAO,GAE1B,IAAM,EAAS,KAAK,IAAK,EAAI,EAAW,CAAC,EAEzC,GAAI,CAAC,OAAO,cAAc,CAAM,EAAG,MAAU,WAAW,4CAA4C,EAEpG,OAAO,CACT"}

package/dist/math/lerp.cjs

@@ -1,2 +1,2 @@
-function e(e,t,n){return e+(t-e)*n}exports.lerp=e;
+function lerp(e,t,n){return e+(t-e)*n}exports.lerp=lerp;
 //# sourceMappingURL=lerp.cjs.map

package/dist/math/lerp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lerp.cjs","names":[],"sources":["../../src/math/lerp.ts"],"sourcesContent":["/**\n * Linearly interpolates between `a` and `b` by factor `t`. `t` is not clamped, so values\n * outside `[0, 1]` extrapolate beyond the `[a, b]` range.\n *\n * @example\n * ```ts\n * lerp(0, 10, 0.5); // 5\n * lerp(0, 10, 1.5); // 15 (extrapolated — t is not clamped)\n * ```\n *\n * @param a - The start value (returned when `t` is `0`).\n * @param b - The end value (returned when `t` is `1`).\n * @param t - The interpolation factor.\n * @returns The interpolated value.\n */\nexport function lerp(a: number, b: number, t: number): number {\n  return a + (b - a) * t;\n}\n"],"mappings":"AAeA,SAAgB,EAAK,EAAW,EAAW,EAAmB,CAC5D,OAAO,GAAK,EAAI,GAAK,CACvB"}
+{"version":3,"file":"lerp.cjs","names":[],"sources":["../../src/math/lerp.ts"],"sourcesContent":["/**\n * Linearly interpolates between `a` and `b` by factor `t`. `t` is not clamped, so values\n * outside `[0, 1]` extrapolate beyond the `[a, b]` range.\n *\n * @example\n * ```ts\n * lerp(0, 10, 0.5); // 5\n * lerp(0, 10, 1.5); // 15 (extrapolated — t is not clamped)\n * ```\n *\n * @param a - The start value (returned when `t` is `0`).\n * @param b - The end value (returned when `t` is `1`).\n * @param t - The interpolation factor.\n * @returns The interpolated value.\n */\nexport function lerp(a: number, b: number, t: number): number {\n  return a + (b - a) * t;\n}\n"],"mappings":"AAeA,SAAgB,KAAK,EAAW,EAAW,EAAmB,CAC5D,OAAO,GAAK,EAAI,GAAK,CACvB"}

package/dist/math/lerp.js

@@ -1,8 +1,2 @@
-//#region src/math/lerp.ts
-function e(e, t, n) {
-	return e + (t - e) * n;
-}
-//#endregion
-export { e as lerp };
-
+function lerp(e,t,n){return e+(t-e)*n}export{lerp};
 //# sourceMappingURL=lerp.js.map

package/dist/math/lerp.js.map

@@ -1 +1 @@
-{"version":3,"file":"lerp.js","names":[],"sources":["../../src/math/lerp.ts"],"sourcesContent":["/**\n * Linearly interpolates between `a` and `b` by factor `t`. `t` is not clamped, so values\n * outside `[0, 1]` extrapolate beyond the `[a, b]` range.\n *\n * @example\n * ```ts\n * lerp(0, 10, 0.5); // 5\n * lerp(0, 10, 1.5); // 15 (extrapolated — t is not clamped)\n * ```\n *\n * @param a - The start value (returned when `t` is `0`).\n * @param b - The end value (returned when `t` is `1`).\n * @param t - The interpolation factor.\n * @returns The interpolated value.\n */\nexport function lerp(a: number, b: number, t: number): number {\n  return a + (b - a) * t;\n}\n"],"mappings":";AAeA,SAAgB,EAAK,GAAW,GAAW,GAAmB;CAC5D,OAAO,KAAK,IAAI,KAAK;AACvB"}
+{"version":3,"file":"lerp.js","names":[],"sources":["../../src/math/lerp.ts"],"sourcesContent":["/**\n * Linearly interpolates between `a` and `b` by factor `t`. `t` is not clamped, so values\n * outside `[0, 1]` extrapolate beyond the `[a, b]` range.\n *\n * @example\n * ```ts\n * lerp(0, 10, 0.5); // 5\n * lerp(0, 10, 1.5); // 15 (extrapolated — t is not clamped)\n * ```\n *\n * @param a - The start value (returned when `t` is `0`).\n * @param b - The end value (returned when `t` is `1`).\n * @param t - The interpolation factor.\n * @returns The interpolated value.\n */\nexport function lerp(a: number, b: number, t: number): number {\n  return a + (b - a) * t;\n}\n"],"mappings":"AAeA,SAAgB,KAAK,EAAW,EAAW,EAAmB,CAC5D,OAAO,GAAK,EAAI,GAAK,CACvB"}

package/dist/math/linspace.cjs

@@ -1,2 +1,2 @@
-function e(e,t,n=5){if(!Number.isFinite(e)||!Number.isFinite(t))throw RangeError(`linspace: bounds must be finite`);if(!Number.isSafeInteger(n)||n<1)throw RangeError(`linspace: steps must be a positive integer`);if(n===1)return[e];let r=(t-e)/(n-1);return Array.from({length:n},(t,n)=>e+n*r)}exports.linspace=e;
+function linspace(e,t,n=5){if(!Number.isFinite(e)||!Number.isFinite(t))throw RangeError(`linspace: bounds must be finite`);if(!Number.isSafeInteger(n)||n<1)throw RangeError(`linspace: steps must be a positive integer`);if(n===1)return[e];let r=(t-e)/(n-1);return Array.from({length:n},(t,n)=>e+n*r)}exports.linspace=linspace;
 //# sourceMappingURL=linspace.cjs.map

package/dist/math/linspace.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"linspace.cjs","names":[],"sources":["../../src/math/linspace.ts"],"sourcesContent":["/**\n * Creates an array of evenly-spaced numbers from `start` to `end`.\n *\n * @example\n * ```ts\n * linspace(0, 10);        // [0, 2.5, 5, 7.5, 10]\n * linspace(0, 10, 3);     // [0, 5, 10]\n * linspace(0, 10, 1);     // [0]\n * linspace(10, 0, 5);     // [10, 7.5, 5, 2.5, 0]\n * ```\n *\n * @param start - The start of the range.\n * @param end - The end of the range.\n * @param steps - Number of evenly-spaced points to generate (default: 5).\n *\n * @returns An array of `steps` numbers from `start` to `end`.\n */\nexport function linspace(start: number, end: number, steps = 5): number[] {\n  if (!Number.isFinite(start) || !Number.isFinite(end)) throw new RangeError('linspace: bounds must be finite');\n  if (!Number.isSafeInteger(steps) || steps < 1) throw new RangeError('linspace: steps must be a positive integer');\n\n  if (steps === 1) return [start];\n\n  const stepSize = (end - start) / (steps - 1);\n\n  return Array.from({ length: steps }, (_, i) => start + i * stepSize);\n}\n"],"mappings":"AAiBA,SAAgB,EAAS,EAAe,EAAa,EAAQ,EAAa,CACxE,GAAI,CAAC,OAAO,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAG,EAAG,MAAU,WAAW,iCAAiC,EAC5G,GAAI,CAAC,OAAO,cAAc,CAAK,GAAK,EAAQ,EAAG,MAAU,WAAW,4CAA4C,EAEhH,GAAI,IAAU,EAAG,MAAO,CAAC,CAAK,EAE9B,IAAM,GAAY,EAAM,IAAU,EAAQ,GAE1C,OAAO,MAAM,KAAK,CAAE,OAAQ,CAAM,GAAI,EAAG,IAAM,EAAQ,EAAI,CAAQ,CACrE"}
+{"version":3,"file":"linspace.cjs","names":[],"sources":["../../src/math/linspace.ts"],"sourcesContent":["/**\n * Creates an array of evenly-spaced numbers from `start` to `end`.\n *\n * @example\n * ```ts\n * linspace(0, 10);        // [0, 2.5, 5, 7.5, 10]\n * linspace(0, 10, 3);     // [0, 5, 10]\n * linspace(0, 10, 1);     // [0]\n * linspace(10, 0, 5);     // [10, 7.5, 5, 2.5, 0]\n * ```\n *\n * @param start - The start of the range.\n * @param end - The end of the range.\n * @param steps - Number of evenly-spaced points to generate (default: 5).\n *\n * @returns An array of `steps` numbers from `start` to `end`.\n */\nexport function linspace(start: number, end: number, steps = 5): number[] {\n  if (!Number.isFinite(start) || !Number.isFinite(end)) throw new RangeError('linspace: bounds must be finite');\n  if (!Number.isSafeInteger(steps) || steps < 1) throw new RangeError('linspace: steps must be a positive integer');\n\n  if (steps === 1) return [start];\n\n  const stepSize = (end - start) / (steps - 1);\n\n  return Array.from({ length: steps }, (_, i) => start + i * stepSize);\n}\n"],"mappings":"AAiBA,SAAgB,SAAS,EAAe,EAAa,EAAQ,EAAa,CACxE,GAAI,CAAC,OAAO,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAG,EAAG,MAAU,WAAW,iCAAiC,EAC5G,GAAI,CAAC,OAAO,cAAc,CAAK,GAAK,EAAQ,EAAG,MAAU,WAAW,4CAA4C,EAEhH,GAAI,IAAU,EAAG,MAAO,CAAC,CAAK,EAE9B,IAAM,GAAY,EAAM,IAAU,EAAQ,GAE1C,OAAO,MAAM,KAAK,CAAE,OAAQ,CAAM,GAAI,EAAG,IAAM,EAAQ,EAAI,CAAQ,CACrE"}

package/dist/math/linspace.js

@@ -1,12 +1,2 @@
-//#region src/math/linspace.ts
-function e(e, t, n = 5) {
-	if (!Number.isFinite(e) || !Number.isFinite(t)) throw RangeError("linspace: bounds must be finite");
-	if (!Number.isSafeInteger(n) || n < 1) throw RangeError("linspace: steps must be a positive integer");
-	if (n === 1) return [e];
-	let r = (t - e) / (n - 1);
-	return Array.from({ length: n }, (t, n) => e + n * r);
-}
-//#endregion
-export { e as linspace };
-
+function linspace(e,t,n=5){if(!Number.isFinite(e)||!Number.isFinite(t))throw RangeError(`linspace: bounds must be finite`);if(!Number.isSafeInteger(n)||n<1)throw RangeError(`linspace: steps must be a positive integer`);if(n===1)return[e];let r=(t-e)/(n-1);return Array.from({length:n},(t,n)=>e+n*r)}export{linspace};
 //# sourceMappingURL=linspace.js.map

package/dist/math/linspace.js.map

@@ -1 +1 @@
-{"version":3,"file":"linspace.js","names":[],"sources":["../../src/math/linspace.ts"],"sourcesContent":["/**\n * Creates an array of evenly-spaced numbers from `start` to `end`.\n *\n * @example\n * ```ts\n * linspace(0, 10);        // [0, 2.5, 5, 7.5, 10]\n * linspace(0, 10, 3);     // [0, 5, 10]\n * linspace(0, 10, 1);     // [0]\n * linspace(10, 0, 5);     // [10, 7.5, 5, 2.5, 0]\n * ```\n *\n * @param start - The start of the range.\n * @param end - The end of the range.\n * @param steps - Number of evenly-spaced points to generate (default: 5).\n *\n * @returns An array of `steps` numbers from `start` to `end`.\n */\nexport function linspace(start: number, end: number, steps = 5): number[] {\n  if (!Number.isFinite(start) || !Number.isFinite(end)) throw new RangeError('linspace: bounds must be finite');\n  if (!Number.isSafeInteger(steps) || steps < 1) throw new RangeError('linspace: steps must be a positive integer');\n\n  if (steps === 1) return [start];\n\n  const stepSize = (end - start) / (steps - 1);\n\n  return Array.from({ length: steps }, (_, i) => start + i * stepSize);\n}\n"],"mappings":";AAiBA,SAAgB,EAAS,GAAe,GAAa,IAAQ,GAAa;CACxE,IAAI,CAAC,OAAO,SAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAG,GAAG,MAAU,WAAW,iCAAiC;CAC5G,IAAI,CAAC,OAAO,cAAc,CAAK,KAAK,IAAQ,GAAG,MAAU,WAAW,4CAA4C;CAEhH,IAAI,MAAU,GAAG,OAAO,CAAC,CAAK;CAE9B,IAAM,KAAY,IAAM,MAAU,IAAQ;CAE1C,OAAO,MAAM,KAAK,EAAE,QAAQ,EAAM,IAAI,GAAG,MAAM,IAAQ,IAAI,CAAQ;AACrE"}
+{"version":3,"file":"linspace.js","names":[],"sources":["../../src/math/linspace.ts"],"sourcesContent":["/**\n * Creates an array of evenly-spaced numbers from `start` to `end`.\n *\n * @example\n * ```ts\n * linspace(0, 10);        // [0, 2.5, 5, 7.5, 10]\n * linspace(0, 10, 3);     // [0, 5, 10]\n * linspace(0, 10, 1);     // [0]\n * linspace(10, 0, 5);     // [10, 7.5, 5, 2.5, 0]\n * ```\n *\n * @param start - The start of the range.\n * @param end - The end of the range.\n * @param steps - Number of evenly-spaced points to generate (default: 5).\n *\n * @returns An array of `steps` numbers from `start` to `end`.\n */\nexport function linspace(start: number, end: number, steps = 5): number[] {\n  if (!Number.isFinite(start) || !Number.isFinite(end)) throw new RangeError('linspace: bounds must be finite');\n  if (!Number.isSafeInteger(steps) || steps < 1) throw new RangeError('linspace: steps must be a positive integer');\n\n  if (steps === 1) return [start];\n\n  const stepSize = (end - start) / (steps - 1);\n\n  return Array.from({ length: steps }, (_, i) => start + i * stepSize);\n}\n"],"mappings":"AAiBA,SAAgB,SAAS,EAAe,EAAa,EAAQ,EAAa,CACxE,GAAI,CAAC,OAAO,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAG,EAAG,MAAU,WAAW,iCAAiC,EAC5G,GAAI,CAAC,OAAO,cAAc,CAAK,GAAK,EAAQ,EAAG,MAAU,WAAW,4CAA4C,EAEhH,GAAI,IAAU,EAAG,MAAO,CAAC,CAAK,EAE9B,IAAM,GAAY,EAAM,IAAU,EAAQ,GAE1C,OAAO,MAAM,KAAK,CAAE,OAAQ,CAAM,GAAI,EAAG,IAAM,EAAQ,EAAI,CAAQ,CACrE"}

package/dist/math/median.cjs

@@ -1,2 +1,2 @@
-function e(e,t){if(e.length===0)return;let n=t?e.map(t):[...e];n.sort((e,t)=>e-t);let r=Math.floor(n.length/2);return n.length%2==0?(n[r-1]+n[r])/2:n[r]}exports.median=e;
+function median(e,t){if(e.length===0)return;let n=t?e.map(t):[...e];n.sort((e,t)=>e-t);let r=Math.floor(n.length/2);return n.length%2==0?(n[r-1]+n[r])/2:n[r]}exports.median=median;
 //# sourceMappingURL=median.cjs.map

package/dist/math/median.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"median.cjs","names":[],"sources":["../../src/math/median.ts"],"sourcesContent":["/**\n * Returns the median of an array of numbers.\n *\n * @example\n * ```ts\n * median([1, 2, 3, 4, 100]); // 3\n * median([1, 2, 3, 4, 5], (n) => n * 2); // 6\n * median([]); // undefined\n * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The median, or `undefined` if the array is empty.\n */\nexport function median<T>(arr: readonly T[], callback?: (item: T) => number): number | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : [...(arr as unknown as number[])];\n\n  values.sort((a, b) => a - b);\n\n  const mid = Math.floor(values.length / 2);\n\n  return values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid];\n}\n"],"mappings":"AAeA,SAAgB,EAAU,EAAmB,EAAoD,CAC/F,GAAI,EAAI,SAAW,EAAG,OAEtB,IAAM,EAAS,EAAW,EAAI,IAAI,CAAQ,EAAI,CAAC,GAAI,CAA2B,EAE9E,EAAO,MAAM,EAAG,IAAM,EAAI,CAAC,EAE3B,IAAM,EAAM,KAAK,MAAM,EAAO,OAAS,CAAC,EAExC,OAAO,EAAO,OAAS,GAAM,GAAK,EAAO,EAAM,GAAK,EAAO,IAAQ,EAAI,EAAO,EAChF"}
+{"version":3,"file":"median.cjs","names":[],"sources":["../../src/math/median.ts"],"sourcesContent":["/**\n * Returns the median of an array of numbers.\n *\n * @example\n * ```ts\n * median([1, 2, 3, 4, 100]); // 3\n * median([1, 2, 3, 4, 5], (n) => n * 2); // 6\n * median([]); // undefined\n * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The median, or `undefined` if the array is empty.\n */\nexport function median<T>(arr: readonly T[], callback?: (item: T) => number): number | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : [...(arr as unknown as number[])];\n\n  values.sort((a, b) => a - b);\n\n  const mid = Math.floor(values.length / 2);\n\n  return values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid];\n}\n"],"mappings":"AAeA,SAAgB,OAAU,EAAmB,EAAoD,CAC/F,GAAI,EAAI,SAAW,EAAG,OAEtB,IAAM,EAAS,EAAW,EAAI,IAAI,CAAQ,EAAI,CAAC,GAAI,CAA2B,EAE9E,EAAO,MAAM,EAAG,IAAM,EAAI,CAAC,EAE3B,IAAM,EAAM,KAAK,MAAM,EAAO,OAAS,CAAC,EAExC,OAAO,EAAO,OAAS,GAAM,GAAK,EAAO,EAAM,GAAK,EAAO,IAAQ,EAAI,EAAO,EAChF"}

package/dist/math/median.js

@@ -1,12 +1,2 @@
-//#region src/math/median.ts
-function e(e, t) {
-	if (e.length === 0) return;
-	let n = t ? e.map(t) : [...e];
-	n.sort((e, t) => e - t);
-	let r = Math.floor(n.length / 2);
-	return n.length % 2 == 0 ? (n[r - 1] + n[r]) / 2 : n[r];
-}
-//#endregion
-export { e as median };
-
+function median(e,t){if(e.length===0)return;let n=t?e.map(t):[...e];n.sort((e,t)=>e-t);let r=Math.floor(n.length/2);return n.length%2==0?(n[r-1]+n[r])/2:n[r]}export{median};
 //# sourceMappingURL=median.js.map

package/dist/math/median.js.map

@@ -1 +1 @@
-{"version":3,"file":"median.js","names":[],"sources":["../../src/math/median.ts"],"sourcesContent":["/**\n * Returns the median of an array of numbers.\n *\n * @example\n * ```ts\n * median([1, 2, 3, 4, 100]); // 3\n * median([1, 2, 3, 4, 5], (n) => n * 2); // 6\n * median([]); // undefined\n * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The median, or `undefined` if the array is empty.\n */\nexport function median<T>(arr: readonly T[], callback?: (item: T) => number): number | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : [...(arr as unknown as number[])];\n\n  values.sort((a, b) => a - b);\n\n  const mid = Math.floor(values.length / 2);\n\n  return values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid];\n}\n"],"mappings":";AAeA,SAAgB,EAAU,GAAmB,GAAoD;CAC/F,IAAI,EAAI,WAAW,GAAG;CAEtB,IAAM,IAAS,IAAW,EAAI,IAAI,CAAQ,IAAI,CAAC,GAAI,CAA2B;CAE9E,EAAO,MAAM,GAAG,MAAM,IAAI,CAAC;CAE3B,IAAM,IAAM,KAAK,MAAM,EAAO,SAAS,CAAC;CAExC,OAAO,EAAO,SAAS,KAAM,KAAK,EAAO,IAAM,KAAK,EAAO,MAAQ,IAAI,EAAO;AAChF"}
+{"version":3,"file":"median.js","names":[],"sources":["../../src/math/median.ts"],"sourcesContent":["/**\n * Returns the median of an array of numbers.\n *\n * @example\n * ```ts\n * median([1, 2, 3, 4, 100]); // 3\n * median([1, 2, 3, 4, 5], (n) => n * 2); // 6\n * median([]); // undefined\n * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The median, or `undefined` if the array is empty.\n */\nexport function median<T>(arr: readonly T[], callback?: (item: T) => number): number | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : [...(arr as unknown as number[])];\n\n  values.sort((a, b) => a - b);\n\n  const mid = Math.floor(values.length / 2);\n\n  return values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid];\n}\n"],"mappings":"AAeA,SAAgB,OAAU,EAAmB,EAAoD,CAC/F,GAAI,EAAI,SAAW,EAAG,OAEtB,IAAM,EAAS,EAAW,EAAI,IAAI,CAAQ,EAAI,CAAC,GAAI,CAA2B,EAE9E,EAAO,MAAM,EAAG,IAAM,EAAI,CAAC,EAE3B,IAAM,EAAM,KAAK,MAAM,EAAO,OAAS,CAAC,EAExC,OAAO,EAAO,OAAS,GAAM,GAAK,EAAO,EAAM,GAAK,EAAO,IAAQ,EAAI,EAAO,EAChF"}

package/dist/math/mod.cjs

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

package/dist/math/mod.cjs.map

@@ -1 +1 @@
-{"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"}
+{"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,IAAI,EAAW,EAAmB,CAChD,GAAI,IAAM,EAAG,MAAU,WAAW,0BAA0B,EAE5D,OAAS,EAAI,EAAK,GAAK,CACzB"}

package/dist/math/mod.js

@@ -1,9 +1,2 @@
-//#region src/math/mod.ts
-function e(e, t) {
-	if (t === 0) throw RangeError("mod: divisor cannot be 0");
-	return (e % t + t) % t;
-}
-//#endregion
-export { e as mod };
-
+function mod(e,t){if(t===0)throw RangeError(`mod: divisor cannot be 0`);return(e%t+t)%t}export{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":["/**\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"}
+{"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,IAAI,EAAW,EAAmB,CAChD,GAAI,IAAM,EAAG,MAAU,WAAW,0BAA0B,EAE5D,OAAS,EAAI,EAAK,GAAK,CACzB"}

package/dist/math/normalize.cjs

@@ -1,2 +1,2 @@
-const e=require("./clamp.cjs");function t(t,n,r){return n===r?0:e.clamp((t-n)/(r-n),0,1)}exports.normalize=t;
+const e=require("./clamp.cjs");function normalize(t,n,r){return n===r?0:e.clamp((t-n)/(r-n),0,1)}exports.normalize=normalize;
 //# sourceMappingURL=normalize.cjs.map

package/dist/math/normalize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.cjs","names":[],"sources":["../../src/math/normalize.ts"],"sourcesContent":["import { clamp } from './clamp';\n\n/**\n * Normalizes a value from the range `[min, max]` into `[0, 1]`. The result is clamped, so\n * values outside `[min, max]` map to `0` or `1` rather than extrapolating.\n *\n * @example\n * ```ts\n * normalize(5, 0, 10); // 0.5\n * normalize(-5, 0, 10); // 0 (clamped)\n * normalize(15, 0, 10); // 1 (clamped)\n * ```\n *\n * @param value - The value to normalize.\n * @param min - The lower bound of the source range.\n * @param max - The upper bound of the source range.\n * @returns The normalized value in `[0, 1]`, or `0` if `min === max`.\n */\nexport function normalize(value: number, min: number, max: number): number {\n  if (min === max) return 0;\n\n  return clamp((value - min) / (max - min), 0, 1);\n}\n"],"mappings":"+BAkBA,SAAgB,EAAU,EAAe,EAAa,EAAqB,CAGzE,OAFI,IAAQ,EAAY,EAEjB,EAAA,OAAO,EAAQ,IAAQ,EAAM,GAAM,EAAG,CAAC,CAChD"}
+{"version":3,"file":"normalize.cjs","names":[],"sources":["../../src/math/normalize.ts"],"sourcesContent":["import { clamp } from './clamp';\n\n/**\n * Normalizes a value from the range `[min, max]` into `[0, 1]`. The result is clamped, so\n * values outside `[min, max]` map to `0` or `1` rather than extrapolating.\n *\n * @example\n * ```ts\n * normalize(5, 0, 10); // 0.5\n * normalize(-5, 0, 10); // 0 (clamped)\n * normalize(15, 0, 10); // 1 (clamped)\n * ```\n *\n * @param value - The value to normalize.\n * @param min - The lower bound of the source range.\n * @param max - The upper bound of the source range.\n * @returns The normalized value in `[0, 1]`, or `0` if `min === max`.\n */\nexport function normalize(value: number, min: number, max: number): number {\n  if (min === max) return 0;\n\n  return clamp((value - min) / (max - min), 0, 1);\n}\n"],"mappings":"+BAkBA,SAAgB,UAAU,EAAe,EAAa,EAAqB,CAGzE,OAFI,IAAQ,EAAY,EAEjB,EAAA,OAAO,EAAQ,IAAQ,EAAM,GAAM,EAAG,CAAC,CAChD"}

package/dist/math/normalize.js

@@ -1,9 +1,2 @@
-import { clamp as e } from "./clamp.js";
-//#region src/math/normalize.ts
-function t(t, n, r) {
-	return n === r ? 0 : e((t - n) / (r - n), 0, 1);
-}
-//#endregion
-export { t as normalize };
-
+import{clamp as e}from"./clamp.js";function normalize(t,n,r){return n===r?0:e((t-n)/(r-n),0,1)}export{normalize};
 //# sourceMappingURL=normalize.js.map

package/dist/math/normalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.js","names":[],"sources":["../../src/math/normalize.ts"],"sourcesContent":["import { clamp } from './clamp';\n\n/**\n * Normalizes a value from the range `[min, max]` into `[0, 1]`. The result is clamped, so\n * values outside `[min, max]` map to `0` or `1` rather than extrapolating.\n *\n * @example\n * ```ts\n * normalize(5, 0, 10); // 0.5\n * normalize(-5, 0, 10); // 0 (clamped)\n * normalize(15, 0, 10); // 1 (clamped)\n * ```\n *\n * @param value - The value to normalize.\n * @param min - The lower bound of the source range.\n * @param max - The upper bound of the source range.\n * @returns The normalized value in `[0, 1]`, or `0` if `min === max`.\n */\nexport function normalize(value: number, min: number, max: number): number {\n  if (min === max) return 0;\n\n  return clamp((value - min) / (max - min), 0, 1);\n}\n"],"mappings":";;AAkBA,SAAgB,EAAU,GAAe,GAAa,GAAqB;CAGzE,OAFI,MAAQ,IAAY,IAEjB,GAAO,IAAQ,MAAQ,IAAM,IAAM,GAAG,CAAC;AAChD"}
+{"version":3,"file":"normalize.js","names":[],"sources":["../../src/math/normalize.ts"],"sourcesContent":["import { clamp } from './clamp';\n\n/**\n * Normalizes a value from the range `[min, max]` into `[0, 1]`. The result is clamped, so\n * values outside `[min, max]` map to `0` or `1` rather than extrapolating.\n *\n * @example\n * ```ts\n * normalize(5, 0, 10); // 0.5\n * normalize(-5, 0, 10); // 0 (clamped)\n * normalize(15, 0, 10); // 1 (clamped)\n * ```\n *\n * @param value - The value to normalize.\n * @param min - The lower bound of the source range.\n * @param max - The upper bound of the source range.\n * @returns The normalized value in `[0, 1]`, or `0` if `min === max`.\n */\nexport function normalize(value: number, min: number, max: number): number {\n  if (min === max) return 0;\n\n  return clamp((value - min) / (max - min), 0, 1);\n}\n"],"mappings":"mCAkBA,SAAgB,UAAU,EAAe,EAAa,EAAqB,CAGzE,OAFI,IAAQ,EAAY,EAEjB,GAAO,EAAQ,IAAQ,EAAM,GAAM,EAAG,CAAC,CAChD"}

package/dist/math/range.cjs

@@ -1,2 +1,2 @@
-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;
+function range(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=range;
 //# sourceMappingURL=range.cjs.map

package/dist/math/range.cjs.map

@@ -1 +1 @@
-{"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"}
+{"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,MAAM,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.js

@@ -1,26 +1,2 @@
-//#region src/math/range.ts
-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);
-}
-//#endregion
-export { e as range };
-
+function range(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)}export{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":["/**\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"}
+{"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,MAAM,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/round.cjs

@@ -1,2 +1,2 @@
-function e(e,t=0,n=Math.round){if(t===0)return n(e);let r=10**Math.max(-323,Math.min(t,292));return n(e*r)/r}exports.round=e;
+function round(e,t=0,n=Math.round){if(t===0)return n(e);let r=10**Math.max(-323,Math.min(t,292));return n(e*r)/r}exports.round=round;
 //# sourceMappingURL=round.cjs.map

package/dist/math/round.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"round.cjs","names":[],"sources":["../../src/math/round.ts"],"sourcesContent":["/**\n * Rounds a number to a specified number of decimal places.\n *\n * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.\n *\n * @example\n * ```ts\n * round(123.456) // 123\n * round(123.456, -1) // 120\n * round(123.456, 1, Math.ceil) // 123.5\n * round(123.456, 1, Math.floor) // 123.4\n * ```\n *\n * @param value - The number to round.\n * @param precision - The number of decimal places to round to.\n * @param [parser] - (optional) function to convert the number to a value.\n *\n * @returns The rounded number.\n */\nexport function round(value: number, precision = 0, parser: (value: number) => number = Math.round): number {\n  if (precision === 0) return parser(value);\n\n  const factor = 10 ** Math.max(-323, Math.min(precision, 292));\n\n  return parser(value * factor) / factor;\n}\n"],"mappings":"AAmBA,SAAgB,EAAM,EAAe,EAAY,EAAG,EAAoC,KAAK,MAAe,CAC1G,GAAI,IAAc,EAAG,OAAO,EAAO,CAAK,EAExC,IAAM,EAAS,IAAM,KAAK,IAAI,KAAM,KAAK,IAAI,EAAW,GAAG,CAAC,EAE5D,OAAO,EAAO,EAAQ,CAAM,EAAI,CAClC"}
+{"version":3,"file":"round.cjs","names":[],"sources":["../../src/math/round.ts"],"sourcesContent":["/**\n * Rounds a number to a specified number of decimal places.\n *\n * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.\n *\n * @example\n * ```ts\n * round(123.456) // 123\n * round(123.456, -1) // 120\n * round(123.456, 1, Math.ceil) // 123.5\n * round(123.456, 1, Math.floor) // 123.4\n * ```\n *\n * @param value - The number to round.\n * @param precision - The number of decimal places to round to.\n * @param [parser] - (optional) function to convert the number to a value.\n *\n * @returns The rounded number.\n */\nexport function round(value: number, precision = 0, parser: (value: number) => number = Math.round): number {\n  if (precision === 0) return parser(value);\n\n  const factor = 10 ** Math.max(-323, Math.min(precision, 292));\n\n  return parser(value * factor) / factor;\n}\n"],"mappings":"AAmBA,SAAgB,MAAM,EAAe,EAAY,EAAG,EAAoC,KAAK,MAAe,CAC1G,GAAI,IAAc,EAAG,OAAO,EAAO,CAAK,EAExC,IAAM,EAAS,IAAM,KAAK,IAAI,KAAM,KAAK,IAAI,EAAW,GAAG,CAAC,EAE5D,OAAO,EAAO,EAAQ,CAAM,EAAI,CAClC"}

package/dist/math/round.js

@@ -1,10 +1,2 @@
-//#region src/math/round.ts
-function e(e, t = 0, n = Math.round) {
-	if (t === 0) return n(e);
-	let r = 10 ** Math.max(-323, Math.min(t, 292));
-	return n(e * r) / r;
-}
-//#endregion
-export { e as round };
-
+function round(e,t=0,n=Math.round){if(t===0)return n(e);let r=10**Math.max(-323,Math.min(t,292));return n(e*r)/r}export{round};
 //# sourceMappingURL=round.js.map

package/dist/math/round.js.map

@@ -1 +1 @@
-{"version":3,"file":"round.js","names":[],"sources":["../../src/math/round.ts"],"sourcesContent":["/**\n * Rounds a number to a specified number of decimal places.\n *\n * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.\n *\n * @example\n * ```ts\n * round(123.456) // 123\n * round(123.456, -1) // 120\n * round(123.456, 1, Math.ceil) // 123.5\n * round(123.456, 1, Math.floor) // 123.4\n * ```\n *\n * @param value - The number to round.\n * @param precision - The number of decimal places to round to.\n * @param [parser] - (optional) function to convert the number to a value.\n *\n * @returns The rounded number.\n */\nexport function round(value: number, precision = 0, parser: (value: number) => number = Math.round): number {\n  if (precision === 0) return parser(value);\n\n  const factor = 10 ** Math.max(-323, Math.min(precision, 292));\n\n  return parser(value * factor) / factor;\n}\n"],"mappings":";AAmBA,SAAgB,EAAM,GAAe,IAAY,GAAG,IAAoC,KAAK,OAAe;CAC1G,IAAI,MAAc,GAAG,OAAO,EAAO,CAAK;CAExC,IAAM,IAAS,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,GAAW,GAAG,CAAC;CAE5D,OAAO,EAAO,IAAQ,CAAM,IAAI;AAClC"}
+{"version":3,"file":"round.js","names":[],"sources":["../../src/math/round.ts"],"sourcesContent":["/**\n * Rounds a number to a specified number of decimal places.\n *\n * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.\n *\n * @example\n * ```ts\n * round(123.456) // 123\n * round(123.456, -1) // 120\n * round(123.456, 1, Math.ceil) // 123.5\n * round(123.456, 1, Math.floor) // 123.4\n * ```\n *\n * @param value - The number to round.\n * @param precision - The number of decimal places to round to.\n * @param [parser] - (optional) function to convert the number to a value.\n *\n * @returns The rounded number.\n */\nexport function round(value: number, precision = 0, parser: (value: number) => number = Math.round): number {\n  if (precision === 0) return parser(value);\n\n  const factor = 10 ** Math.max(-323, Math.min(precision, 292));\n\n  return parser(value * factor) / factor;\n}\n"],"mappings":"AAmBA,SAAgB,MAAM,EAAe,EAAY,EAAG,EAAoC,KAAK,MAAe,CAC1G,GAAI,IAAc,EAAG,OAAO,EAAO,CAAK,EAExC,IAAM,EAAS,IAAM,KAAK,IAAI,KAAM,KAAK,IAAI,EAAW,GAAG,CAAC,EAE5D,OAAO,EAAO,EAAQ,CAAM,EAAI,CAClC"}

package/dist/math/standardDeviation.cjs

@@ -1,2 +1,2 @@
-const e=require("./variance.cjs");function t(t,n){return Math.sqrt(e.variance(t,n))}exports.standardDeviation=t;
+const e=require("./variance.cjs");function standardDeviation(t,n){return Math.sqrt(e.variance(t,n))}exports.standardDeviation=standardDeviation;
 //# sourceMappingURL=standardDeviation.cjs.map

package/dist/math/standardDeviation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"standardDeviation.cjs","names":[],"sources":["../../src/math/standardDeviation.ts"],"sourcesContent":["import { variance } from './variance';\n\n/**\n * Computes the population standard deviation (square root of `variance`) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2\n * standardDeviation([]); // 0\n * ```\n *\n * @param array - The array to compute standard deviation over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population standard deviation, or `0` for an empty array.\n */\nexport function standardDeviation<T>(array: readonly T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":"kCAgBA,SAAgB,EAAqB,EAAqB,EAAwC,CAChG,OAAO,KAAK,KAAK,EAAA,SAAS,EAAO,CAAQ,CAAC,CAC5C"}
+{"version":3,"file":"standardDeviation.cjs","names":[],"sources":["../../src/math/standardDeviation.ts"],"sourcesContent":["import { variance } from './variance';\n\n/**\n * Computes the population standard deviation (square root of `variance`) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2\n * standardDeviation([]); // 0\n * ```\n *\n * @param array - The array to compute standard deviation over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population standard deviation, or `0` for an empty array.\n */\nexport function standardDeviation<T>(array: readonly T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":"kCAgBA,SAAgB,kBAAqB,EAAqB,EAAwC,CAChG,OAAO,KAAK,KAAK,EAAA,SAAS,EAAO,CAAQ,CAAC,CAC5C"}

package/dist/math/standardDeviation.js

@@ -1,9 +1,2 @@
-import { variance as e } from "./variance.js";
-//#region src/math/standardDeviation.ts
-function t(t, n) {
-	return Math.sqrt(e(t, n));
-}
-//#endregion
-export { t as standardDeviation };
-
+import{variance as e}from"./variance.js";function standardDeviation(t,n){return Math.sqrt(e(t,n))}export{standardDeviation};
 //# sourceMappingURL=standardDeviation.js.map

package/dist/math/standardDeviation.js.map

@@ -1 +1 @@
-{"version":3,"file":"standardDeviation.js","names":[],"sources":["../../src/math/standardDeviation.ts"],"sourcesContent":["import { variance } from './variance';\n\n/**\n * Computes the population standard deviation (square root of `variance`) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2\n * standardDeviation([]); // 0\n * ```\n *\n * @param array - The array to compute standard deviation over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population standard deviation, or `0` for an empty array.\n */\nexport function standardDeviation<T>(array: readonly T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":";;AAgBA,SAAgB,EAAqB,GAAqB,GAAwC;CAChG,OAAO,KAAK,KAAK,EAAS,GAAO,CAAQ,CAAC;AAC5C"}
+{"version":3,"file":"standardDeviation.js","names":[],"sources":["../../src/math/standardDeviation.ts"],"sourcesContent":["import { variance } from './variance';\n\n/**\n * Computes the population standard deviation (square root of `variance`) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2\n * standardDeviation([]); // 0\n * ```\n *\n * @param array - The array to compute standard deviation over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population standard deviation, or `0` for an empty array.\n */\nexport function standardDeviation<T>(array: readonly T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":"yCAgBA,SAAgB,kBAAqB,EAAqB,EAAwC,CAChG,OAAO,KAAK,KAAK,EAAS,EAAO,CAAQ,CAAC,CAC5C"}

package/dist/math/sum.cjs

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

package/dist/math/sum.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sum.cjs","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (!Number.isFinite(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"AAiBA,SAAgB,EAAO,EAAqB,EAAwC,CAGlF,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,CAAC,OAAO,SAAS,CAAG,EACtB,MAAU,UAAU,kFAAkF,EAGxG,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}
+{"version":3,"file":"sum.cjs","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (!Number.isFinite(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"AAiBA,SAAgB,IAAO,EAAqB,EAAwC,CAGlF,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,CAAC,OAAO,SAAS,CAAG,EACtB,MAAU,UAAU,kFAAkF,EAGxG,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}

package/dist/math/sum.js

@@ -1,12 +1,2 @@
-//#region src/math/sum.ts
-function e(e, t) {
-	return e.length === 0 ? 0 : e.reduce((e, n) => {
-		let r = t ? t(n) : n;
-		if (!Number.isFinite(r)) throw TypeError("sum: encountered a non-numeric value; provide a callback to map non-number items");
-		return e + r;
-	}, 0);
-}
-//#endregion
-export { e as sum };
-
+function sum(e,t){return e.length===0?0:e.reduce((e,n)=>{let r=t?t(n):n;if(!Number.isFinite(r))throw TypeError(`sum: encountered a non-numeric value; provide a callback to map non-number items`);return e+r},0)}export{sum};
 //# sourceMappingURL=sum.js.map

package/dist/math/sum.js.map

@@ -1 +1 @@
-{"version":3,"file":"sum.js","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (!Number.isFinite(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":";AAiBA,SAAgB,EAAO,GAAqB,GAAwC;CAGlF,OAFI,EAAM,WAAW,IAAU,IAExB,EAAM,QAAgB,GAAK,MAAS;EACzC,IAAM,IAAM,IAAW,EAAS,CAAI,IAAK;EAEzC,IAAI,CAAC,OAAO,SAAS,CAAG,GACtB,MAAU,UAAU,kFAAkF;EAGxG,OAAO,IAAM;CACf,GAAG,CAAC;AACN"}
+{"version":3,"file":"sum.js","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (!Number.isFinite(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"AAiBA,SAAgB,IAAO,EAAqB,EAAwC,CAGlF,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,CAAC,OAAO,SAAS,CAAG,EACtB,MAAU,UAAU,kFAAkF,EAGxG,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}

package/dist/math/variance.cjs

@@ -1,2 +1,2 @@
-const e=require("./average.cjs");function t(t,n){if(t.length===0)return 0;let r=n?t.map(n):t,i=e.average(r)??0;return e.average(r.map(e=>(e-i)**2))??0}exports.variance=t;
+const e=require("./average.cjs");function variance(t,n){if(t.length===0)return 0;let r=n?t.map(n):t,i=e.average(r)??0;return e.average(r.map(e=>(e-i)**2))??0}exports.variance=variance;
 //# sourceMappingURL=variance.cjs.map

package/dist/math/variance.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"variance.cjs","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":"iCAiBA,SAAgB,EAAY,EAAqB,EAAwC,CACvF,GAAI,EAAM,SAAW,EAAG,MAAO,GAE/B,IAAM,EAAS,EAAW,EAAM,IAAI,CAAQ,EAAK,EAC3C,EAAO,EAAA,QAAQ,CAAM,GAAK,EAEhC,OAAO,EAAA,QAAQ,EAAO,IAAK,IAAW,EAAQ,IAAS,CAAC,CAAC,GAAK,CAChE"}
+{"version":3,"file":"variance.cjs","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":"iCAiBA,SAAgB,SAAY,EAAqB,EAAwC,CACvF,GAAI,EAAM,SAAW,EAAG,MAAO,GAE/B,IAAM,EAAS,EAAW,EAAM,IAAI,CAAQ,EAAK,EAC3C,EAAO,EAAA,QAAQ,CAAM,GAAK,EAEhC,OAAO,EAAA,QAAQ,EAAO,IAAK,IAAW,EAAQ,IAAS,CAAC,CAAC,GAAK,CAChE"}

package/dist/math/variance.js

@@ -1,11 +1,2 @@
-import { average as e } from "./average.js";
-//#region src/math/variance.ts
-function t(t, n) {
-	if (t.length === 0) return 0;
-	let r = n ? t.map(n) : t, i = e(r) ?? 0;
-	return e(r.map((e) => (e - i) ** 2)) ?? 0;
-}
-//#endregion
-export { t as variance };
-
+import{average as e}from"./average.js";function variance(t,n){if(t.length===0)return 0;let r=n?t.map(n):t,i=e(r)??0;return e(r.map(e=>(e-i)**2))??0}export{variance};
 //# sourceMappingURL=variance.js.map

package/dist/math/variance.js.map

@@ -1 +1 @@
-{"version":3,"file":"variance.js","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":";;AAiBA,SAAgB,EAAY,GAAqB,GAAwC;CACvF,IAAI,EAAM,WAAW,GAAG,OAAO;CAE/B,IAAM,IAAS,IAAW,EAAM,IAAI,CAAQ,IAAK,GAC3C,IAAO,EAAQ,CAAM,KAAK;CAEhC,OAAO,EAAQ,EAAO,KAAK,OAAW,IAAQ,MAAS,CAAC,CAAC,KAAK;AAChE"}
+{"version":3,"file":"variance.js","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":"uCAiBA,SAAgB,SAAY,EAAqB,EAAwC,CACvF,GAAI,EAAM,SAAW,EAAG,MAAO,GAE/B,IAAM,EAAS,EAAW,EAAM,IAAI,CAAQ,EAAK,EAC3C,EAAO,EAAQ,CAAM,GAAK,EAEhC,OAAO,EAAQ,EAAO,IAAK,IAAW,EAAQ,IAAS,CAAC,CAAC,GAAK,CAChE"}

package/dist/object/defaults.cjs

@@ -1,2 +1,2 @@
-const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");function n(n,...r){let i={...n};for(let n of r)if(t.isPlainObject(n))for(let t of Object.keys(n))e.isUnsafeKey(t)||i[t]===void 0&&(i[t]=n[t]);return i}exports.defaults=n;
+const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");function defaults(n,...r){let i={...n};for(let n of r)if(t.isPlainObject(n))for(let t of Object.keys(n))e.isUnsafeKey(t)||i[t]===void 0&&(i[t]=n[t]);return i}exports.defaults=defaults;
 //# sourceMappingURL=defaults.cjs.map

package/dist/object/defaults.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":"uFAkBA,SAAgB,EAAwB,EAAW,GAAG,EAA+B,CACnF,IAAM,EAAM,CAAE,GAAG,CAAO,EAExB,IAAK,IAAM,KAAU,EACd,KAAA,cAAc,CAAM,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAC9B,EAAA,YAAY,CAAkB,GAE9B,EAAI,KAAS,IAAA,KACf,EAAI,GAAO,EAAO,IAKxB,OAAO,CACT"}
+{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":"uFAkBA,SAAgB,SAAwB,EAAW,GAAG,EAA+B,CACnF,IAAM,EAAM,CAAE,GAAG,CAAO,EAExB,IAAK,IAAM,KAAU,EACd,KAAA,cAAc,CAAM,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAC9B,EAAA,YAAY,CAAkB,GAE9B,EAAI,KAAS,IAAA,KACf,EAAI,GAAO,EAAO,IAKxB,OAAO,CACT"}

package/dist/object/defaults.js

@@ -1,12 +1,2 @@
-import { isUnsafeKey as e } from "../_common/unsafePaths.js";
-import { isPlainObject as t } from "../guards/isPlainObject.js";
-//#region src/object/defaults.ts
-function n(n, ...r) {
-	let i = { ...n };
-	for (let n of r) if (t(n)) for (let t of Object.keys(n)) e(t) || i[t] === void 0 && (i[t] = n[t]);
-	return i;
-}
-//#endregion
-export { n as defaults };
-
+import{isUnsafeKey as e}from"../_common/unsafePaths.js";import{isPlainObject as t}from"../guards/isPlainObject.js";function defaults(n,...r){let i={...n};for(let n of r)if(t(n))for(let t of Object.keys(n))e(t)||i[t]===void 0&&(i[t]=n[t]);return i}export{defaults};
 //# sourceMappingURL=defaults.js.map

package/dist/object/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":";;;AAkBA,SAAgB,EAAwB,GAAW,GAAG,GAA+B;CACnF,IAAM,IAAM,EAAE,GAAG,EAAO;CAExB,KAAK,IAAM,KAAU,GACd,MAAc,CAAM,GAEzB,KAAK,IAAM,KAAO,OAAO,KAAK,CAAM,GAC9B,EAAY,CAAkB,KAE9B,EAAI,OAAS,KAAA,MACf,EAAI,KAAO,EAAO;CAKxB,OAAO;AACT"}
+{"version":3,"file":"defaults.js","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mHAkBA,SAAgB,SAAwB,EAAW,GAAG,EAA+B,CACnF,IAAM,EAAM,CAAE,GAAG,CAAO,EAExB,IAAK,IAAM,KAAU,EACd,KAAc,CAAM,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAC9B,EAAY,CAAkB,GAE9B,EAAI,KAAS,IAAA,KACf,EAAI,GAAO,EAAO,IAKxB,OAAO,CACT"}

package/dist/object/diff.cjs

@@ -1,2 +1,2 @@
-const e=require("../guards/isEqual.cjs"),t=require("../_common/unsafePaths.cjs");function n(n={},r={},i=e.isEqual){let a=[],o=[],s={},c=new Set(Object.keys(n)),l=new Set(Object.keys(r));for(let e of l)c.has(e)?!t.isUnsafeKey(e)&&!i(n[e],r[e])&&(s[e]={after:r[e],before:n[e]}):a.push(e);for(let e of c)l.has(e)||o.push(e);return{added:a,changed:s,removed:o}}function r(t,n,r){let i=r?.compareFn??((t,n)=>e.isEqual(t,n));return{added:n.filter(e=>!t.some(t=>i(t,e))),removed:t.filter(e=>!n.some(t=>i(e,t)))}}exports.diff=n,exports.diffArrays=r;
+const e=require("../guards/isEqual.cjs"),t=require("../_common/unsafePaths.cjs");function diff(n={},r={},i=e.isEqual){let a=[],o=[],s={},c=new Set(Object.keys(n)),l=new Set(Object.keys(r));for(let e of l)c.has(e)?!t.isUnsafeKey(e)&&!i(n[e],r[e])&&(s[e]={after:r[e],before:n[e]}):a.push(e);for(let e of c)l.has(e)||o.push(e);return{added:a,changed:s,removed:o}}function diffArrays(t,n,r){let i=r?.compareFn??((t,n)=>e.isEqual(t,n));return{added:n.filter(e=>!t.some(t=>i(t,e))),removed:t.filter(e=>!n.some(t=>i(e,t)))}}exports.diff=diff,exports.diffArrays=diffArrays;
 //# sourceMappingURL=diff.cjs.map