@vielzeug/toolkit 1.1.3 → 2.0.0

package/dist/math/average.js.map

@@ -1 +1 @@
-{"version":3,"file":"average.js","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n\n  // Check if we are dealing with Dates (either directly or via callback)\n  const firstItem = callback ? callback(array[0]) : array[0];\n  const isDate = firstItem instanceof Date;\n\n  if (isDate) {\n    const totalTimestamp = array.reduce<number>((acc, item) => {\n      const val = callback ? callback(item) : item;\n      if (!(val instanceof Date)) {\n        throw new TypeError('average expected all items to be Date objects');\n      }\n      return acc + val.getTime();\n    }, 0);\n    return new Date(totalTimestamp / array.length);\n  }\n\n  // Handle numbers\n  try {\n    const total = sum(array, callback as (item: T) => number);\n    if (typeof total === 'number') {\n      return total / array.length;\n    }\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n\n  return undefined;\n}\n"],"names":["average","array","callback","totalTimestamp","acc","item","val","total","sum","err"],"mappings":";AAkBO,SAASA,EAAWC,GAAYC,GAAkE;AACvG,MAAID,EAAM,WAAW,EAAG;AAMxB,OAHkBC,IAAWA,EAASD,EAAM,CAAC,CAAC,IAAIA,EAAM,CAAC,cACrB,MAExB;AACV,UAAME,IAAiBF,EAAM,OAAe,CAACG,GAAKC,MAAS;AACzD,YAAMC,IAAMJ,IAAWA,EAASG,CAAI,IAAIA;AACxC,UAAI,EAAEC,aAAe;AACnB,cAAM,IAAI,UAAU,+CAA+C;AAErE,aAAOF,IAAME,EAAI,QAAA;AAAA,IACnB,GAAG,CAAC;AACJ,WAAO,IAAI,KAAKH,IAAiBF,EAAM,MAAM;AAAA,EAC/C;AAGA,MAAI;AACF,UAAMM,IAAQC,EAAIP,GAAOC,CAA+B;AACxD,QAAI,OAAOK,KAAU;AACnB,aAAOA,IAAQN,EAAM;AAAA,EAEzB,SAASQ,GAAK;AACZ,QAAIA,aAAe,UAAW;AAC9B,UAAMA;AAAA,EACR;AAGF;"}
+{"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;AACrF,OAAM,WAAW,EAErB,KAAI;EACF,IAAM,IAAS,EAAI,GAAO,EAAS,GAAG,EAAM;AAE5C,SAAO,OAAO,MAAM,EAAO,GAAG,KAAA,IAAY;SACpC;AACN"}

package/dist/math/clamp.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function n(t,e,a){return Math.min(Math.max(t,e),a)}exports.clamp=n;
-//# sourceMappingURL=clamp.cjs.map
+function e(e,t,n){return Math.min(Math.max(e,t),n)}exports.clamp=e;
+//# sourceMappingURL=clamp.cjs.map

package/dist/math/clamp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"clamp.cjs","sources":["../../src/math/clamp.ts"],"sourcesContent":["/**\n * The `clamp` function restricts a number to be within a specified range.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10) // 5\n * clamp(0, 1, 10) // 1\n * clamp(15, 1, 10) // 10\n * ```\n *\n * @param n - The number to be clamped.\n * @param min - The minimum value of the range.\n * @param max - The maximum value of the range.\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.min(Math.max(n, min), max);\n}\n"],"names":["clamp","n","min","max"],"mappings":"gFAgBO,SAASA,EAAMC,EAAWC,EAAaC,EAAqB,CACjE,OAAO,KAAK,IAAI,KAAK,IAAIF,EAAGC,CAAG,EAAGC,CAAG,CACvC"}
+{"version":3,"file":"clamp.cjs","names":[],"sources":["../../src/math/clamp.ts"],"sourcesContent":["/**\n * The `clamp` function restricts a number to be within a specified range.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10) // 5\n * clamp(0, 1, 10) // 1\n * clamp(15, 1, 10) // 10\n * ```\n *\n * @param n - The number to be clamped.\n * @param min - The minimum value of the range.\n * @param max - The maximum value of the range.\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.min(Math.max(n, min), max);\n}\n"],"mappings":"AAgBA,SAAgB,EAAM,EAAW,EAAa,EAAqB,CACjE,OAAO,KAAK,IAAI,KAAK,IAAI,EAAG,EAAI,CAAE,EAAI"}

package/dist/math/clamp.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The `clamp` function restricts a number to be within a specified range.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 1, 10) // 5
+ * clamp(0, 1, 10) // 1
+ * clamp(15, 1, 10) // 10
+ * ```
+ *
+ * @param n - The number to be clamped.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ *
+ * @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;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/dist/math/clamp.js

@@ -1,7 +1,8 @@
-function m(t, a, n) {
-  return Math.min(Math.max(t, a), n);
+//#region src/math/clamp.ts
+function e(e, t, n) {
+	return Math.min(Math.max(e, t), n);
 }
-export {
-  m as clamp
-};
-//# sourceMappingURL=clamp.js.map
+//#endregion
+export { e as clamp };
+
+//# sourceMappingURL=clamp.js.map

package/dist/math/clamp.js.map

@@ -1 +1 @@
-{"version":3,"file":"clamp.js","sources":["../../src/math/clamp.ts"],"sourcesContent":["/**\n * The `clamp` function restricts a number to be within a specified range.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10) // 5\n * clamp(0, 1, 10) // 1\n * clamp(15, 1, 10) // 10\n * ```\n *\n * @param n - The number to be clamped.\n * @param min - The minimum value of the range.\n * @param max - The maximum value of the range.\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.min(Math.max(n, min), max);\n}\n"],"names":["clamp","n","min","max"],"mappings":"AAgBO,SAASA,EAAMC,GAAWC,GAAaC,GAAqB;AACjE,SAAO,KAAK,IAAI,KAAK,IAAIF,GAAGC,CAAG,GAAGC,CAAG;AACvC;"}
+{"version":3,"file":"clamp.js","names":[],"sources":["../../src/math/clamp.ts"],"sourcesContent":["/**\n * The `clamp` function restricts a number to be within a specified range.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10) // 5\n * clamp(0, 1, 10) // 1\n * clamp(15, 1, 10) // 10\n * ```\n *\n * @param n - The number to be clamped.\n * @param min - The minimum value of the range.\n * @param max - The maximum value of the range.\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.min(Math.max(n, min), max);\n}\n"],"mappings":";AAgBA,SAAgB,EAAM,GAAW,GAAa,GAAqB;AACjE,QAAO,KAAK,IAAI,KAAK,IAAI,GAAG,EAAI,EAAE,EAAI"}

package/dist/math/distribute.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function c(r,e){if(e<1)throw new Error("Parts must be at least 1");if(typeof r=="bigint"){const t=r/BigInt(e),b=r%BigInt(e),o=[];for(let n=0;n<e;n++)o.push(n<Number(b)?t+1n:t);return o}const i=Math.floor(r/e),u=r-i*e,s=[];for(let t=0;t<e;t++)s.push(t<u?i+1:i);return s}exports.distribute=c;
-//# sourceMappingURL=distribute.cjs.map
+function e(e,t){if(t<1)throw Error(`Parts must be at least 1`);if(typeof e==`bigint`){let n=e/BigInt(t),r=e%BigInt(t),i=[];for(let e=0;e<t;e++)i.push(BigInt(e)<r?n+1n:n);return i}let n=Math.floor(e/t),r=e-n*t;return Array.from({length:t},(e,t)=>t<r?n+1:n)}exports.distribute=e;
+//# sourceMappingURL=distribute.cjs.map

package/dist/math/distribute.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"distribute.cjs","sources":["../../src/math/distribute.ts"],"sourcesContent":["/**\n * Distributes an amount evenly among N parties.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Useful for splitting bills, costs, or payments equally.\n *\n * @example\n * ```ts\n * // Split $100 among 3 people\n * distribute(100, 3);\n * // [34, 33, 33] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * distribute(10000n, 3);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to distribute\n * @param parts - Number of parts to divide into\n * @returns Array of distributed amounts (a sum equals original amount)\n * @throws {Error} If parts are less than 1\n */\nexport function distribute(amount: number, parts: number): number[];\nexport function distribute(amount: bigint, parts: number): bigint[];\nexport function distribute(amount: number | bigint, parts: number): (number | bigint)[] {\n  if (parts < 1) {\n    throw new Error('Parts must be at least 1');\n  }\n\n  if (typeof amount === 'bigint') {\n    const baseShare = amount / BigInt(parts);\n    const remainder = amount % BigInt(parts);\n    const results: bigint[] = [];\n\n    for (let i = 0; i < parts; i++) {\n      // Distribute the remainder to first items\n      results.push(i < Number(remainder) ? baseShare + 1n : baseShare);\n    }\n\n    return results;\n  }\n\n  // Handle number type\n  const baseShare = Math.floor(amount / parts);\n  const remainder = amount - baseShare * parts;\n  const results: number[] = [];\n\n  for (let i = 0; i < parts; i++) {\n    // Distribute the remainder to first items\n    results.push(i < remainder ? baseShare + 1 : baseShare);\n  }\n\n  return results;\n}\n"],"names":["distribute","amount","parts","baseShare","remainder","results","i"],"mappings":"gFAuBO,SAASA,EAAWC,EAAyBC,EAAoC,CACtF,GAAIA,EAAQ,EACV,MAAM,IAAI,MAAM,0BAA0B,EAG5C,GAAI,OAAOD,GAAW,SAAU,CAC9B,MAAME,EAAYF,EAAS,OAAOC,CAAK,EACjCE,EAAYH,EAAS,OAAOC,CAAK,EACjCG,EAAoB,CAAA,EAE1B,QAASC,EAAI,EAAGA,EAAIJ,EAAOI,IAEzBD,EAAQ,KAAKC,EAAI,OAAOF,CAAS,EAAID,EAAY,GAAKA,CAAS,EAGjE,OAAOE,CACT,CAGA,MAAMF,EAAY,KAAK,MAAMF,EAASC,CAAK,EACrCE,EAAYH,EAASE,EAAYD,EACjCG,EAAoB,CAAA,EAE1B,QAASC,EAAI,EAAGA,EAAIJ,EAAOI,IAEzBD,EAAQ,KAAKC,EAAIF,EAAYD,EAAY,EAAIA,CAAS,EAGxD,OAAOE,CACT"}
+{"version":3,"file":"distribute.cjs","names":[],"sources":["../../src/math/distribute.ts"],"sourcesContent":["/**\n * Distributes an amount evenly among N parties.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Useful for splitting bills, costs, or payments equally.\n *\n * @example\n * ```ts\n * // Split $100 among 3 people\n * distribute(100, 3);\n * // [34, 33, 33] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * distribute(10000n, 3);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to distribute\n * @param parts - Number of parts to divide into\n * @returns Array of distributed amounts (a sum equals original amount)\n * @throws {Error} If parts are less than 1\n */\nexport function distribute(amount: number, parts: number): number[];\nexport function distribute(amount: bigint, parts: number): bigint[];\nexport function distribute(amount: number | bigint, parts: number): (number | bigint)[] {\n  if (parts < 1) {\n    throw new Error('Parts must be at least 1');\n  }\n\n  if (typeof amount === 'bigint') {\n    const baseShare = amount / BigInt(parts);\n    const remainder = amount % BigInt(parts);\n    const results: bigint[] = [];\n\n    for (let i = 0; i < parts; i++) {\n      // Distribute the remainder to first items\n      results.push(BigInt(i) < remainder ? baseShare + 1n : baseShare);\n    }\n\n    return results;\n  }\n\n  // Handle number type\n  const baseShare = Math.floor(amount / parts);\n  const remainder = amount - baseShare * parts;\n\n  return Array.from({ length: parts }, (_, i) => (i < remainder ? baseShare + 1 : baseShare));\n}\n"],"mappings":"AAuBA,SAAgB,EAAW,EAAyB,EAAoC,CACtF,GAAI,EAAQ,EACV,MAAU,MAAM,2BAA2B,CAG7C,GAAI,OAAO,GAAW,SAAU,CAC9B,IAAM,EAAY,EAAS,OAAO,EAAM,CAClC,EAAY,EAAS,OAAO,EAAM,CAClC,EAAoB,EAAE,CAE5B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IAEzB,EAAQ,KAAK,OAAO,EAAE,CAAG,EAAY,EAAY,GAAK,EAAU,CAGlE,OAAO,EAIT,IAAM,EAAY,KAAK,MAAM,EAAS,EAAM,CACtC,EAAY,EAAS,EAAY,EAEvC,OAAO,MAAM,KAAK,CAAE,OAAQ,EAAO,EAAG,EAAG,IAAO,EAAI,EAAY,EAAY,EAAI,EAAW"}

package/dist/math/distribute.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Distributes an amount evenly among N parties.
+ * Handles rounding to ensure the sum equals the original amount exactly.
+ * Useful for splitting bills, costs, or payments equally.
+ *
+ * @example
+ * ```ts
+ * // Split $100 among 3 people
+ * distribute(100, 3);
+ * // [34, 33, 33] - sum is exactly 100
+ *
+ * // Split with bigint (e.g., cents)
+ * distribute(10000n, 3);
+ * // [3334n, 3333n, 3333n] - sum is exactly 10000n
+ * ```
+ *
+ * @param amount - Total amount to distribute
+ * @param parts - Number of parts to divide into
+ * @returns Array of distributed amounts (a sum equals original amount)
+ * @throws {Error} If parts are less than 1
+ */
+export declare function distribute(amount: number, parts: number): number[];
+export declare function distribute(amount: bigint, parts: number): bigint[];
+//# sourceMappingURL=distribute.d.ts.map

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

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

package/dist/math/distribute.js

@@ -1,18 +1,15 @@
-function b(t, e) {
-  if (e < 1)
-    throw new Error("Parts must be at least 1");
-  if (typeof t == "bigint") {
-    const r = t / BigInt(e), f = t % BigInt(e), o = [];
-    for (let n = 0; n < e; n++)
-      o.push(n < Number(f) ? r + 1n : r);
-    return o;
-  }
-  const i = Math.floor(t / e), c = t - i * e, s = [];
-  for (let r = 0; r < e; r++)
-    s.push(r < c ? i + 1 : i);
-  return s;
+//#region src/math/distribute.ts
+function e(e, t) {
+	if (t < 1) throw Error("Parts must be at least 1");
+	if (typeof e == "bigint") {
+		let n = e / BigInt(t), r = e % BigInt(t), i = [];
+		for (let e = 0; e < t; e++) i.push(BigInt(e) < r ? n + 1n : n);
+		return i;
+	}
+	let n = Math.floor(e / t), r = e - n * t;
+	return Array.from({ length: t }, (e, t) => t < r ? n + 1 : n);
 }
-export {
-  b as distribute
-};
-//# sourceMappingURL=distribute.js.map
+//#endregion
+export { e as distribute };
+
+//# sourceMappingURL=distribute.js.map

package/dist/math/distribute.js.map

@@ -1 +1 @@
-{"version":3,"file":"distribute.js","sources":["../../src/math/distribute.ts"],"sourcesContent":["/**\n * Distributes an amount evenly among N parties.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Useful for splitting bills, costs, or payments equally.\n *\n * @example\n * ```ts\n * // Split $100 among 3 people\n * distribute(100, 3);\n * // [34, 33, 33] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * distribute(10000n, 3);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to distribute\n * @param parts - Number of parts to divide into\n * @returns Array of distributed amounts (a sum equals original amount)\n * @throws {Error} If parts are less than 1\n */\nexport function distribute(amount: number, parts: number): number[];\nexport function distribute(amount: bigint, parts: number): bigint[];\nexport function distribute(amount: number | bigint, parts: number): (number | bigint)[] {\n  if (parts < 1) {\n    throw new Error('Parts must be at least 1');\n  }\n\n  if (typeof amount === 'bigint') {\n    const baseShare = amount / BigInt(parts);\n    const remainder = amount % BigInt(parts);\n    const results: bigint[] = [];\n\n    for (let i = 0; i < parts; i++) {\n      // Distribute the remainder to first items\n      results.push(i < Number(remainder) ? baseShare + 1n : baseShare);\n    }\n\n    return results;\n  }\n\n  // Handle number type\n  const baseShare = Math.floor(amount / parts);\n  const remainder = amount - baseShare * parts;\n  const results: number[] = [];\n\n  for (let i = 0; i < parts; i++) {\n    // Distribute the remainder to first items\n    results.push(i < remainder ? baseShare + 1 : baseShare);\n  }\n\n  return results;\n}\n"],"names":["distribute","amount","parts","baseShare","remainder","results","i"],"mappings":"AAuBO,SAASA,EAAWC,GAAyBC,GAAoC;AACtF,MAAIA,IAAQ;AACV,UAAM,IAAI,MAAM,0BAA0B;AAG5C,MAAI,OAAOD,KAAW,UAAU;AAC9B,UAAME,IAAYF,IAAS,OAAOC,CAAK,GACjCE,IAAYH,IAAS,OAAOC,CAAK,GACjCG,IAAoB,CAAA;AAE1B,aAASC,IAAI,GAAGA,IAAIJ,GAAOI;AAEzBD,MAAAA,EAAQ,KAAKC,IAAI,OAAOF,CAAS,IAAID,IAAY,KAAKA,CAAS;AAGjE,WAAOE;AAAAA,EACT;AAGA,QAAMF,IAAY,KAAK,MAAMF,IAASC,CAAK,GACrCE,IAAYH,IAASE,IAAYD,GACjCG,IAAoB,CAAA;AAE1B,WAASC,IAAI,GAAGA,IAAIJ,GAAOI;AAEzB,IAAAD,EAAQ,KAAKC,IAAIF,IAAYD,IAAY,IAAIA,CAAS;AAGxD,SAAOE;AACT;"}
+{"version":3,"file":"distribute.js","names":[],"sources":["../../src/math/distribute.ts"],"sourcesContent":["/**\n * Distributes an amount evenly among N parties.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Useful for splitting bills, costs, or payments equally.\n *\n * @example\n * ```ts\n * // Split $100 among 3 people\n * distribute(100, 3);\n * // [34, 33, 33] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * distribute(10000n, 3);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to distribute\n * @param parts - Number of parts to divide into\n * @returns Array of distributed amounts (a sum equals original amount)\n * @throws {Error} If parts are less than 1\n */\nexport function distribute(amount: number, parts: number): number[];\nexport function distribute(amount: bigint, parts: number): bigint[];\nexport function distribute(amount: number | bigint, parts: number): (number | bigint)[] {\n  if (parts < 1) {\n    throw new Error('Parts must be at least 1');\n  }\n\n  if (typeof amount === 'bigint') {\n    const baseShare = amount / BigInt(parts);\n    const remainder = amount % BigInt(parts);\n    const results: bigint[] = [];\n\n    for (let i = 0; i < parts; i++) {\n      // Distribute the remainder to first items\n      results.push(BigInt(i) < remainder ? baseShare + 1n : baseShare);\n    }\n\n    return results;\n  }\n\n  // Handle number type\n  const baseShare = Math.floor(amount / parts);\n  const remainder = amount - baseShare * parts;\n\n  return Array.from({ length: parts }, (_, i) => (i < remainder ? baseShare + 1 : baseShare));\n}\n"],"mappings":";AAuBA,SAAgB,EAAW,GAAyB,GAAoC;AACtF,KAAI,IAAQ,EACV,OAAU,MAAM,2BAA2B;AAG7C,KAAI,OAAO,KAAW,UAAU;EAC9B,IAAM,IAAY,IAAS,OAAO,EAAM,EAClC,IAAY,IAAS,OAAO,EAAM,EAClC,IAAoB,EAAE;AAE5B,OAAK,IAAI,IAAI,GAAG,IAAI,GAAO,IAEzB,GAAQ,KAAK,OAAO,EAAE,GAAG,IAAY,IAAY,KAAK,EAAU;AAGlE,SAAO;;CAIT,IAAM,IAAY,KAAK,MAAM,IAAS,EAAM,EACtC,IAAY,IAAS,IAAY;AAEvC,QAAO,MAAM,KAAK,EAAE,QAAQ,GAAO,GAAG,GAAG,MAAO,IAAI,IAAY,IAAY,IAAI,EAAW"}

package/dist/math/index.d.ts

@@ -0,0 +1,14 @@
+export * from './abs';
+export * from './allocate';
+export * from './average';
+export * from './clamp';
+export * from './distribute';
+export * from './linspace';
+export * from './max';
+export * from './median';
+export * from './min';
+export * from './percent';
+export * from './range';
+export * from './round';
+export * from './sum';
+//# 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,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

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,EAAE,CAEzB,GAAI,IAAU,EAAG,MAAO,CAAC,EAAM,CAE/B,IAAM,GAAY,EAAM,IAAU,EAAQ,GAE1C,OAAO,MAAM,KAAK,CAAE,OAAQ,EAAO,EAAG,EAAG,IAAM,EAAQ,EAAI,EAAS"}

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;AACxE,KAAI,KAAS,EAAG,QAAO,EAAE;AAEzB,KAAI,MAAU,EAAG,QAAO,CAAC,EAAM;CAE/B,IAAM,KAAY,IAAM,MAAU,IAAQ;AAE1C,QAAO,MAAM,KAAK,EAAE,QAAQ,GAAO,GAAG,GAAG,MAAM,IAAQ,IAAI,EAAS"}

package/dist/math/max.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../function/compare.cjs"),u=require("./boil.cjs");function a(t,n){return u.boil(t,(e,r)=>{const o=n||(c=>c);return i.compare(o(e),o(r))>0?e:r})}exports.max=a;
-//# sourceMappingURL=max.cjs.map
+const e=require(`../array/fold.cjs`),t=require(`../function/compare.cjs`);function n(n,r){let i=r??(e=>e);return e.fold(n,(e,n)=>t.compare(i(e),i(n))>0?e:n)}exports.max=n;
+//# sourceMappingURL=max.cjs.map

package/dist/math/max.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"max.cjs","sources":["../../src/math/max.ts"],"sourcesContent":["import { compare } from '../function/compare';\nimport { boil } from './boil';\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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  return boil(array, (a, b) => {\n    const fn = callback || ((item: T) => item);\n    return compare(fn(a), fn(b)) > 0 ? a : b;\n  });\n}\n"],"names":["max","array","callback","boil","a","b","fn","item","compare"],"mappings":"mJAwBO,SAASA,EAAOC,EAAYC,EAA+D,CAChG,OAAOC,OAAKF,EAAO,CAACG,EAAGC,IAAM,CAC3B,MAAMC,EAAKJ,IAAcK,GAAYA,GACrC,OAAOC,EAAAA,QAAQF,EAAGF,CAAC,EAAGE,EAAGD,CAAC,CAAC,EAAI,EAAID,EAAIC,CACzC,CAAC,CACH"}
+{"version":3,"file":"max.cjs","names":[],"sources":["../../src/math/max.ts"],"sourcesContent":["import { fold } from '../array/fold';\nimport { compare } from '../function/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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  const fn = callback ?? ((item: T) => item);\n\n  return fold(array, (a, b) => (compare(fn(a), fn(b)) > 0 ? a : b));\n}\n"],"mappings":"0EAwBA,SAAgB,EAAO,EAAY,EAA+D,CAChG,IAAM,EAAK,IAAc,GAAY,GAErC,OAAO,EAAA,KAAK,GAAQ,EAAG,IAAO,EAAA,QAAQ,EAAG,EAAE,CAAE,EAAG,EAAE,CAAC,CAAG,EAAI,EAAI,EAAG"}

package/dist/math/max.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+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":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;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,CAIhG"}

package/dist/math/max.js

@@ -1,12 +1,11 @@
-import { compare as f } from "../function/compare.js";
-import { boil as i } from "./boil.js";
-function u(m, n) {
-  return i(m, (r, o) => {
-    const t = n || ((e) => e);
-    return f(t(r), t(o)) > 0 ? r : o;
-  });
+import { fold as e } from "../array/fold.js";
+import { compare as t } from "../function/compare.js";
+//#region src/math/max.ts
+function n(n, r) {
+	let i = r ?? ((e) => e);
+	return e(n, (e, n) => t(i(e), i(n)) > 0 ? e : n);
 }
-export {
-  u as max
-};
-//# sourceMappingURL=max.js.map
+//#endregion
+export { n as max };
+
+//# sourceMappingURL=max.js.map

package/dist/math/max.js.map

@@ -1 +1 @@
-{"version":3,"file":"max.js","sources":["../../src/math/max.ts"],"sourcesContent":["import { compare } from '../function/compare';\nimport { boil } from './boil';\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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  return boil(array, (a, b) => {\n    const fn = callback || ((item: T) => item);\n    return compare(fn(a), fn(b)) > 0 ? a : b;\n  });\n}\n"],"names":["max","array","callback","boil","a","b","fn","item","compare"],"mappings":";;AAwBO,SAASA,EAAOC,GAAYC,GAA+D;AAChG,SAAOC,EAAKF,GAAO,CAACG,GAAGC,MAAM;AAC3B,UAAMC,IAAKJ,MAAa,CAACK,MAAYA;AACrC,WAAOC,EAAQF,EAAGF,CAAC,GAAGE,EAAGD,CAAC,CAAC,IAAI,IAAID,IAAIC;AAAA,EACzC,CAAC;AACH;"}
+{"version":3,"file":"max.js","names":[],"sources":["../../src/math/max.ts"],"sourcesContent":["import { fold } from '../array/fold';\nimport { compare } from '../function/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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  const fn = callback ?? ((item: T) => item);\n\n  return fold(array, (a, b) => (compare(fn(a), fn(b)) > 0 ? a : b));\n}\n"],"mappings":";;;AAwBA,SAAgB,EAAO,GAAY,GAA+D;CAChG,IAAM,IAAK,OAAc,MAAY;AAErC,QAAO,EAAK,IAAQ,GAAG,MAAO,EAAQ,EAAG,EAAE,EAAE,EAAG,EAAE,CAAC,GAAG,IAAI,IAAI,EAAG"}

package/dist/math/median.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function c(n,a){if(n.length===0)return;const i=a?n.map(a):n,l=i.every(e=>e instanceof Date),t=i.map(e=>e instanceof Date?e.getTime():e);t.sort((e,u)=>e-u);const o=Math.floor(t.length/2),s=t.length%2===0?(t[o-1]+t[o])/2:t[o];return l?new Date(s):s}exports.median=c;
-//# sourceMappingURL=median.cjs.map
+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

@@ -1 +1 @@
-{"version":3,"file":"median.cjs","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 * median([new Date(2020-01-01), new Date(2020-01-02), new Date(2020-01-31)]) // 2020-01-02\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map the numbers.\n * @returns The median of the numbers.\n */\nexport function median<T>(arr: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : (arr as unknown as (number | Date)[]);\n  const allDates = values.every((v) => v instanceof Date);\n  const numericValues = values.map((v) => (v instanceof Date ? v.getTime() : (v as number)));\n\n  numericValues.sort((a, b) => a - b);\n\n  const mid = Math.floor(numericValues.length / 2);\n  const medianValue =\n    numericValues.length % 2 === 0 ? (numericValues[mid - 1] + numericValues[mid]) / 2 : numericValues[mid];\n\n  return (allDates ? new Date(medianValue) : medianValue) as unknown as number | Date;\n}\n"],"names":["median","arr","callback","values","allDates","v","numericValues","a","b","mid","medianValue"],"mappings":"gFAgBO,SAASA,EAAUC,EAAUC,EAAkE,CACpG,GAAID,EAAI,SAAW,EAAG,OAEtB,MAAME,EAASD,EAAWD,EAAI,IAAIC,CAAQ,EAAKD,EACzCG,EAAWD,EAAO,MAAOE,GAAMA,aAAa,IAAI,EAChDC,EAAgBH,EAAO,IAAKE,GAAOA,aAAa,KAAOA,EAAE,QAAA,EAAaA,CAAa,EAEzFC,EAAc,KAAK,CAACC,EAAGC,IAAMD,EAAIC,CAAC,EAElC,MAAMC,EAAM,KAAK,MAAMH,EAAc,OAAS,CAAC,EACzCI,EACJJ,EAAc,OAAS,IAAM,GAAKA,EAAcG,EAAM,CAAC,EAAIH,EAAcG,CAAG,GAAK,EAAIH,EAAcG,CAAG,EAExG,OAAQL,EAAW,IAAI,KAAKM,CAAW,EAAIA,CAC7C"}
+{"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,EAAS,CAAG,CAAC,GAAI,EAA4B,CAE/E,EAAO,MAAM,EAAG,IAAM,EAAI,EAAE,CAE5B,IAAM,EAAM,KAAK,MAAM,EAAO,OAAS,EAAE,CAEzC,OAAO,EAAO,OAAS,GAAM,GAAK,EAAO,EAAM,GAAK,EAAO,IAAQ,EAAI,EAAO"}

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

@@ -1,11 +1,12 @@
-function m(n, a) {
-  if (n.length === 0) return;
-  const s = a ? n.map(a) : n, c = s.every((e) => e instanceof Date), t = s.map((e) => e instanceof Date ? e.getTime() : e);
-  t.sort((e, l) => e - l);
-  const o = Math.floor(t.length / 2), i = t.length % 2 === 0 ? (t[o - 1] + t[o]) / 2 : t[o];
-  return c ? new Date(i) : i;
+//#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];
 }
-export {
-  m as median
-};
-//# sourceMappingURL=median.js.map
+//#endregion
+export { e as median };
+
+//# sourceMappingURL=median.js.map

package/dist/math/median.js.map

@@ -1 +1 @@
-{"version":3,"file":"median.js","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 * median([new Date(2020-01-01), new Date(2020-01-02), new Date(2020-01-31)]) // 2020-01-02\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map the numbers.\n * @returns The median of the numbers.\n */\nexport function median<T>(arr: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : (arr as unknown as (number | Date)[]);\n  const allDates = values.every((v) => v instanceof Date);\n  const numericValues = values.map((v) => (v instanceof Date ? v.getTime() : (v as number)));\n\n  numericValues.sort((a, b) => a - b);\n\n  const mid = Math.floor(numericValues.length / 2);\n  const medianValue =\n    numericValues.length % 2 === 0 ? (numericValues[mid - 1] + numericValues[mid]) / 2 : numericValues[mid];\n\n  return (allDates ? new Date(medianValue) : medianValue) as unknown as number | Date;\n}\n"],"names":["median","arr","callback","values","allDates","v","numericValues","a","b","mid","medianValue"],"mappings":"AAgBO,SAASA,EAAUC,GAAUC,GAAkE;AACpG,MAAID,EAAI,WAAW,EAAG;AAEtB,QAAME,IAASD,IAAWD,EAAI,IAAIC,CAAQ,IAAKD,GACzCG,IAAWD,EAAO,MAAM,CAACE,MAAMA,aAAa,IAAI,GAChDC,IAAgBH,EAAO,IAAI,CAACE,MAAOA,aAAa,OAAOA,EAAE,QAAA,IAAaA,CAAa;AAEzF,EAAAC,EAAc,KAAK,CAACC,GAAGC,MAAMD,IAAIC,CAAC;AAElC,QAAMC,IAAM,KAAK,MAAMH,EAAc,SAAS,CAAC,GACzCI,IACJJ,EAAc,SAAS,MAAM,KAAKA,EAAcG,IAAM,CAAC,IAAIH,EAAcG,CAAG,KAAK,IAAIH,EAAcG,CAAG;AAExG,SAAQL,IAAW,IAAI,KAAKM,CAAW,IAAIA;AAC7C;"}
+{"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;AACtF,KAAI,EAAI,WAAW,EAAG;CAEtB,IAAM,IAAS,IAAW,EAAI,IAAI,EAAS,GAAG,CAAC,GAAI,EAA4B;AAE/E,GAAO,MAAM,GAAG,MAAM,IAAI,EAAE;CAE5B,IAAM,IAAM,KAAK,MAAM,EAAO,SAAS,EAAE;AAEzC,QAAO,EAAO,SAAS,KAAM,KAAK,EAAO,IAAM,KAAK,EAAO,MAAQ,IAAI,EAAO"}

package/dist/math/min.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../function/compare.cjs"),u=require("./boil.cjs");function l(o,t){return u.boil(o,(e,r)=>{const n=t||(i=>i);return c.compare(n(e),n(r))<0?e:r})}exports.min=l;
-//# sourceMappingURL=min.cjs.map
+const e=require(`../array/fold.cjs`),t=require(`../function/compare.cjs`);function n(n,r){let i=r??(e=>e);return e.fold(n,(e,n)=>t.compare(i(e),i(n))<0?e:n)}exports.min=n;
+//# sourceMappingURL=min.cjs.map

package/dist/math/min.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"min.cjs","sources":["../../src/math/min.ts"],"sourcesContent":["import { compare } from '../function/compare';\nimport { boil } from './boil';\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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  return boil(array, (a, b) => {\n    const fn = callback || ((item: T) => item);\n    return compare(fn(a), fn(b)) < 0 ? a : b;\n  });\n}\n"],"names":["min","array","callback","boil","a","b","fn","item","compare"],"mappings":"mJAwBO,SAASA,EAAOC,EAAYC,EAA+D,CAChG,OAAOC,OAAKF,EAAO,CAACG,EAAGC,IAAM,CAC3B,MAAMC,EAAKJ,IAAcK,GAAYA,GACrC,OAAOC,EAAAA,QAAQF,EAAGF,CAAC,EAAGE,EAAGD,CAAC,CAAC,EAAI,EAAID,EAAIC,CACzC,CAAC,CACH"}
+{"version":3,"file":"min.cjs","names":[],"sources":["../../src/math/min.ts"],"sourcesContent":["import { fold } from '../array/fold';\nimport { compare } from '../function/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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  const fn = callback ?? ((item: T) => item);\n\n  return fold(array, (a, b) => (compare(fn(a), fn(b)) < 0 ? a : b));\n}\n"],"mappings":"0EAwBA,SAAgB,EAAO,EAAY,EAA+D,CAChG,IAAM,EAAK,IAAc,GAAY,GAErC,OAAO,EAAA,KAAK,GAAQ,EAAG,IAAO,EAAA,QAAQ,EAAG,EAAE,CAAE,EAAG,EAAE,CAAC,CAAG,EAAI,EAAI,EAAG"}

package/dist/math/min.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+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":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;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,CAIhG"}

package/dist/math/min.js

@@ -1,12 +1,11 @@
-import { compare as e } from "../function/compare.js";
-import { boil as f } from "./boil.js";
-function u(t, m) {
-  return f(t, (r, o) => {
-    const n = m || ((i) => i);
-    return e(n(r), n(o)) < 0 ? r : o;
-  });
+import { fold as e } from "../array/fold.js";
+import { compare as t } from "../function/compare.js";
+//#region src/math/min.ts
+function n(n, r) {
+	let i = r ?? ((e) => e);
+	return e(n, (e, n) => t(i(e), i(n)) < 0 ? e : n);
 }
-export {
-  u as min
-};
-//# sourceMappingURL=min.js.map
+//#endregion
+export { n as min };
+
+//# sourceMappingURL=min.js.map

package/dist/math/min.js.map

@@ -1 +1 @@
-{"version":3,"file":"min.js","sources":["../../src/math/min.ts"],"sourcesContent":["import { compare } from '../function/compare';\nimport { boil } from './boil';\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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  return boil(array, (a, b) => {\n    const fn = callback || ((item: T) => item);\n    return compare(fn(a), fn(b)) < 0 ? a : b;\n  });\n}\n"],"names":["min","array","callback","boil","a","b","fn","item","compare"],"mappings":";;AAwBO,SAASA,EAAOC,GAAYC,GAA+D;AAChG,SAAOC,EAAKF,GAAO,CAACG,GAAGC,MAAM;AAC3B,UAAMC,IAAKJ,MAAa,CAACK,MAAYA;AACrC,WAAOC,EAAQF,EAAGF,CAAC,GAAGE,EAAGD,CAAC,CAAC,IAAI,IAAID,IAAIC;AAAA,EACzC,CAAC;AACH;"}
+{"version":3,"file":"min.js","names":[],"sources":["../../src/math/min.ts"],"sourcesContent":["import { fold } from '../array/fold';\nimport { compare } from '../function/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 *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  const fn = callback ?? ((item: T) => item);\n\n  return fold(array, (a, b) => (compare(fn(a), fn(b)) < 0 ? a : b));\n}\n"],"mappings":";;;AAwBA,SAAgB,EAAO,GAAY,GAA+D;CAChG,IAAM,IAAK,OAAc,MAAY;AAErC,QAAO,EAAK,IAAQ,GAAG,MAAO,EAAQ,EAAG,EAAE,EAAE,EAAG,EAAE,CAAC,GAAG,IAAI,IAAI,EAAG"}

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"}

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;AAG5D,QAFI,MAAU,IAAU,IAEhB,IAAQ,IAAS"}

package/dist/math/range.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../function/assert.cjs");function m(r,i,e){if(a.assert(Number.isFinite(r)&&Number.isFinite(i)&&Number.isFinite(e),"start, stop, and step must be finite numbers",{args:{start:r,step:e,stop:i},type:TypeError}),a.assert(e!==0,"Step cannot be 0",{args:{step:e},type:Error}),r===i)return[];const n=Math.max(0,Math.ceil((i-r)/e+Number.EPSILON));return a.assert(n<=1e7,"Range exceeds maximum allowed size of 10,000,000",{args:{length:n,start:r,step:e,stop:i},type:Error}),Array.from({length:n},(t,u)=>r+u*e)}exports.range=m;
-//# sourceMappingURL=range.cjs.map
+const e=require(`../function/assert.cjs`);function t(t,n,r){if(e.assert(Number.isFinite(t)&&Number.isFinite(n)&&Number.isFinite(r),`start, stop, and step must be finite numbers`,{args:{start:t,step:r,stop:n},type:TypeError}),e.assert(r!==0,`Step cannot be 0`,{args:{step:r},type:Error}),t===n)return[];let i=Math.max(0,Math.ceil((n-t)/r+2**-52));return e.assert(i<=1e7,`Range exceeds maximum allowed size of 10,000,000`,{args:{length:i,start:t,step:r,stop:n},type:Error}),Array.from({length:i},(e,n)=>t+n*r)}exports.range=t;
+//# sourceMappingURL=range.cjs.map

package/dist/math/range.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"range.cjs","sources":["../../src/math/range.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates an array of numbers progressing from start up to, but not including, end. A step is used to specify the difference between each number in the array.\n *\n * @example\n * ```ts\n * const start = 0;\n * const stop = 10;\n * const step = 2;\n *\n * range(start, stop, step) // [0, 2, 4, 6, 8];\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range.\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {TypeError} If start, stop, or step are not finite numbers.\n * @throws {Error} If step is 0 or if range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number) {\n  assert(\n    Number.isFinite(start) && Number.isFinite(stop) && Number.isFinite(step),\n    'start, stop, and step must be finite numbers',\n    { args: { start, step, stop }, type: TypeError },\n  );\n  assert(step !== 0, 'Step cannot be 0', { args: { step }, type: Error });\n\n  if (start === stop) {\n    return [];\n  }\n\n  const length = Math.max(0, Math.ceil((stop - start) / step + Number.EPSILON));\n\n  assert(length <= 10_000_000, 'Range exceeds maximum allowed size of 10,000,000', {\n    args: { length, start, step, stop },\n    type: Error,\n  });\n\n  return Array.from({ length }, (_, i) => start + i * step);\n}\n"],"names":["range","start","stop","step","assert","length","_","i"],"mappings":"0HAuBO,SAASA,EAAMC,EAAeC,EAAcC,EAAc,CAQ/D,GAPAC,EAAAA,OACE,OAAO,SAASH,CAAK,GAAK,OAAO,SAASC,CAAI,GAAK,OAAO,SAASC,CAAI,EACvE,+CACA,CAAE,KAAM,CAAE,MAAAF,EAAO,KAAAE,EAAM,KAAAD,CAAA,EAAQ,KAAM,SAAA,CAAU,EAEjDE,SAAOD,IAAS,EAAG,mBAAoB,CAAE,KAAM,CAAE,KAAAA,CAAA,EAAQ,KAAM,MAAO,EAElEF,IAAUC,EACZ,MAAO,CAAA,EAGT,MAAMG,EAAS,KAAK,IAAI,EAAG,KAAK,MAAMH,EAAOD,GAASE,EAAO,OAAO,OAAO,CAAC,EAE5EC,OAAAA,SAAOC,GAAU,IAAY,mDAAoD,CAC/E,KAAM,CAAE,OAAAA,EAAQ,MAAAJ,EAAO,KAAAE,EAAM,KAAAD,CAAA,EAC7B,KAAM,KAAA,CACP,EAEM,MAAM,KAAK,CAAE,OAAAG,CAAA,EAAU,CAACC,EAAGC,IAAMN,EAAQM,EAAIJ,CAAI,CAC1D"}
+{"version":3,"file":"range.cjs","names":[],"sources":["../../src/math/range.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates an array of numbers progressing from start up to, but not including, end. A step is used to specify the difference between each number in the array.\n *\n * @example\n * ```ts\n * const start = 0;\n * const stop = 10;\n * const step = 2;\n *\n * range(start, stop, step) // [0, 2, 4, 6, 8];\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range.\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {TypeError} If start, stop, or step are not finite numbers.\n * @throws {Error} If step is 0 or if range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number) {\n  assert(\n    Number.isFinite(start) && Number.isFinite(stop) && Number.isFinite(step),\n    'start, stop, and step must be finite numbers',\n    { args: { start, step, stop }, type: TypeError },\n  );\n  assert(step !== 0, 'Step cannot be 0', { args: { step }, type: Error });\n\n  if (start === stop) {\n    return [];\n  }\n\n  const length = Math.max(0, Math.ceil((stop - start) / step + Number.EPSILON));\n\n  assert(length <= 10_000_000, 'Range exceeds maximum allowed size of 10,000,000', {\n    args: { length, start, step, stop },\n    type: Error,\n  });\n\n  return Array.from({ length }, (_, i) => start + i * step);\n}\n"],"mappings":"0CAuBA,SAAgB,EAAM,EAAe,EAAc,EAAc,CAQ/D,GAPA,EAAA,OACE,OAAO,SAAS,EAAM,EAAI,OAAO,SAAS,EAAK,EAAI,OAAO,SAAS,EAAK,CACxE,+CACA,CAAE,KAAM,CAAE,QAAO,OAAM,OAAM,CAAE,KAAM,UAAW,CACjD,CACD,EAAA,OAAO,IAAS,EAAG,mBAAoB,CAAE,KAAM,CAAE,OAAM,CAAE,KAAM,MAAO,CAAC,CAEnE,IAAU,EACZ,MAAO,EAAE,CAGX,IAAM,EAAS,KAAK,IAAI,EAAG,KAAK,MAAM,EAAO,GAAS,SAAsB,CAAC,CAO7E,OALA,EAAA,OAAO,GAAU,IAAY,mDAAoD,CAC/E,KAAM,CAAE,SAAQ,QAAO,OAAM,OAAM,CACnC,KAAM,MACP,CAAC,CAEK,MAAM,KAAK,CAAE,SAAQ,EAAG,EAAG,IAAM,EAAQ,EAAI,EAAK"}