umt 2.12.3 → 2.13.0

package/module/es5/Math/average.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.average = void 0;
-var _addition = require("./addition");
 var _division = require("./division");
+var _sum = require("../Array/sum");
 /**
  * Calculates the arithmetic mean of an array of numbers
  * @param  {number[]} numbers - Array of numbers to average
@@ -19,9 +19,7 @@ var average = exports.average = function average(numbers) {
   if (numbers.length === 0) {
     return 0;
   }
-  var sum = numbers.reduce(function (a, b) {
-    return (0, _addition.addition)(a, b);
-  }, 0);
-  var avg = (0, _division.division)(sum, numbers.length);
+  var total = (0, _sum.sum)(numbers);
+  var avg = (0, _division.division)(total, numbers.length);
   return avg;
 };

package/module/es5/Math/bitwise.js

@@ -30,7 +30,7 @@ var bitwise = exports.bitwise = function bitwise(x, k) {
       }
     default:
       {
-        throw new Error("Invalid direction ".concat(direction));
+        return direction;
       }
   }
 };

package/module/es5/Math/calculator/core.js

@@ -9,6 +9,7 @@ var _addition = require("../../Math/addition");
 var _division = require("../../Math/division");
 var _multiplication = require("../../Math/multiplication");
 var _subtract = require("../../Math/subtract");
+var _escapeRegExp = require("../../Tool/escapeRegExp");
 var _isNumber = require("../../Validate/isNumber");
 var calculatorCore = exports.calculatorCore = function calculatorCore(expression, currencyExchange) {
   // Handle empty string
@@ -84,7 +85,7 @@ var getCurrencyRegex = function getCurrencyRegex(currencySymbol) {
   if (cached) {
     return cached;
   }
-  var regex = new RegExp("\\".concat(currencySymbol, "([0-9]+)"));
+  var regex = new RegExp("".concat((0, _escapeRegExp.escapeRegExp)(currencySymbol), "([0-9]+)"));
   currencyRegexCache.set(currencySymbol, regex);
   return regex;
 };

package/module/es5/Math/calculator/literalExpression.js

@@ -36,7 +36,7 @@ var literalExpression = exports.literalExpression = function literalExpression(x
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var part = _step.value;
       if (/[A-Za-z]+/.test(part)) {
-        variablePart = part.split(/([-+]?\d*[A-Za-z]+)|([-+]?\d+)/).filter(function (n) {
+        variablePart = part.split(/([+-]?\d*[A-Za-z]+)|([+-]?\d+)/).filter(function (n) {
           return n && n !== undefined;
         });
       } else {

package/module/es5/Math/clamp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Clamps a number between a minimum and maximum value.
+ *
+ * @param value - The number to clamp.
+ * @param min - The minimum bound.
+ * @param max - The maximum bound.
+ * @returns The clamped number.
+ *
+ * @example
+ * ```typescript
+ * clamp(5, 0, 10);   // 5
+ * clamp(-3, 0, 10);  // 0
+ * clamp(15, 0, 10);  // 10
+ * ```
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;

package/module/es5/Math/clamp.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clamp = void 0;
+/**
+ * Clamps a number between a minimum and maximum value.
+ *
+ * @param value - The number to clamp.
+ * @param min - The minimum bound.
+ * @param max - The maximum bound.
+ * @returns The clamped number.
+ *
+ * @example
+ * ```typescript
+ * clamp(5, 0, 10);   // 5
+ * clamp(-3, 0, 10);  // 0
+ * clamp(15, 0, 10);  // 10
+ * ```
+ */
+var clamp = exports.clamp = function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+};

package/module/es5/Math/correlationCoefficient.js

@@ -23,9 +23,6 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * correlationCoefficient([1, 2, 3, 4, 5], [1, 1, 1, 1, 1]); // 0 (no correlation)
  */
 var correlationCoefficient = exports.correlationCoefficient = function correlationCoefficient(x, y) {
-  if (x.length !== y.length) {
-    throw new Error("Arrays must have the same length");
-  }
   if (x.length === 0) {
     return Number.NaN;
   }

package/module/es5/Math/inRange.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if a number is within a given range.
+ * If only two arguments are provided, the range is [0, start).
+ * If three arguments are provided, the range is [min(start, end), max(start, end)).
+ *
+ * @param value - The number to check.
+ * @param start - The start of the range, or the end if end is not provided.
+ * @param end - The end of the range (optional).
+ * @returns True if the value is within the range, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * inRange(3, 5);      // true  (range: [0, 5))
+ * inRange(5, 5);      // false (range: [0, 5))
+ * inRange(3, 2, 5);   // true  (range: [2, 5))
+ * inRange(3, 5, 2);   // true  (range: [2, 5))
+ * ```
+ */
+export declare const inRange: (value: number, start: number, end?: number) => boolean;

package/module/es5/Math/inRange.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.inRange = void 0;
+/**
+ * Checks if a number is within a given range.
+ * If only two arguments are provided, the range is [0, start).
+ * If three arguments are provided, the range is [min(start, end), max(start, end)).
+ *
+ * @param value - The number to check.
+ * @param start - The start of the range, or the end if end is not provided.
+ * @param end - The end of the range (optional).
+ * @returns True if the value is within the range, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * inRange(3, 5);      // true  (range: [0, 5))
+ * inRange(5, 5);      // false (range: [0, 5))
+ * inRange(3, 2, 5);   // true  (range: [2, 5))
+ * inRange(3, 5, 2);   // true  (range: [2, 5))
+ * ```
+ */
+var inRange = exports.inRange = function inRange(value, start, end) {
+  var lower = end === undefined ? Math.min(start, 0) : Math.min(start, end);
+  var upper = end === undefined ? Math.max(start, 0) : Math.max(start, end);
+  return value >= lower && value < upper;
+};

package/module/es5/Math/index.d.ts

@@ -2,6 +2,7 @@ export * from "./addition";
 export * from "./average";
 export * from "./bitwise";
 export * from "./calculator";
+export * from "./clamp";
 export * from "./correlationCoefficient";
 export * from "./degToRad";
 export * from "./deviationValue";
@@ -11,6 +12,7 @@ export * from "./factorize";
 export * from "./flexibleNumberConversion";
 export * from "./gcd";
 export * from "./getDecimalLength";
+export * from "./inRange";
 export * from "./lcm";
 export * from "./linearCongruentialGenerator";
 export * from "./mathConverter";
@@ -35,6 +37,7 @@ export * from "./roundOf";
 export * from "./solveEquation";
 export * from "./standardDeviation";
 export * from "./subtract";
+export * from "./sumPrecise";
 export * from "./toBaseN";
 export * from "./toCelsius";
 export * from "./toKelvin";

package/module/es5/Math/index.js

@@ -47,6 +47,17 @@ Object.keys(_calculator).forEach(function (key) {
     }
   });
 });
+var _clamp = require("./clamp");
+Object.keys(_clamp).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _clamp[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _clamp[key];
+    }
+  });
+});
 var _correlationCoefficient = require("./correlationCoefficient");
 Object.keys(_correlationCoefficient).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -146,6 +157,17 @@ Object.keys(_getDecimalLength).forEach(function (key) {
     }
   });
 });
+var _inRange = require("./inRange");
+Object.keys(_inRange).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _inRange[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _inRange[key];
+    }
+  });
+});
 var _lcm = require("./lcm");
 Object.keys(_lcm).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -410,6 +432,17 @@ Object.keys(_subtract).forEach(function (key) {
     }
   });
 });
+var _sumPrecise = require("./sumPrecise");
+Object.keys(_sumPrecise).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sumPrecise[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _sumPrecise[key];
+    }
+  });
+});
 var _toBaseN = require("./toBaseN");
 Object.keys(_toBaseN).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Math/median.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.median = void 0;
-var _quickSort = require("../Array/quickSort");
+var _ultraNumberSort = require("../Array/ultraNumberSort");
 /**
  * Calculate the median of an array of numbers
  * @param {number[]} array Array of numbers
@@ -12,7 +12,7 @@ var _quickSort = require("../Array/quickSort");
  * @example median([1, 3, 3, 6, 7, 8, 9]); // 6
  */
 var median = exports.median = function median(array) {
-  var sortedArray = (0, _quickSort.quickSort)(array);
+  var sortedArray = (0, _ultraNumberSort.ultraNumberSort)(array);
   var mid = Math.floor(sortedArray.length / 2);
   return sortedArray.length % 2 === 0 ? (sortedArray[mid - 1] + sortedArray[mid]) / 2 : sortedArray[mid];
 };

package/module/es5/Math/nCr.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.nCr = void 0;
+var _factorial = require("./factorial");
 var _nPr = require("./nPr");
 /**
  * Calculates combinations (nCr) - number of ways to choose r items from n items
@@ -23,10 +24,7 @@ var nCr = exports.nCr = function nCr(n, r) {
     return 1;
   }
   var numerator = (0, _nPr.nPr)(n, r);
-  var denominator = 1;
-  for (var index = 2; index <= r; index++) {
-    denominator *= index;
-  }
+  var denominator = (0, _factorial.factorial)(r);
   var result = numerator / denominator;
   return result;
 };

package/module/es5/Math/percentile.js

@@ -4,13 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.percentile = void 0;
-var _quickSort = require("../Array/quickSort");
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var _ultraNumberSort = require("../Array/ultraNumberSort");
 /**
  * Calculate the nth percentile of values in an array
  * @param array - Array of numbers
@@ -25,10 +19,7 @@ var percentile = exports.percentile = function percentile(array, _percentile) {
   if (array.length === 0) {
     return Number.NaN;
   }
-  if (_percentile < 0 || _percentile > 100) {
-    throw new Error("Percentile must be between 0 and 100");
-  }
-  var sortedArray = (0, _quickSort.quickSort)(_toConsumableArray(array));
+  var sortedArray = (0, _ultraNumberSort.ultraNumberSort)(array);
   var index = _percentile / 100 * (sortedArray.length - 1);
   var lowerIndex = Math.floor(index);
   var upperIndex = Math.ceil(index);

package/module/es5/Math/primeFactorization.js

@@ -14,7 +14,7 @@ exports.primeFactorization = void 0;
  * For example, 12 = 2^2 * 3^1 is represented as [{number: 2, count: 2}, {number: 3, count: 1}]
  */
 var primeFactorization = exports.primeFactorization = function primeFactorization(x) {
-  var n = 0;
+  var n;
   var copyX = x;
   var out = [];
   for (var index = 2; index * index <= copyX; index++) {

package/module/es5/Math/sumPrecise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Computes the sum of an array of numbers using the Neumaier
+ * summation algorithm for improved floating-point precision.
+ *
+ * @param numbers - The array of numbers to sum.
+ * @returns The precise sum of all numbers.
+ *
+ * @example
+ * ```typescript
+ * sumPrecise([0.1, 0.2, 0.3]);    // 0.6
+ * sumPrecise([1e20, 1, -1e20]);    // 1
+ * ```
+ */
+export declare const sumPrecise: (numbers: number[]) => number;

package/module/es5/Math/sumPrecise.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sumPrecise = void 0;
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Computes the sum of an array of numbers using the Neumaier
+ * summation algorithm for improved floating-point precision.
+ *
+ * @param numbers - The array of numbers to sum.
+ * @returns The precise sum of all numbers.
+ *
+ * @example
+ * ```typescript
+ * sumPrecise([0.1, 0.2, 0.3]);    // 0.6
+ * sumPrecise([1e20, 1, -1e20]);    // 1
+ * ```
+ */
+var sumPrecise = exports.sumPrecise = function sumPrecise(numbers) {
+  var sum = 0;
+  var compensation = 0;
+  var _iterator = _createForOfIteratorHelper(numbers),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var number_ = _step.value;
+      var t = sum + number_;
+      compensation += Math.abs(sum) >= Math.abs(number_) ? sum - t + number_ : number_ - t + sum;
+      sum = t;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return sum + compensation;
+};

package/module/es5/Math/uuidv7.js

@@ -4,13 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.uuidv7 = void 0;
-function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /**
  * Generates a UUID v7 (Universally Unique Identifier version 7)
  * @returns {string} A UUID v7 string in the format xxxxxxxx-xxxx-7xxx-8xxx-xxxxxxxxxxxx
@@ -27,40 +20,32 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 var uuidv7 = exports.uuidv7 = function uuidv7() {
   var DIGITS = "0123456789abcdef";
   var unixTsMs = Date.now();
+
+  // Create a single 16-byte buffer for the UUID
   var bytes = new Uint8Array(16);
-  for (var index = 0; index < 6; index++) {
-    bytes[index] = unixTsMs >>> (5 - index) * 8 & 0xff;
-  }
 
-  // Generate 10 random bytes for the rest
-  var randomBytes = new Uint8Array(10);
-  globalThis.crypto.getRandomValues(randomBytes);
+  // Fill the entire buffer with random data first.
+  // This avoids allocating a separate 10-byte buffer for randomness.
+  // We will overwrite the first 6 bytes with the timestamp.
+  globalThis.crypto.getRandomValues(bytes);
+
+  // Overwrite first 6 bytes with 48-bit timestamp (Big-Endian)
+  // Note: We use division for the high 16 bits because JS bitwise operators (>>>)
+  // truncate to 32 bits, which would corrupt the 48-bit timestamp.
+  bytes[0] = unixTsMs / 0x10000000000 & 0xff;
+  bytes[1] = unixTsMs / 0x100000000 & 0xff;
+  bytes[2] = unixTsMs >>> 24 & 0xff;
+  bytes[3] = unixTsMs >>> 16 & 0xff;
+  bytes[4] = unixTsMs >>> 8 & 0xff;
+  bytes[5] = unixTsMs & 0xff;
+
+  // Version 7 (0x70) + 4 bits from random data (already in bytes[6])
+  bytes[6] = 0x70 | bytes[6] & 0x0f;
+
+  // Variant 2 (0x80) + 6 bits from random data (already in bytes[8])
+  bytes[8] = 0x80 | bytes[8] & 0x3f;
 
-  // Version 7 (0x70) + 4 bits from randomBytes[0]
-  bytes[6] = 0x70 | randomBytes[0] & 0x0f;
-  // Random byte
-  bytes[7] = randomBytes[1];
-  // Variant 2 (0x80) + 6 bits from randomBytes[2]
-  bytes[8] = 0x80 | randomBytes[2] & 0x3f;
-  // Remaining random bytes
-  bytes.set(randomBytes.subarray(3), 9);
-  var uuid = "";
-  var _iterator = _createForOfIteratorHelper(bytes.entries()),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        _index = _step$value[0],
-        _byte = _step$value[1];
-      uuid += DIGITS[_byte >>> 4] + DIGITS[_byte & 0xf];
-      if (_index === 3 || _index === 5 || _index === 7 || _index === 9) {
-        uuid += "-";
-      }
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  return uuid;
+  // Convert to string (unrolled for performance)
+  // Format: 8-4-4-4-12 hex digits (xxxxxxxx-xxxx-7xxx-8xxx-xxxxxxxxxxxx)
+  return DIGITS[bytes[0] >>> 4] + DIGITS[bytes[0] & 0xf] + DIGITS[bytes[1] >>> 4] + DIGITS[bytes[1] & 0xf] + DIGITS[bytes[2] >>> 4] + DIGITS[bytes[2] & 0xf] + DIGITS[bytes[3] >>> 4] + DIGITS[bytes[3] & 0xf] + "-" + DIGITS[bytes[4] >>> 4] + DIGITS[bytes[4] & 0xf] + DIGITS[bytes[5] >>> 4] + DIGITS[bytes[5] & 0xf] + "-" + DIGITS[bytes[6] >>> 4] + DIGITS[bytes[6] & 0xf] + DIGITS[bytes[7] >>> 4] + DIGITS[bytes[7] & 0xf] + "-" + DIGITS[bytes[8] >>> 4] + DIGITS[bytes[8] & 0xf] + DIGITS[bytes[9] >>> 4] + DIGITS[bytes[9] & 0xf] + "-" + DIGITS[bytes[10] >>> 4] + DIGITS[bytes[10] & 0xf] + DIGITS[bytes[11] >>> 4] + DIGITS[bytes[11] & 0xf] + DIGITS[bytes[12] >>> 4] + DIGITS[bytes[12] & 0xf] + DIGITS[bytes[13] >>> 4] + DIGITS[bytes[13] & 0xf] + DIGITS[bytes[14] >>> 4] + DIGITS[bytes[14] & 0xf] + DIGITS[bytes[15] >>> 4] + DIGITS[bytes[15] & 0xf];
 };

package/module/es5/Number/formatNumber.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Options for formatting a number.
+ */
+export interface FormatNumberOptions {
+    /** The locale to use for formatting (e.g., "en-US", "ja-JP") */
+    locale?: string;
+    /** Minimum number of fraction digits */
+    minimumFractionDigits?: number;
+    /** Maximum number of fraction digits */
+    maximumFractionDigits?: number;
+    /** The formatting style */
+    style?: "decimal" | "currency" | "percent";
+    /** The currency code (required when style is "currency") */
+    currency?: string;
+}
+/**
+ * Formats a number using Intl.NumberFormat.
+ *
+ * @param value - The number to format
+ * @param options - Formatting options
+ * @returns The formatted number string
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1234567.89);
+ * // "1,234,567.89" (in en-US locale)
+ *
+ * formatNumber(1234567.89, { locale: "de-DE" });
+ * // "1.234.567,89"
+ *
+ * formatNumber(0.75, { style: "percent" });
+ * // "75%"
+ *
+ * formatNumber(1234.5, {
+ *   style: "currency",
+ *   currency: "USD",
+ *   locale: "en-US",
+ * });
+ * // "$1,234.50"
+ * ```
+ */
+export declare const formatNumber: (value: number, options?: FormatNumberOptions) => string;

package/module/es5/Number/formatNumber.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatNumber = void 0;
+/**
+ * Options for formatting a number.
+ */
+
+/**
+ * Formats a number using Intl.NumberFormat.
+ *
+ * @param value - The number to format
+ * @param options - Formatting options
+ * @returns The formatted number string
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1234567.89);
+ * // "1,234,567.89" (in en-US locale)
+ *
+ * formatNumber(1234567.89, { locale: "de-DE" });
+ * // "1.234.567,89"
+ *
+ * formatNumber(0.75, { style: "percent" });
+ * // "75%"
+ *
+ * formatNumber(1234.5, {
+ *   style: "currency",
+ *   currency: "USD",
+ *   locale: "en-US",
+ * });
+ * // "$1,234.50"
+ * ```
+ */
+var formatNumber = exports.formatNumber = function formatNumber(value) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var locale = options.locale,
+    minimumFractionDigits = options.minimumFractionDigits,
+    maximumFractionDigits = options.maximumFractionDigits,
+    style = options.style,
+    currency = options.currency;
+  var formatOptions = {};
+  if (style !== undefined) {
+    formatOptions.style = style;
+  }
+  if (currency !== undefined) {
+    formatOptions.currency = currency;
+  }
+  if (minimumFractionDigits !== undefined) {
+    formatOptions.minimumFractionDigits = minimumFractionDigits;
+  }
+  if (maximumFractionDigits !== undefined) {
+    formatOptions.maximumFractionDigits = maximumFractionDigits;
+  }
+  return new Intl.NumberFormat(locale, formatOptions).format(value);
+};

package/module/es5/Number/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./formatNumber";
+export * from "./toOrdinal";
+export * from "./toPercentage";

package/module/es5/Number/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _formatNumber = require("./formatNumber");
+Object.keys(_formatNumber).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _formatNumber[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _formatNumber[key];
+    }
+  });
+});
+var _toOrdinal = require("./toOrdinal");
+Object.keys(_toOrdinal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toOrdinal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toOrdinal[key];
+    }
+  });
+});
+var _toPercentage = require("./toPercentage");
+Object.keys(_toPercentage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toPercentage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toPercentage[key];
+    }
+  });
+});

package/module/es5/Number/toOrdinal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a number to its English ordinal string representation.
+ *
+ * Handles the special cases for 11th, 12th, and 13th
+ * (which end in "th" despite their last digit).
+ *
+ * @param value - The number to convert to ordinal form
+ * @returns The ordinal string (e.g., "1st", "2nd", "3rd", "11th")
+ *
+ * @example
+ * ```typescript
+ * toOrdinal(1);   // "1st"
+ * toOrdinal(2);   // "2nd"
+ * toOrdinal(3);   // "3rd"
+ * toOrdinal(11);  // "11th"
+ * toOrdinal(21);  // "21st"
+ * toOrdinal(112); // "112th"
+ * ```
+ */
+export declare const toOrdinal: (value: number) => string;