@vielzeug/arsenal 1.0.1

package/dist/math/min.js

@@ -0,0 +1,12 @@
+import { compare as e } from "../array/compare.js";
+//#region src/math/min.ts
+function t(t, n) {
+	if (t.length === 0) return;
+	let r = n ?? ((e) => e), i = t[0];
+	for (let n = 1; n < t.length; n++) e(r(t[n]), r(i)) < 0 && (i = t[n]);
+	return i;
+}
+//#endregion
+export { t as min };
+
+//# sourceMappingURL=min.js.map

package/dist/math/min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"min.js","names":[],"sources":["../../src/math/min.ts"],"sourcesContent":["import { compare } from '../array/compare';\n\n/**\n * Finds the minimum item in an array.\n *\n * @description\n * This function can be used to find the minimum number, string, or any other type of item in an array.\n *\n * @example\n * ```ts\n * min([1, 2, 3]); // 1\n * min([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 1\n * min(['apple', 'banana', 'cherry']); // 'apple'\n * min([new Date('2023-01-01'), new Date('2022-01-01')]); // 2022-01-01\n * ```\n *\n * @param array - The array to be searched.\n * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.\n *\n * @return The item with the minimum value as determined by the callback function.\n */\nexport function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  if (array.length === 0) return undefined;\n\n  const fn = callback ?? ((item: T) => item);\n  let current = array[0];\n\n  for (let i = 1; i < array.length; i++) {\n    if (compare(fn(array[i]), fn(current)) < 0) {\n      current = array[i];\n    }\n  }\n\n  return current;\n}\n"],"mappings":";;AAqBA,SAAgB,EAAO,GAAY,GAA+D;CAChG,IAAI,EAAM,WAAW,GAAG;CAExB,IAAM,IAAK,OAAc,MAAY,IACjC,IAAU,EAAM;CAEpB,KAAK,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,KAChC,AAAI,EAAQ,EAAG,EAAM,EAAE,GAAG,EAAG,CAAO,CAAC,IAAI,MACvC,IAAU,EAAM;CAIpB,OAAO;AACT"}

package/dist/math/mod.cjs

@@ -0,0 +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;
+//# sourceMappingURL=mod.cjs.map

package/dist/math/mod.cjs.map

@@ -0,0 +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"}

package/dist/math/mod.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sign-correct modulo — unlike the native `%` operator, the result always has the same sign
+ * as the divisor `b` (e.g. `mod(-1, 4)` is `3`, not `-1`).
+ *
+ * @example
+ * ```ts
+ * mod(-1, 4); // 3
+ * mod(5, 3); // 2
+ * ```
+ *
+ * @param a - The dividend.
+ * @param b - The divisor. Must not be `0`.
+ * @returns The sign-correct modulo of `a` by `b`.
+ *
+ * @throws {ArsenalValidationError} 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

@@ -0,0 +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"}

package/dist/math/mod.js

@@ -0,0 +1,10 @@
+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;
+}
+//#endregion
+export { t as mod };
+
+//# sourceMappingURL=mod.js.map

package/dist/math/mod.js.map

@@ -0,0 +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"}

package/dist/math/normalize.cjs

@@ -0,0 +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;
+//# sourceMappingURL=normalize.cjs.map

package/dist/math/normalize.cjs.map

@@ -0,0 +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"}

package/dist/math/normalize.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Normalizes a value from the range `[min, max]` into `[0, 1]`. The result is clamped, so
+ * values outside `[min, max]` map to `0` or `1` rather than extrapolating.
+ *
+ * @example
+ * ```ts
+ * normalize(5, 0, 10); // 0.5
+ * normalize(-5, 0, 10); // 0 (clamped)
+ * normalize(15, 0, 10); // 1 (clamped)
+ * ```
+ *
+ * @param value - The value to normalize.
+ * @param min - The lower bound of the source range.
+ * @param max - The upper bound of the source range.
+ * @returns The normalized value in `[0, 1]`, or `0` if `min === max`.
+ */
+export declare function normalize(value: number, min: number, max: number): number;
+//# sourceMappingURL=normalize.d.ts.map

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

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

package/dist/math/normalize.js

@@ -0,0 +1,9 @@
+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 };
+
+//# sourceMappingURL=normalize.js.map

package/dist/math/normalize.js.map

@@ -0,0 +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"}

package/dist/math/percent.cjs

@@ -0,0 +1,2 @@
+function e(e,t){return t===0?0:e/t*100}exports.percent=e;
+//# sourceMappingURL=percent.cjs.map

package/dist/math/percent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"percent.cjs","names":[],"sources":["../../src/math/percent.ts"],"sourcesContent":["/**\n * Calculates what percentage `value` is of `total`.\n *\n * @example\n * ```ts\n * percent(25, 100);  // 25\n * percent(1, 3);     // 33.333...\n * percent(50, 200);  // 25\n * percent(0, 100);   // 0\n * percent(5, 0);     // 0\n * ```\n *\n * @param value - The partial value.\n * @param total - The total value.\n *\n * @returns The percentage (0–100 scale). Returns 0 when `total` is 0.\n */\nexport function percent(value: number, total: number): number {\n  if (total === 0) return 0;\n\n  return (value / total) * 100;\n}\n"],"mappings":"AAiBA,SAAgB,EAAQ,EAAe,EAAuB,CAG5D,OAFI,IAAU,EAAU,EAEhB,EAAQ,EAAS,GAC3B"}

package/dist/math/percent.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Calculates what percentage `value` is of `total`.
+ *
+ * @example
+ * ```ts
+ * percent(25, 100);  // 25
+ * percent(1, 3);     // 33.333...
+ * percent(50, 200);  // 25
+ * percent(0, 100);   // 0
+ * percent(5, 0);     // 0
+ * ```
+ *
+ * @param value - The partial value.
+ * @param total - The total value.
+ *
+ * @returns The percentage (0–100 scale). Returns 0 when `total` is 0.
+ */
+export declare function percent(value: number, total: number): number;
+//# sourceMappingURL=percent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"percent.d.ts","sourceRoot":"","sources":["../../src/math/percent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI5D"}

package/dist/math/percent.js

@@ -0,0 +1,8 @@
+//#region src/math/percent.ts
+function e(e, t) {
+	return t === 0 ? 0 : e / t * 100;
+}
+//#endregion
+export { e as percent };
+
+//# sourceMappingURL=percent.js.map

package/dist/math/percent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"percent.js","names":[],"sources":["../../src/math/percent.ts"],"sourcesContent":["/**\n * Calculates what percentage `value` is of `total`.\n *\n * @example\n * ```ts\n * percent(25, 100);  // 25\n * percent(1, 3);     // 33.333...\n * percent(50, 200);  // 25\n * percent(0, 100);   // 0\n * percent(5, 0);     // 0\n * ```\n *\n * @param value - The partial value.\n * @param total - The total value.\n *\n * @returns The percentage (0–100 scale). Returns 0 when `total` is 0.\n */\nexport function percent(value: number, total: number): number {\n  if (total === 0) return 0;\n\n  return (value / total) * 100;\n}\n"],"mappings":";AAiBA,SAAgB,EAAQ,GAAe,GAAuB;CAG5D,OAFI,MAAU,IAAU,IAEhB,IAAQ,IAAS;AAC3B"}

package/dist/math/range.cjs

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

package/dist/math/range.cjs.map

@@ -0,0 +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"}

package/dist/math/range.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Creates an array of numbers from `0` up to, but not including, `stop` with step `1`.
+ *
+ * @example
+ * ```ts
+ * range(5) // [0, 1, 2, 3, 4]
+ * ```
+ */
+export declare function range(stop: number): number[];
+/**
+ * Creates an array of numbers from `start` up to, but not including, `stop` with step `1`.
+ *
+ * @example
+ * ```ts
+ * range(2, 6) // [2, 3, 4, 5]
+ * ```
+ */
+export declare function range(start: number, stop: number): number[];
+/**
+ * Creates an array of numbers progressing from `start` up to, but not including, `stop` with a given `step`.
+ *
+ * @example
+ * ```ts
+ * range(0, 10, 2) // [0, 2, 4, 6, 8]
+ * range(10, 0, -2) // [10, 8, 6, 4, 2]
+ * ```
+ *
+ * @param start - The start of the range.
+ * @param stop - The end of the range (exclusive).
+ * @param step - The value to increment or decrement by.
+ *
+ * @returns The range of numbers.
+ *
+ * @throws {ArsenalValidationError} 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

@@ -0,0 +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"}

package/dist/math/range.js

@@ -0,0 +1,27 @@
+import { ArsenalValidationError as e } from "../errors.js";
+//#region src/math/range.ts
+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("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);
+}
+//#endregion
+export { t as range };
+
+//# sourceMappingURL=range.js.map

package/dist/math/range.js.map

@@ -0,0 +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"}

package/dist/math/round.cjs

@@ -0,0 +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;
+//# sourceMappingURL=round.cjs.map

package/dist/math/round.cjs.map

@@ -0,0 +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"}

package/dist/math/round.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Rounds a number to a specified number of decimal places.
+ *
+ * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.
+ *
+ * @example
+ * ```ts
+ * round(123.456) // 123
+ * round(123.456, -1) // 120
+ * round(123.456, 1, Math.ceil) // 123.5
+ * round(123.456, 1, Math.floor) // 123.4
+ * ```
+ *
+ * @param value - The number to round.
+ * @param precision - The number of decimal places to round to.
+ * @param [parser] - (optional) function to convert the number to a value.
+ *
+ * @returns The rounded number.
+ */
+export declare function round(value: number, precision?: number, parser?: (value: number) => number): number;
+//# sourceMappingURL=round.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../src/math/round.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,SAAI,EAAE,MAAM,GAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAmB,GAAG,MAAM,CAM1G"}

package/dist/math/round.js

@@ -0,0 +1,10 @@
+//#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 };
+
+//# sourceMappingURL=round.js.map

package/dist/math/round.js.map

@@ -0,0 +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"}

package/dist/math/standardDeviation.cjs

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

package/dist/math/standardDeviation.cjs.map

@@ -0,0 +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: T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":"kCAgBA,SAAgB,EAAqB,EAAY,EAAwC,CACvF,OAAO,KAAK,KAAK,EAAA,SAAS,EAAO,CAAQ,CAAC,CAC5C"}

package/dist/math/standardDeviation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Computes the population standard deviation (square root of `variance`) of an array of
+ * numbers, or of values mapped by a callback.
+ *
+ * @example
+ * ```ts
+ * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2
+ * standardDeviation([]); // 0
+ * ```
+ *
+ * @param array - The array to compute standard deviation over.
+ * @param callback - An optional callback to map each item to a number.
+ * @returns The population standard deviation, or `0` for an empty array.
+ */
+export declare function standardDeviation<T>(array: T[], callback?: (item: T) => number): number;
+//# sourceMappingURL=standardDeviation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standardDeviation.d.ts","sourceRoot":"","sources":["../../src/math/standardDeviation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAEvF"}

package/dist/math/standardDeviation.js

@@ -0,0 +1,9 @@
+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 };
+
+//# sourceMappingURL=standardDeviation.js.map

package/dist/math/standardDeviation.js.map

@@ -0,0 +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: T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":";;AAgBA,SAAgB,EAAqB,GAAY,GAAwC;CACvF,OAAO,KAAK,KAAK,EAAS,GAAO,CAAQ,CAAC;AAC5C"}

package/dist/math/sum.cjs

@@ -0,0 +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;
+//# sourceMappingURL=sum.cjs.map

package/dist/math/sum.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sum.cjs","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\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']) // ArsenalValidationError\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 {ArsenalValidationError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: 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 (typeof val !== 'number' || Number.isNaN(val)) {\n      throw new ArsenalValidationError(\n        'sum: encountered a non-numeric value; provide a callback to map non-number items',\n      );\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"iCAmBA,SAAgB,EAAO,EAAY,EAAwC,CAGzE,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,OAAO,GAAQ,UAAY,OAAO,MAAM,CAAG,EAC7C,MAAM,IAAI,EAAA,uBACR,kFACF,EAGF,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}

package/dist/math/sum.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sum numbers in an array or numbers mapped by a callback function.
+ *
+ * @example
+ * ```ts
+ * sum([1, 2, 3]) // 6
+ * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6
+ * sum(['apple', 'banana', 'cherry']) // ArsenalValidationError
+ * ```
+ *
+ * @param array - The array to sum.
+ * @param callback - An optional callback function to map the values.
+ *
+ * @returns The sum of the numbers in the array or the sum of the mapped values.
+ *
+ * @throws {ArsenalValidationError} If (after an optional `callback` mapping) any item is not a finite number.
+ */
+export declare function sum<T>(array: T[], callback?: (item: T) => number): number;
+//# sourceMappingURL=sum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sum.d.ts","sourceRoot":"","sources":["../../src/math/sum.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAczE"}

package/dist/math/sum.js

@@ -0,0 +1,13 @@
+import { ArsenalValidationError as e } from "../errors.js";
+//#region src/math/sum.ts
+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("sum: encountered a non-numeric value; provide a callback to map non-number items");
+		return t + i;
+	}, 0);
+}
+//#endregion
+export { t as sum };
+
+//# sourceMappingURL=sum.js.map

package/dist/math/sum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sum.js","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\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']) // ArsenalValidationError\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 {ArsenalValidationError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: 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 (typeof val !== 'number' || Number.isNaN(val)) {\n      throw new ArsenalValidationError(\n        'sum: encountered a non-numeric value; provide a callback to map non-number items',\n      );\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":";;AAmBA,SAAgB,EAAO,GAAY,GAAwC;CAGzE,OAFI,EAAM,WAAW,IAAU,IAExB,EAAM,QAAgB,GAAK,MAAS;EACzC,IAAM,IAAM,IAAW,EAAS,CAAI,IAAK;EAEzC,IAAI,OAAO,KAAQ,YAAY,OAAO,MAAM,CAAG,GAC7C,MAAM,IAAI,EACR,kFACF;EAGF,OAAO,IAAM;CACf,GAAG,CAAC;AACN"}

package/dist/math/variance.cjs

@@ -0,0 +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;
+//# sourceMappingURL=variance.cjs.map

package/dist/math/variance.cjs.map

@@ -0,0 +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: 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,EAAY,EAAwC,CAC9E,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.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Computes the population variance (average squared deviation from the mean) of an array of
+ * numbers, or of values mapped by a callback.
+ *
+ * @example
+ * ```ts
+ * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4
+ * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1
+ * variance([]); // 0
+ * ```
+ *
+ * @param array - The array to compute variance over.
+ * @param callback - An optional callback to map each item to a number.
+ * @returns The population variance, or `0` for an empty array.
+ */
+export declare function variance<T>(array: T[], callback?: (item: T) => number): number;
+//# sourceMappingURL=variance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"variance.d.ts","sourceRoot":"","sources":["../../src/math/variance.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAO9E"}

package/dist/math/variance.js

@@ -0,0 +1,11 @@
+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 };
+
+//# sourceMappingURL=variance.js.map

package/dist/math/variance.js.map

@@ -0,0 +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: 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,GAAY,GAAwC;CAC9E,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"}

package/dist/object/defaults.cjs

@@ -0,0 +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;
+//# sourceMappingURL=defaults.cjs.map

package/dist/object/defaults.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\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":"uFAmBA,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"}

package/dist/object/defaults.d.ts

@@ -0,0 +1,17 @@
+import type { Obj } from '../types';
+/**
+ * Fills in `undefined` properties in `target` with values from `sources`. First source wins
+ * — unlike `shallowMerge`, already-set keys are never overwritten.
+ *
+ * @example
+ * ```ts
+ * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });
+ * // { a: 1, b: 2, c: 3 }
+ * ```
+ *
+ * @param target - The object to fill in.
+ * @param sources - One or more partial objects supplying default values.
+ * @returns A new object with missing keys filled from `sources`.
+ */
+export declare function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/object/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/object/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAKpC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAgBnF"}

package/dist/object/defaults.js

@@ -0,0 +1,12 @@
+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 };
+
+//# sourceMappingURL=defaults.js.map

package/dist/object/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\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":";;;AAmBA,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"}

package/dist/object/diff.cjs

@@ -0,0 +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;
+//# sourceMappingURL=diff.cjs.map

package/dist/object/diff.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.cjs","names":[],"sources":["../../src/object/diff.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isEqual } from '../guards/isEqual';\n\nexport type DiffResult<T extends Obj> = {\n  /** Keys present in `after` but not in `before`. */\n  added: Array<keyof T & string>;\n  /** Keys present in both objects whose values differ. Maps key → `{ before, after }`. */\n  changed: { [K in keyof T]?: { after: T[K]; before: T[K] } };\n  /** Keys present in `before` but not in `after`. */\n  removed: Array<keyof T & string>;\n};\n\n/**\n * Computes the structural difference between two plain objects.\n * Returns an `{ added, removed, changed }` result — no sentinel symbols needed.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are omitted from `changed`.\n *\n * @example\n * ```ts\n * diff({ a: 1, b: 2, c: 3 }, { a: 1, b: 99 });\n * // { added: [], removed: ['c'], changed: { b: { before: 2, after: 99 } } }\n *\n * diff({ x: { n: 1 } }, { x: { n: 2 } });\n * // { added: [], removed: [], changed: { x: { before: { n: 1 }, after: { n: 2 } } } }\n * ```\n *\n * @param before - The original object.\n * @param after - The updated object.\n * @param compareFn - Custom equality function. Defaults to deep `isEqual`.\n */\nexport function diff<T extends Obj>(\n  before: T = {} as T,\n  after: T = {} as T,\n  compareFn: (a: unknown, b: unknown) => boolean = isEqual,\n): DiffResult<T> {\n  const added: Array<keyof T & string> = [];\n  const removed: Array<keyof T & string> = [];\n  const changed: Record<string, { after: unknown; before: unknown }> = {};\n\n  const beforeKeys = new Set(Object.keys(before));\n  const afterKeys = new Set(Object.keys(after));\n\n  for (const key of afterKeys) {\n    if (!beforeKeys.has(key)) {\n      added.push(key as keyof T & string);\n    } else if (!isUnsafeKey(key) && !compareFn(before[key], after[key])) {\n      changed[key] = { after: after[key], before: before[key] };\n    }\n  }\n\n  for (const key of beforeKeys) {\n    if (!afterKeys.has(key)) {\n      removed.push(key as keyof T & string);\n    }\n  }\n\n  return { added, changed: changed as DiffResult<T>['changed'], removed };\n}\n\nexport type ArrayDiff<T> = {\n  added: T[];\n  removed: T[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  compareFn?: (a: T, b: T) => boolean;\n};\n\n/**\n * Computes the set-difference between two arrays.\n * Items present in `after` but not `before` are `added`.\n * Items present in `before` but not `after` are `removed`.\n * Order-independent; uses deep equality by default.\n *\n * @example\n * ```ts\n * diffArrays([1, 2, 3], [2, 3, 4]); // { added: [4], removed: [1] }\n * diffArrays(\n *   [{ id: 1 }, { id: 2 }],\n *   [{ id: 2 }, { id: 3 }],\n *   { compareFn: (a, b) => a.id === b.id },\n * ); // { added: [{ id: 3 }], removed: [{ id: 1 }] }\n * ```\n *\n * @param before - The original array.\n * @param after - The updated array.\n * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.\n * @returns An object with `added` and `removed` arrays.\n */\nexport function diffArrays<T>(before: T[], after: T[], options?: ArrayDiffOptions<T>): ArrayDiff<T> {\n  const compareFn = options?.compareFn ?? ((a: T, b: T) => isEqual(a, b));\n\n  return {\n    added: after.filter((item) => !before.some((b) => compareFn(b, item))),\n    removed: before.filter((item) => !after.some((a) => compareFn(item, a))),\n  };\n}\n"],"mappings":"iFAgCA,SAAgB,EACd,EAAY,CAAC,EACb,EAAW,CAAC,EACZ,EAAiD,EAAA,QAClC,CACf,IAAM,EAAiC,CAAC,EAClC,EAAmC,CAAC,EACpC,EAA+D,CAAC,EAEhE,EAAa,IAAI,IAAI,OAAO,KAAK,CAAM,CAAC,EACxC,EAAY,IAAI,IAAI,OAAO,KAAK,CAAK,CAAC,EAE5C,IAAK,IAAM,KAAO,EACX,EAAW,IAAI,CAAG,EAEZ,CAAC,EAAA,YAAY,CAAG,GAAK,CAAC,EAAU,EAAO,GAAM,EAAM,EAAI,IAChE,EAAQ,GAAO,CAAE,MAAO,EAAM,GAAM,OAAQ,EAAO,EAAK,GAFxD,EAAM,KAAK,CAAuB,EAMtC,IAAK,IAAM,KAAO,EACX,EAAU,IAAI,CAAG,GACpB,EAAQ,KAAK,CAAuB,EAIxC,MAAO,CAAE,QAAgB,UAAqC,SAAQ,CACxE,CAgCA,SAAgB,EAAc,EAAa,EAAY,EAA6C,CAClG,IAAM,EAAY,GAAS,aAAe,EAAM,IAAS,EAAA,QAAQ,EAAG,CAAC,GAErE,MAAO,CACL,MAAO,EAAM,OAAQ,GAAS,CAAC,EAAO,KAAM,GAAM,EAAU,EAAG,CAAI,CAAC,CAAC,EACrE,QAAS,EAAO,OAAQ,GAAS,CAAC,EAAM,KAAM,GAAM,EAAU,EAAM,CAAC,CAAC,CAAC,CACzE,CACF"}

package/dist/object/diff.d.ts

@@ -0,0 +1,63 @@
+import type { Obj } from '../types';
+export type DiffResult<T extends Obj> = {
+    /** Keys present in `after` but not in `before`. */
+    added: Array<keyof T & string>;
+    /** Keys present in both objects whose values differ. Maps key → `{ before, after }`. */
+    changed: {
+        [K in keyof T]?: {
+            after: T[K];
+            before: T[K];
+        };
+    };
+    /** Keys present in `before` but not in `after`. */
+    removed: Array<keyof T & string>;
+};
+/**
+ * Computes the structural difference between two plain objects.
+ * Returns an `{ added, removed, changed }` result — no sentinel symbols needed.
+ * Dangerous keys (`__proto__`, `constructor`, `prototype`) are omitted from `changed`.
+ *
+ * @example
+ * ```ts
+ * diff({ a: 1, b: 2, c: 3 }, { a: 1, b: 99 });
+ * // { added: [], removed: ['c'], changed: { b: { before: 2, after: 99 } } }
+ *
+ * diff({ x: { n: 1 } }, { x: { n: 2 } });
+ * // { added: [], removed: [], changed: { x: { before: { n: 1 }, after: { n: 2 } } } }
+ * ```
+ *
+ * @param before - The original object.
+ * @param after - The updated object.
+ * @param compareFn - Custom equality function. Defaults to deep `isEqual`.
+ */
+export declare function diff<T extends Obj>(before?: T, after?: T, compareFn?: (a: unknown, b: unknown) => boolean): DiffResult<T>;
+export type ArrayDiff<T> = {
+    added: T[];
+    removed: T[];
+};
+export type ArrayDiffOptions<T> = {
+    compareFn?: (a: T, b: T) => boolean;
+};
+/**
+ * Computes the set-difference between two arrays.
+ * Items present in `after` but not `before` are `added`.
+ * Items present in `before` but not `after` are `removed`.
+ * Order-independent; uses deep equality by default.
+ *
+ * @example
+ * ```ts
+ * diffArrays([1, 2, 3], [2, 3, 4]); // { added: [4], removed: [1] }
+ * diffArrays(
+ *   [{ id: 1 }, { id: 2 }],
+ *   [{ id: 2 }, { id: 3 }],
+ *   { compareFn: (a, b) => a.id === b.id },
+ * ); // { added: [{ id: 3 }], removed: [{ id: 1 }] }
+ * ```
+ *
+ * @param before - The original array.
+ * @param after - The updated array.
+ * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.
+ * @returns An object with `added` and `removed` arrays.
+ */
+export declare function diffArrays<T>(before: T[], after: T[], options?: ArrayDiffOptions<T>): ArrayDiff<T>;
+//# sourceMappingURL=diff.d.ts.map

package/dist/object/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/object/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAKpC,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,GAAG,IAAI;IACtC,mDAAmD;IACnD,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IAC/B,wFAAwF;IACxF,OAAO,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE;YAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;SAAE;KAAE,CAAC;IAC5D,mDAAmD;IACnD,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAChC,MAAM,GAAE,CAAW,EACnB,KAAK,GAAE,CAAW,EAClB,SAAS,GAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAiB,GACvD,UAAU,CAAC,CAAC,CAAC,CAuBf;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CACrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAOlG"}