@vielzeug/arsenal 1.0.1

package/dist/math/abs.cjs

@@ -0,0 +1,2 @@
+function e(e){return typeof e==`bigint`?e<0n?-e:e:Math.abs(e)}exports.abs=e;
+//# sourceMappingURL=abs.cjs.map

package/dist/math/abs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"abs.cjs","names":[],"sources":["../../src/math/abs.ts"],"sourcesContent":["/**\n * Returns the absolute value of a number.\n * Supports both regular numbers and bigint.\n *\n * @example\n * ```ts\n * abs(-5); // 5\n * abs(3); // 3\n * abs(-100n); // 100n\n * ```\n *\n * @param value - The number or bigint to get absolute value of\n * @returns Absolute value\n */\nexport function abs(value: number): number;\nexport function abs(value: bigint): bigint;\nexport function abs(value: number | bigint): number | bigint {\n  if (typeof value === 'bigint') {\n    return value < 0n ? -value : value;\n  }\n\n  return Math.abs(value);\n}\n"],"mappings":"AAgBA,SAAgB,EAAI,EAAyC,CAK3D,OAJI,OAAO,GAAU,SACZ,EAAQ,GAAK,CAAC,EAAQ,EAGxB,KAAK,IAAI,CAAK,CACvB"}

package/dist/math/abs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the absolute value of a number.
+ * Supports both regular numbers and bigint.
+ *
+ * @example
+ * ```ts
+ * abs(-5); // 5
+ * abs(3); // 3
+ * abs(-100n); // 100n
+ * ```
+ *
+ * @param value - The number or bigint to get absolute value of
+ * @returns Absolute value
+ */
+export declare function abs(value: number): number;
+export declare function abs(value: bigint): bigint;
+//# sourceMappingURL=abs.d.ts.map

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

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

package/dist/math/abs.js

@@ -0,0 +1,8 @@
+//#region src/math/abs.ts
+function e(e) {
+	return typeof e == "bigint" ? e < 0n ? -e : e : Math.abs(e);
+}
+//#endregion
+export { e as abs };
+
+//# sourceMappingURL=abs.js.map

package/dist/math/abs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abs.js","names":[],"sources":["../../src/math/abs.ts"],"sourcesContent":["/**\n * Returns the absolute value of a number.\n * Supports both regular numbers and bigint.\n *\n * @example\n * ```ts\n * abs(-5); // 5\n * abs(3); // 3\n * abs(-100n); // 100n\n * ```\n *\n * @param value - The number or bigint to get absolute value of\n * @returns Absolute value\n */\nexport function abs(value: number): number;\nexport function abs(value: bigint): bigint;\nexport function abs(value: number | bigint): number | bigint {\n  if (typeof value === 'bigint') {\n    return value < 0n ? -value : value;\n  }\n\n  return Math.abs(value);\n}\n"],"mappings":";AAgBA,SAAgB,EAAI,GAAyC;CAK3D,OAJI,OAAO,KAAU,WACZ,IAAQ,KAAK,CAAC,IAAQ,IAGxB,KAAK,IAAI,CAAK;AACvB"}

package/dist/math/allocate.cjs

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

package/dist/math/allocate.cjs.map

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

package/dist/math/allocate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Distributes an amount proportionally according to given ratios.
+ * Handles rounding to ensure the sum equals the original amount exactly.
+ * The indivisible remainder is allocated to the last bucket.
+ * Critical for financial operations like splitting payments to avoid rounding errors.
+ *
+ * @example
+ * ```ts
+ * // Split $100 in ratio 1:2:3 (total ratio = 6)
+ * allocate(100, [1, 2, 3]);
+ * // [16, 33, 51] - sum is exactly 100
+ *
+ * // Split $100 evenly among 3 parts
+ * allocate(100, 3);
+ * // [33, 33, 34] - sum is exactly 100
+ *
+ * // Split with bigint (e.g., cents)
+ * allocate(10000n, [1, 1, 1]);
+ * // [3333n, 3333n, 3334n] - sum is exactly 10000n
+ * ```
+ *
+ * @param amount - Total amount to allocate
+ * @param ratios - Array of ratios for distribution or number of equal parts
+ * @returns Array of allocated amounts with remainder applied to last bucket (sum equals original amount)
+ * @throws {ArsenalValidationError} If ratios array is empty, contains negative values, sums to zero, or parts is not a positive integer
+ */
+export declare function allocate(amount: number, ratios: number[] | number): number[];
+export declare function allocate(amount: bigint, ratios: number[] | number): bigint[];
+//# sourceMappingURL=allocate.d.ts.map

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

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

package/dist/math/allocate.js

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

package/dist/math/allocate.js.map

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

package/dist/math/average.cjs

@@ -0,0 +1,2 @@
+const e=require("./sum.cjs");function t(t,n){if(t.length!==0)try{let r=e.sum(t,n)/t.length;return Number.isNaN(r)?void 0:r}catch{return}}exports.average=t;
+//# sourceMappingURL=average.cjs.map

package/dist/math/average.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"average.cjs","names":[],"sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * ```\n *\n * @param array - The array to average.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The average, or `undefined` if the array is empty or contains non-numeric values.\n */\nexport function average<T>(array: T[], callback?: (item: T) => number): number | undefined {\n  if (array.length === 0) return undefined;\n\n  try {\n    const result = sum(array, callback) / array.length;\n\n    return Number.isNaN(result) ? undefined : result;\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"6BAgBA,SAAgB,EAAW,EAAY,EAAoD,CACrF,KAAM,SAAW,EAErB,GAAI,CACF,IAAM,EAAS,EAAA,IAAI,EAAO,CAAQ,EAAI,EAAM,OAE5C,OAAO,OAAO,MAAM,CAAM,EAAI,IAAA,GAAY,CAC5C,MAAQ,CACN,MACF,CACF"}

package/dist/math/average.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Calculates the average of an array of numbers.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * average(arr); // 3
+ * average(arr, (num) => num * 2); // 6
+ * ```
+ *
+ * @param array - The array to average.
+ * @param callback - (optional) A callback function to map each item to a number.
+ * @returns The average, or `undefined` if the array is empty or contains non-numeric values.
+ */
+export declare function average<T>(array: T[], callback?: (item: T) => number): number | undefined;
+//# sourceMappingURL=average.d.ts.map

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

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

package/dist/math/average.js

@@ -0,0 +1,14 @@
+import { sum as e } from "./sum.js";
+//#region src/math/average.ts
+function t(t, n) {
+	if (t.length !== 0) try {
+		let r = e(t, n) / t.length;
+		return Number.isNaN(r) ? void 0 : r;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { t as average };
+
+//# sourceMappingURL=average.js.map

package/dist/math/average.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"average.js","names":[],"sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * ```\n *\n * @param array - The array to average.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The average, or `undefined` if the array is empty or contains non-numeric values.\n */\nexport function average<T>(array: T[], callback?: (item: T) => number): number | undefined {\n  if (array.length === 0) return undefined;\n\n  try {\n    const result = sum(array, callback) / array.length;\n\n    return Number.isNaN(result) ? undefined : result;\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":";;AAgBA,SAAgB,EAAW,GAAY,GAAoD;CACrF,MAAM,WAAW,GAErB,IAAI;EACF,IAAM,IAAS,EAAI,GAAO,CAAQ,IAAI,EAAM;EAE5C,OAAO,OAAO,MAAM,CAAM,IAAI,KAAA,IAAY;CAC5C,QAAQ;EACN;CACF;AACF"}

package/dist/math/clamp.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){return t!=null&&e<t?t:n!=null&&e>n?n:e}exports.clamp=e;
+//# sourceMappingURL=clamp.cjs.map

package/dist/math/clamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.cjs","names":[],"sources":["../../src/math/clamp.ts"],"sourcesContent":["/**\n * Restricts a number to be within a specified range.\n * Both `min` and `max` are optional — omitting one leaves that end unconstrained.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10)  // 5  — within range\n * clamp(0, 1, 10)  // 1  — below min\n * clamp(15, 1, 10) // 10 — above max\n * clamp(15, 1)     // 15 — no max, above min\n * clamp(-5, undefined, 0) // -5 — no min, below max\n * ```\n *\n * @param n   - The number to clamp.\n * @param min - Optional lower bound (inclusive).\n * @param max - Optional upper bound (inclusive).\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min?: number, max?: number): number {\n  if (min != null && n < min) return min;\n\n  if (max != null && n > max) return max;\n\n  return n;\n}\n"],"mappings":"AAmBA,SAAgB,EAAM,EAAW,EAAc,EAAsB,CAKnE,OAJI,GAAO,MAAQ,EAAI,EAAY,EAE/B,GAAO,MAAQ,EAAI,EAAY,EAE5B,CACT"}

package/dist/math/clamp.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Restricts a number to be within a specified range.
+ * Both `min` and `max` are optional — omitting one leaves that end unconstrained.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 1, 10)  // 5  — within range
+ * clamp(0, 1, 10)  // 1  — below min
+ * clamp(15, 1, 10) // 10 — above max
+ * clamp(15, 1)     // 15 — no max, above min
+ * clamp(-5, undefined, 0) // -5 — no min, below max
+ * ```
+ *
+ * @param n   - The number to clamp.
+ * @param min - Optional lower bound (inclusive).
+ * @param max - Optional upper bound (inclusive).
+ *
+ * @returns The clamped number.
+ */
+export declare function clamp(n: number, min?: number, max?: number): number;
+//# sourceMappingURL=clamp.d.ts.map

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

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

package/dist/math/clamp.js

@@ -0,0 +1,8 @@
+//#region src/math/clamp.ts
+function e(e, t, n) {
+	return t != null && e < t ? t : n != null && e > n ? n : e;
+}
+//#endregion
+export { e as clamp };
+
+//# sourceMappingURL=clamp.js.map

package/dist/math/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.js","names":[],"sources":["../../src/math/clamp.ts"],"sourcesContent":["/**\n * Restricts a number to be within a specified range.\n * Both `min` and `max` are optional — omitting one leaves that end unconstrained.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10)  // 5  — within range\n * clamp(0, 1, 10)  // 1  — below min\n * clamp(15, 1, 10) // 10 — above max\n * clamp(15, 1)     // 15 — no max, above min\n * clamp(-5, undefined, 0) // -5 — no min, below max\n * ```\n *\n * @param n   - The number to clamp.\n * @param min - Optional lower bound (inclusive).\n * @param max - Optional upper bound (inclusive).\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min?: number, max?: number): number {\n  if (min != null && n < min) return min;\n\n  if (max != null && n > max) return max;\n\n  return n;\n}\n"],"mappings":";AAmBA,SAAgB,EAAM,GAAW,GAAc,GAAsB;CAKnE,OAJI,KAAO,QAAQ,IAAI,IAAY,IAE/B,KAAO,QAAQ,IAAI,IAAY,IAE5B;AACT"}

package/dist/math/gcd.cjs

@@ -0,0 +1,2 @@
+function e(e,t){let n=Math.abs(e),r=Math.abs(t);for(;r!==0;){let e=r;r=n%r,n=e}return n}exports.gcd=e;
+//# sourceMappingURL=gcd.cjs.map

package/dist/math/gcd.cjs.map

@@ -0,0 +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  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,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.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Computes the greatest common divisor of two integers using the Euclidean algorithm.
+ * The sign of the inputs is ignored — the result is always non-negative.
+ *
+ * @example
+ * ```ts
+ * gcd(12, 18); // 6
+ * gcd(-12, 18); // 6
+ * gcd(0, 5); // 5
+ * gcd(0, 0); // 0
+ * ```
+ *
+ * @param a - The first integer.
+ * @param b - The second integer.
+ * @returns The greatest common divisor of `a` and `b`.
+ */
+export declare function gcd(a: number, b: number): number;
+//# sourceMappingURL=gcd.d.ts.map

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

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

package/dist/math/gcd.js

@@ -0,0 +1,13 @@
+//#region src/math/gcd.ts
+function e(e, t) {
+	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 };
+
+//# sourceMappingURL=gcd.js.map

package/dist/math/gcd.js.map

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

package/dist/math/index.d.ts

@@ -0,0 +1,20 @@
+export * from './abs';
+export * from './allocate';
+export * from './average';
+export * from './clamp';
+export * from './gcd';
+export * from './lcm';
+export * from './lerp';
+export * from './linspace';
+export * from './max';
+export * from './median';
+export * from './min';
+export * from './mod';
+export * from './normalize';
+export * from './percent';
+export * from './range';
+export * from './round';
+export * from './standardDeviation';
+export * from './sum';
+export * from './variance';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/math/lcm.cjs

@@ -0,0 +1,2 @@
+const e=require("./gcd.cjs");function t(t,n){return t===0||n===0?0:Math.abs(t*n)/e.gcd(t,n)}exports.lcm=t;
+//# sourceMappingURL=lcm.cjs.map

package/dist/math/lcm.cjs.map

@@ -0,0 +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  if (a === 0 || b === 0) return 0;\n\n  return Math.abs(a * b) / gcd(a, b);\n}\n"],"mappings":"6BAeA,SAAgB,EAAI,EAAW,EAAmB,CAGhD,OAFI,IAAM,GAAK,IAAM,EAAU,EAExB,KAAK,IAAI,EAAI,CAAC,EAAI,EAAA,IAAI,EAAG,CAAC,CACnC"}

package/dist/math/lcm.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Computes the least common multiple of two integers.
+ *
+ * @example
+ * ```ts
+ * lcm(4, 6); // 12
+ * lcm(0, 5); // 0
+ * ```
+ *
+ * @param a - The first integer.
+ * @param b - The second integer.
+ * @returns The least common multiple of `a` and `b`, or `0` if either is `0`.
+ */
+export declare function lcm(a: number, b: number): number;
+//# sourceMappingURL=lcm.d.ts.map

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

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

package/dist/math/lcm.js

@@ -0,0 +1,9 @@
+import { gcd as e } from "./gcd.js";
+//#region src/math/lcm.ts
+function t(t, n) {
+	return t === 0 || n === 0 ? 0 : Math.abs(t * n) / e(t, n);
+}
+//#endregion
+export { t as lcm };
+
+//# sourceMappingURL=lcm.js.map

package/dist/math/lcm.js.map

@@ -0,0 +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  if (a === 0 || b === 0) return 0;\n\n  return Math.abs(a * b) / gcd(a, b);\n}\n"],"mappings":";;AAeA,SAAgB,EAAI,GAAW,GAAmB;CAGhD,OAFI,MAAM,KAAK,MAAM,IAAU,IAExB,KAAK,IAAI,IAAI,CAAC,IAAI,EAAI,GAAG,CAAC;AACnC"}

package/dist/math/lerp.cjs

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

package/dist/math/lerp.cjs.map

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

package/dist/math/lerp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Linearly interpolates between `a` and `b` by factor `t`. `t` is not clamped, so values
+ * outside `[0, 1]` extrapolate beyond the `[a, b]` range.
+ *
+ * @example
+ * ```ts
+ * lerp(0, 10, 0.5); // 5
+ * lerp(0, 10, 1.5); // 15 (extrapolated — t is not clamped)
+ * ```
+ *
+ * @param a - The start value (returned when `t` is `0`).
+ * @param b - The end value (returned when `t` is `1`).
+ * @param t - The interpolation factor.
+ * @returns The interpolated value.
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+//# sourceMappingURL=lerp.d.ts.map

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

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

package/dist/math/lerp.js

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

package/dist/math/lerp.js.map

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

package/dist/math/linspace.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n=5){if(n<=0)return[];if(n===1)return[e];let r=(t-e)/(n-1);return Array.from({length:n},(t,n)=>e+n*r)}exports.linspace=e;
+//# sourceMappingURL=linspace.cjs.map

package/dist/math/linspace.cjs.map

@@ -0,0 +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 (steps <= 0) return [];\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,GAAS,EAAG,MAAO,CAAC,EAExB,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.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates an array of evenly-spaced numbers from `start` to `end`.
+ *
+ * @example
+ * ```ts
+ * linspace(0, 10);        // [0, 2.5, 5, 7.5, 10]
+ * linspace(0, 10, 3);     // [0, 5, 10]
+ * linspace(0, 10, 1);     // [0]
+ * linspace(10, 0, 5);     // [10, 7.5, 5, 2.5, 0]
+ * ```
+ *
+ * @param start - The start of the range.
+ * @param end - The end of the range.
+ * @param steps - Number of evenly-spaced points to generate (default: 5).
+ *
+ * @returns An array of `steps` numbers from `start` to `end`.
+ */
+export declare function linspace(start: number, end: number, steps?: number): number[];
+//# sourceMappingURL=linspace.d.ts.map

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

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

package/dist/math/linspace.js

@@ -0,0 +1,11 @@
+//#region src/math/linspace.ts
+function e(e, t, n = 5) {
+	if (n <= 0) return [];
+	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 };
+
+//# sourceMappingURL=linspace.js.map

package/dist/math/linspace.js.map

@@ -0,0 +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 (steps <= 0) return [];\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,KAAS,GAAG,OAAO,CAAC;CAExB,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"}

package/dist/math/max.cjs

@@ -0,0 +1,2 @@
+const e=require("../array/compare.cjs");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.compare(r(t[n]),r(i))>0&&(i=t[n]);return i}exports.max=t;
+//# sourceMappingURL=max.cjs.map

package/dist/math/max.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"max.cjs","names":[],"sources":["../../src/math/max.ts"],"sourcesContent":["import { compare } from '../array/compare';\n\n/**\n * Finds the maximum item in an array.\n *\n * @description\n * This function can be used to find the maximum number, string, or any other type of item in an array.\n *\n * @example\n * ```ts\n * max([1, 2, 3]); // 3\n * max([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 3\n * max(['apple', 'banana', 'cherry']); // 'cherry'\n * max([new Date('2023-01-01'), new Date('2022-01-01')]); // 2023-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 maximum value as determined by the callback function.\n */\nexport function max<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":"wCAqBA,SAAgB,EAAO,EAAY,EAA+D,CAChG,GAAI,EAAM,SAAW,EAAG,OAExB,IAAM,EAAK,IAAc,GAAY,GACjC,EAAU,EAAM,GAEpB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,IAC5B,EAAA,QAAQ,EAAG,EAAM,EAAE,EAAG,EAAG,CAAO,CAAC,EAAI,IACvC,EAAU,EAAM,IAIpB,OAAO,CACT"}

package/dist/math/max.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Finds the maximum item in an array.
+ *
+ * @description
+ * This function can be used to find the maximum number, string, or any other type of item in an array.
+ *
+ * @example
+ * ```ts
+ * max([1, 2, 3]); // 3
+ * max([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 3
+ * max(['apple', 'banana', 'cherry']); // 'cherry'
+ * max([new Date('2023-01-01'), new Date('2022-01-01')]); // 2023-01-01
+ * ```
+ *
+ * @param array - The array to be searched.
+ * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.
+ *
+ * @return The item with the maximum value as determined by the callback function.
+ */
+export declare function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined;
+//# sourceMappingURL=max.d.ts.map

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

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

package/dist/math/max.js

@@ -0,0 +1,12 @@
+import { compare as e } from "../array/compare.js";
+//#region src/math/max.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 max };
+
+//# sourceMappingURL=max.js.map

package/dist/math/max.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"max.js","names":[],"sources":["../../src/math/max.ts"],"sourcesContent":["import { compare } from '../array/compare';\n\n/**\n * Finds the maximum item in an array.\n *\n * @description\n * This function can be used to find the maximum number, string, or any other type of item in an array.\n *\n * @example\n * ```ts\n * max([1, 2, 3]); // 3\n * max([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 3\n * max(['apple', 'banana', 'cherry']); // 'cherry'\n * max([new Date('2023-01-01'), new Date('2022-01-01')]); // 2023-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 maximum value as determined by the callback function.\n */\nexport function max<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/median.cjs

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

package/dist/math/median.cjs.map

@@ -0,0 +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: 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,EAAU,EAAoD,CACtF,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.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the median of an array of numbers.
+ *
+ * @example
+ * ```ts
+ * median([1, 2, 3, 4, 100]); // 3
+ * median([1, 2, 3, 4, 5], (n) => n * 2); // 6
+ * median([]); // undefined
+ * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5
+ * ```
+ *
+ * @param arr - The array of numbers.
+ * @param callback - (optional) A callback function to map each item to a number.
+ * @returns The median, or `undefined` if the array is empty.
+ */
+export declare function median<T>(arr: T[], callback?: (item: T) => number): number | undefined;
+//# sourceMappingURL=median.d.ts.map

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

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

package/dist/math/median.js

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

package/dist/math/median.js.map

@@ -0,0 +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: 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,GAAU,GAAoD;CACtF,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"}

package/dist/math/min.cjs

@@ -0,0 +1,2 @@
+const e=require("../array/compare.cjs");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.compare(r(t[n]),r(i))<0&&(i=t[n]);return i}exports.min=t;
+//# sourceMappingURL=min.cjs.map

package/dist/math/min.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"min.cjs","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":"wCAqBA,SAAgB,EAAO,EAAY,EAA+D,CAChG,GAAI,EAAM,SAAW,EAAG,OAExB,IAAM,EAAK,IAAc,GAAY,GACjC,EAAU,EAAM,GAEpB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,IAC5B,EAAA,QAAQ,EAAG,EAAM,EAAE,EAAG,EAAG,CAAO,CAAC,EAAI,IACvC,EAAU,EAAM,IAIpB,OAAO,CACT"}

package/dist/math/min.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Finds the minimum item in an array.
+ *
+ * @description
+ * This function can be used to find the minimum number, string, or any other type of item in an array.
+ *
+ * @example
+ * ```ts
+ * min([1, 2, 3]); // 1
+ * min([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 1
+ * min(['apple', 'banana', 'cherry']); // 'apple'
+ * min([new Date('2023-01-01'), new Date('2022-01-01')]); // 2022-01-01
+ * ```
+ *
+ * @param array - The array to be searched.
+ * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.
+ *
+ * @return The item with the minimum value as determined by the callback function.
+ */
+export declare function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined;
+//# sourceMappingURL=min.d.ts.map

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

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