umt 2.13.0 → 2.15.0

package/module/es5/Array/zip.js

@@ -4,12 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.zip = void 0;
-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; }
 /**
  * Creates a new array by combining elements from multiple arrays at corresponding positions
  * @param {T} arrays List of arrays to combine
@@ -22,17 +16,29 @@ var zip = exports.zip = function zip() {
   for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
     arrays[_key] = arguments[_key];
   }
-  if (arrays.length === 0) {
+  var arraysLength = arrays.length;
+  if (arraysLength === 0) {
     return [];
   }
-  var length = Math.min.apply(Math, _toConsumableArray(arrays.map(function (array) {
-    return array.length;
-  })));
-  return Array.from({
-    length: length
-  }, function (_, index) {
-    return arrays.map(function (array) {
-      return array[index];
-    });
-  });
+
+  // Optimize: Avoid Math.min(...arrays.map(...)) to prevent Call Stack Size Exceeded errors
+  // for a large number of arrays, and avoid intermediate array allocations.
+  var minLength = arrays[0].length;
+  for (var index = 1; index < arraysLength; index += 1) {
+    if (arrays[index].length < minLength) {
+      minLength = arrays[index].length;
+    }
+  }
+
+  // Optimize: Pre-allocate outer array dynamically using loops rather than Array.from
+  // to reduce closure creation overhead and eliminate intermediate mapped arrays.
+  var result = [];
+  for (var _index = 0; _index < minLength; _index += 1) {
+    var tuple = [];
+    for (var arrayIndex = 0; arrayIndex < arraysLength; arrayIndex += 1) {
+      tuple.push(arrays[arrayIndex][_index]);
+    }
+    result.push(tuple);
+  }
+  return result;
 };

package/module/es5/Array/zipLongest.js

@@ -4,12 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.zipLongest = void 0;
-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; }
 /**
  * Combines arrays of different lengths by padding shorter arrays with undefined values
  * to match the length of the longest array
@@ -25,14 +19,33 @@ var zipLongest = exports.zipLongest = function zipLongest() {
   for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
     arrays[_key] = arguments[_key];
   }
-  var maxLength = Math.max.apply(Math, _toConsumableArray(arrays.map(function (array) {
-    return array.length;
-  })));
-  return Array.from({
+  var arraysLength = arrays.length;
+  if (arraysLength === 0) {
+    return [];
+  }
+
+  // Optimize: Avoid Math.max(...arrays.map(...)) to prevent Call Stack Size Exceeded errors
+  // for a large number of arrays, and avoid intermediate array allocations.
+  var maxLength = arrays[0].length;
+  for (var index = 1; index < arraysLength; index += 1) {
+    if (arrays[index].length > maxLength) {
+      maxLength = arrays[index].length;
+    }
+  }
+
+  // Optimize: Pre-allocate arrays with known lengths and use direct index assignment
+  // instead of .push() to avoid repeated capacity checks and potential reallocations.
+  var result = Array.from({
     length: maxLength
-  }, function (_, index) {
-    return arrays.map(function (array) {
-      return array[index];
-    });
   });
+  for (var _index = 0; _index < maxLength; _index += 1) {
+    var tuple = Array.from({
+      length: arraysLength
+    });
+    for (var arrayIndex = 0; arrayIndex < arraysLength; arrayIndex += 1) {
+      tuple[arrayIndex] = arrays[arrayIndex][_index];
+    }
+    result[_index] = tuple;
+  }
+  return result;
 };

package/module/es5/Crypto/decodeBase32.js

@@ -6,8 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.decodeBase32 = void 0;
 var _constants = require("./constants");
 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 _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; }
+// O(1) lookup table for Base32 character-to-index mapping
+var base32CharToIndex = new Map(_toConsumableArray(_constants.BASE32_ALPHABET).map(function (c, index) {
+  return [c, index];
+}));
+
 /**
  * Decodes a Base32 string to Uint8Array
  * @param {string} input - Base32 encoded string
@@ -15,7 +24,6 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * @example decodeBase32("JBSWY3DP"); // Uint8Array for "Hello"
  */
 var decodeBase32 = exports.decodeBase32 = function decodeBase32(input) {
-  var alphabet = _constants.BASE32_ALPHABET;
   var cleanedInput = input.replaceAll("=", "");
   var result = [];
   var buffer = 0;
@@ -24,8 +32,9 @@ var decodeBase32 = exports.decodeBase32 = function decodeBase32(input) {
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _base32CharToIndex$ge;
       var _char = _step.value;
-      var value = alphabet.indexOf(_char);
+      var value = (_base32CharToIndex$ge = base32CharToIndex.get(_char)) !== null && _base32CharToIndex$ge !== void 0 ? _base32CharToIndex$ge : 0;
       buffer = buffer << 5 | value;
       bufferLength += 5;
       if (bufferLength >= 8) {

package/module/es5/Crypto/decodeBase58.js

@@ -5,13 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.decodeBase58 = void 0;
 var _constants = require("./constants");
+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 _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 _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; }
+// O(1) lookup table for Base58 character-to-index mapping
+var base58CharToIndex = new Map(_toConsumableArray(_constants.BASE58_ALPHABET).map(function (c, index) {
+  return [c, index];
+}));
+
 /**
  * Decodes a Base58 string to Uint8Array
  * @param {string} input - Base58 encoded string
@@ -19,16 +24,17 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * @example decodeBase58("9Ajdvzr"); // Uint8Array for "Hello"
  */
 var decodeBase58 = exports.decodeBase58 = function decodeBase58(input) {
-  var alphabet = _constants.BASE58_ALPHABET;
   var bigNumber = 0n;
   var _iterator = _createForOfIteratorHelper(input),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _base58CharToIndex$ge;
       var _char = _step.value;
-      var value = alphabet.indexOf(_char);
-      bigNumber = bigNumber * 58n + BigInt(value);
+      bigNumber = bigNumber * 58n + BigInt((_base58CharToIndex$ge = base58CharToIndex.get(_char)) !== null && _base58CharToIndex$ge !== void 0 ? _base58CharToIndex$ge : 0);
     }
+
+    // Use push + reverse instead of unshift to avoid O(n²) array shifting
   } catch (err) {
     _iterator.e(err);
   } finally {
@@ -36,9 +42,10 @@ var decodeBase58 = exports.decodeBase58 = function decodeBase58(input) {
   }
   var bytes = [];
   while (bigNumber > 0) {
-    bytes.unshift(Number(bigNumber % 256n));
+    bytes.push(Number(bigNumber % 256n));
     bigNumber /= 256n;
   }
+  bytes.reverse();
   var leadingOnes = 0;
   var _iterator2 = _createForOfIteratorHelper(input),
     _step2;

package/module/es5/Crypto/encodeBase32.js

@@ -17,7 +17,11 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 var encodeBase32 = exports.encodeBase32 = function encodeBase32(input) {
   var alphabet = _constants.BASE32_ALPHABET;
   var bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-  var result = "";
+
+  // Performance: collect characters in an array and join at the end instead of
+  // repeated string concatenation, which copies the entire string on every +=
+  // and is O(n²) for large inputs. Array push + join is O(n).
+  var chars = [];
   var buffer = 0;
   var bufferLength = 0;
   var _iterator = _createForOfIteratorHelper(bytes),
@@ -29,7 +33,7 @@ var encodeBase32 = exports.encodeBase32 = function encodeBase32(input) {
       bufferLength += 8;
       while (bufferLength >= 5) {
         bufferLength -= 5;
-        result += alphabet[buffer >> bufferLength & 0x1f];
+        chars.push(alphabet[buffer >> bufferLength & 0x1f]);
       }
     }
   } catch (err) {
@@ -38,9 +42,11 @@ var encodeBase32 = exports.encodeBase32 = function encodeBase32(input) {
     _iterator.f();
   }
   if (bufferLength > 0) {
-    result += alphabet[buffer << 5 - bufferLength & 0x1f];
+    chars.push(alphabet[buffer << 5 - bufferLength & 0x1f]);
+  }
+  var paddingLength = (8 - chars.length % 8) % 8;
+  if (paddingLength > 0) {
+    chars.push("=".repeat(paddingLength));
   }
-  var paddingLength = (8 - result.length % 8) % 8;
-  result += "=".repeat(paddingLength);
-  return result;
+  return chars.join("");
 };

package/module/es5/Crypto/encodeBase58.js

@@ -17,7 +17,9 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 var encodeBase58 = exports.encodeBase58 = function encodeBase58(input) {
   var alphabet = _constants.BASE58_ALPHABET;
   var bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-  var encoded = "";
+
+  // Use array + reverse + join instead of string prepend to avoid O(n²) string concatenation
+  var chars = [];
   var bigNumber = 0n;
   var _iterator = _createForOfIteratorHelper(bytes),
     _step;
@@ -33,9 +35,11 @@ var encodeBase58 = exports.encodeBase58 = function encodeBase58(input) {
   }
   while (bigNumber > 0) {
     var remainder = Number(bigNumber % 58n);
-    encoded = alphabet[remainder] + encoded;
+    chars.push(alphabet[remainder]);
     bigNumber /= 58n;
   }
+  chars.reverse();
+  var encoded = chars.join("");
   var leadingZeros = 0;
   var _iterator2 = _createForOfIteratorHelper(bytes),
     _step2;

package/module/es5/DataStructure/priorityQueue.js

@@ -330,9 +330,14 @@ var PriorityQueue = exports.PriorityQueue = /*#__PURE__*/function () {
         this.minPriority = 0;
         return;
       }
-      this.minPriority = Math.min.apply(Math, _toConsumableArray(this.heap.map(function (item) {
-        return item.priority;
-      })));
+      // Single-pass minimum without intermediate array allocation
+      var min = this.heap[0].priority;
+      for (var index = 1; index < this.heap.length; index++) {
+        if (this.heap[index].priority < min) {
+          min = this.heap[index].priority;
+        }
+      }
+      this.minPriority = min;
     }
 
     /**

package/module/es5/IP/ipToBinaryString.js

@@ -10,7 +10,7 @@ exports.ipToBinaryString = void 0;
  * @returns {string} Binary string representation (32 bits)
  */
 var ipToBinaryString = exports.ipToBinaryString = function ipToBinaryString(ip) {
-  return ip.split(".").map(function (octet) {
-    return Number.parseInt(octet, 10).toString(2).padStart(8, "0");
+  return ip.split(".").map(function (part) {
+    return Number.parseInt(part, 10).toString(2).padStart(8, "0");
   }).join("");
 };

package/module/es5/IP/longToIp.d.ts

@@ -1,6 +1,6 @@
 /**
  * Converts a 32-bit number to an IPv4 address
- * @param {number} long - 32-bit unsigned integer to convert
+ * @param {number} long - 32-bit unsigned integer to convert (0 to 4294967295)
  * @returns {string} IPv4 address (e.g., "192.168.1.1")
  */
 export declare const longToIp: (long: number) => string;

package/module/es5/IP/longToIp.js

@@ -6,20 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.longToIp = void 0;
 /**
  * Converts a 32-bit number to an IPv4 address
- * @param {number} long - 32-bit unsigned integer to convert
+ * @param {number} long - 32-bit unsigned integer to convert (0 to 4294967295)
  * @returns {string} IPv4 address (e.g., "192.168.1.1")
  */
 var longToIp = exports.longToIp = function longToIp(_long) {
-  // Convert to binary string and ensure 32-bit length
-  var binary = _long.toString(2).padStart(32, "0");
-
-  // Split into octets and convert to decimal
-  var octets = Array.from({
-    length: 4
-  }, function (_, index) {
-    return Number.parseInt(binary.slice(index * 8, (index + 1) * 8), 2);
-  });
-
-  // Join octets with dots
-  return octets.join(".");
+  return "".concat(_long >>> 24 & 0xff, ".").concat(_long >>> 16 & 0xff, ".").concat(_long >>> 8 & 0xff, ".").concat(_long & 0xff);
 };

package/module/es5/Math/addition.js

@@ -13,30 +13,21 @@ var _getDecimalLength = require("./getDecimalLength");
  */
 var addition = exports.addition = function addition() {
   var maxDecimal = 0;
-  var allIntegers = true;
   for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
     numbers[_key] = arguments[_key];
   }
   for (var _i = 0, _numbers = numbers; _i < _numbers.length; _i++) {
     var number = _numbers[_i];
-    if (!Number.isInteger(number)) {
-      allIntegers = false;
-      var length = (0, _getDecimalLength.getDecimalLength)(number);
-      if (length > maxDecimal) {
-        maxDecimal = length;
-      }
+    var length = (0, _getDecimalLength.getDecimalLength)(number);
+    if (length > maxDecimal) {
+      maxDecimal = length;
     }
   }
-  if (allIntegers || maxDecimal === 0) {
-    return numbers.reduce(function (sum, current) {
-      return sum + current;
-    }, 0);
-  }
   var z = Math.pow(10, maxDecimal);
   var sum = 0;
   for (var _i2 = 0, _numbers2 = numbers; _i2 < _numbers2.length; _i2++) {
     var _number = _numbers2[_i2];
-    sum += Math.round(_number * z);
+    sum += maxDecimal === 0 ? _number : Math.round(_number * z);
   }
   return sum / z;
 };

package/module/es5/Math/multiplication.js

@@ -4,7 +4,32 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.multiplication = void 0;
+var _addition = require("./addition");
 var _getDecimalLength = require("./getDecimalLength");
+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 _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 _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; }
+var multiplyIntegers = function multiplyIntegers(numbers) {
+  var product = 1;
+  var _iterator = _createForOfIteratorHelper(numbers),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var n = _step.value;
+      product *= n;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return product;
+};
+
 /**
  * Performs multiplication without floating point errors for any number of arguments
  * @param  {...number[]} numbers Numbers to multiply
@@ -15,10 +40,16 @@ var multiplication = exports.multiplication = function multiplication() {
   for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
     numbers[_key] = arguments[_key];
   }
-  return numbers.reduce(function (accumulator, number) {
-    var n = Math.pow(10, (0, _getDecimalLength.getDecimalLength)(accumulator) + (0, _getDecimalLength.getDecimalLength)(number));
-    var accumulatorWithoutDot = +"".concat(accumulator).replace(".", "");
-    var numberWithoutDot = +"".concat(number).replace(".", "");
-    return accumulatorWithoutDot * numberWithoutDot / n;
-  }, 1);
+  if (numbers.every(function (n) {
+    return Number.isInteger(n);
+  })) {
+    return multiplyIntegers(numbers);
+  }
+  var integers = numbers.map(function (n) {
+    return +"".concat(n).replace(".", "");
+  });
+  var totalDecimal = _addition.addition.apply(void 0, _toConsumableArray(numbers.map(function (n) {
+    return (0, _getDecimalLength.getDecimalLength)(n);
+  })));
+  return multiplyIntegers(integers) / Math.pow(10, totalDecimal);
 };

package/module/es5/Math/nCr.js

@@ -23,8 +23,13 @@ var nCr = exports.nCr = function nCr(n, r) {
   if (r === 0 || n === r) {
     return 1;
   }
-  var numerator = (0, _nPr.nPr)(n, r);
-  var denominator = (0, _factorial.factorial)(r);
+
+  // Performance: use symmetry property nCr(n, r) = nCr(n, n-r) to
+  // minimize the number of multiplications when r > n/2.
+  // e.g. nCr(100, 97) becomes nCr(100, 3), reducing 193 multiplications to 5.
+  var effectiveR = Math.min(r, n - r);
+  var numerator = (0, _nPr.nPr)(n, effectiveR);
+  var denominator = (0, _factorial.factorial)(effectiveR);
   var result = numerator / denominator;
   return result;
 };

package/module/es5/Math/standardDeviation.js

@@ -5,8 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.standardDeviation = void 0;
 var _average = require("./average");
+var _addition = require("../Math/addition");
+var _division = require("../Math/division");
 var _multiplication = require("../Math/multiplication");
 var _subtract = require("../Math/subtract");
+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; }
 /**
  * Calculates the standard deviation of a set of values
  * @param {number[]} values Array of numeric values
@@ -19,17 +24,27 @@ var _subtract = require("../Math/subtract");
  * while a high standard deviation indicates that the values are spread out over a wider range.
  */
 var standardDeviation = exports.standardDeviation = function standardDeviation(values) {
+  if (values.length === 0) {
+    return 0;
+  }
   var avg = (0, _average.average)(values);
 
-  // Calculate the squared differences from the mean
-  var squareDiffs = values.map(function (value) {
-    var diff = (0, _subtract.subtract)(value, avg);
-    return (0, _multiplication.multiplication)(diff, diff);
-  });
-
-  // Calculate the mean of the squared differences
-  var avgSquareDiff = (0, _average.average)(squareDiffs);
-
-  // Return the square root of the mean squared differences
+  // Accumulate sum of squared differences in a single pass,
+  // avoiding an intermediate array allocation and extra traversal
+  var sumSquareDiffs = 0;
+  var _iterator = _createForOfIteratorHelper(values),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var value = _step.value;
+      var diff = (0, _subtract.subtract)(value, avg);
+      sumSquareDiffs = (0, _addition.addition)(sumSquareDiffs, (0, _multiplication.multiplication)(diff, diff));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var avgSquareDiff = (0, _division.division)(sumSquareDiffs, values.length);
   return Math.sqrt(avgSquareDiff);
 };

package/module/es5/Math/subtract.js

@@ -4,9 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.subtract = void 0;
+var _addition = require("./addition");
 var _getDecimalLength = require("./getDecimalLength");
 var _max = require("./max");
 var _multiplication = require("./multiplication");
+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; }
 /**
  * Performs subtraction with arbitrary number of arguments without floating point errors
  * @param  {number[]} numbers Array of numbers to subtract
@@ -24,13 +31,9 @@ var subtract = exports.subtract = function subtract() {
   for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
     numbers[_key] = arguments[_key];
   }
-  return numbers.reduce(function (accumulator, current, index) {
-    if (index === 0) {
-      return current;
-    }
-    // Get the power of 10 based on the maximum decimal places
-    var z = Math.pow(10, (0, _max.max)((0, _getDecimalLength.getDecimalLength)(accumulator), (0, _getDecimalLength.getDecimalLength)(current)));
-    // Scale to integers, subtract, then scale back to original decimal places
-    return ((0, _multiplication.multiplication)(accumulator, z) - (0, _multiplication.multiplication)(current, z)) / z;
-  }, 0);
+  var first = numbers[0],
+    rest = _arrayLikeToArray(numbers).slice(1);
+  var restSum = _addition.addition.apply(void 0, _toConsumableArray(rest));
+  var z = Math.pow(10, (0, _max.max)((0, _getDecimalLength.getDecimalLength)(first), (0, _getDecimalLength.getDecimalLength)(restSum)));
+  return ((0, _multiplication.multiplication)(first, z) - (0, _multiplication.multiplication)(restSum, z)) / z;
 };

package/module/es5/Object/deepClone.d.ts

@@ -11,5 +11,15 @@
  * cloned.b.c = 99;
  * original.b.c; // still 2
  * ```
+ *
+ * @remarks
+ * **Prototype pollution warning:** This function does not filter out
+ * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
+ * If processing user-controlled input, sanitize with the appropriate
+ * `removePrototype*` helper before calling this function:
+ * - `removePrototype` — shallow sanitization of a single object
+ * - `removePrototypeDeep` — recursive sanitization of a single object (for deeply nested data)
+ * - `removePrototypeMap` — shallow sanitization of an array of objects
+ * - `removePrototypeMapDeep` — recursive sanitization of an array of objects (for deeply nested data)
  */
 export declare const deepClone: <T>(value: T) => T;

package/module/es5/Object/deepClone.js

@@ -15,7 +15,7 @@ function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" ==
 /**
  * Recursively clones a value.
  */
-var _cloneValue = function cloneValue(value) {
+var _cloneValue = function cloneValue(value, depth) {
   if (value === null || _typeof(value) !== "object") {
     return value;
   }
@@ -26,7 +26,7 @@ var _cloneValue = function cloneValue(value) {
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var element = _step.value;
-        _result.push(_cloneValue(element));
+        _result.push(_cloneValue(element, depth + 1));
       }
     } catch (err) {
       _iterator.e(err);
@@ -50,7 +50,7 @@ var _cloneValue = function cloneValue(value) {
         var _step2$value = _slicedToArray(_step2.value, 2),
           k = _step2$value[0],
           v = _step2$value[1];
-        _result2.set(_cloneValue(k), _cloneValue(v));
+        _result2.set(_cloneValue(k, depth + 1), _cloneValue(v, depth + 1));
       }
     } catch (err) {
       _iterator2.e(err);
@@ -66,7 +66,7 @@ var _cloneValue = function cloneValue(value) {
     try {
       for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
         var _v = _step3.value;
-        _result3.add(_cloneValue(_v));
+        _result3.add(_cloneValue(_v, depth + 1));
       }
     } catch (err) {
       _iterator3.e(err);
@@ -80,7 +80,7 @@ var _cloneValue = function cloneValue(value) {
   var result = {};
   for (var _i = 0, _Object$keys = Object.keys(value); _i < _Object$keys.length; _i++) {
     var key = _Object$keys[_i];
-    result[key] = _cloneValue(value[key]);
+    result[key] = _cloneValue(value[key], depth + 1);
   }
   return result;
 };
@@ -98,10 +98,20 @@ var _cloneValue = function cloneValue(value) {
  * cloned.b.c = 99;
  * original.b.c; // still 2
  * ```
+ *
+ * @remarks
+ * **Prototype pollution warning:** This function does not filter out
+ * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
+ * If processing user-controlled input, sanitize with the appropriate
+ * `removePrototype*` helper before calling this function:
+ * - `removePrototype` — shallow sanitization of a single object
+ * - `removePrototypeDeep` — recursive sanitization of a single object (for deeply nested data)
+ * - `removePrototypeMap` — shallow sanitization of an array of objects
+ * - `removePrototypeMapDeep` — recursive sanitization of an array of objects (for deeply nested data)
  */
 var deepClone = exports.deepClone = function deepClone(value) {
   if (value === null || _typeof(value) !== "object") {
     return value;
   }
-  return _cloneValue(value);
+  return _cloneValue(value, 0);
 };

package/module/es5/Object/getObjectsCommon.d.ts

@@ -11,6 +11,16 @@
  * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
  * @returns {Partial<T>} Object containing only the key-value pairs shared by all inputs.
  *
+ * @remarks
+ * **Prototype pollution warning:** This function does not filter out
+ * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
+ * If processing user-controlled input, sanitize with the appropriate
+ * `removePrototype*` helper before calling this function:
+ * - `removePrototype` — shallow sanitization of a single object
+ * - `removePrototypeDeep` — recursive sanitization of a single object (for deeply nested data)
+ * - `removePrototypeMap` — shallow sanitization of an array of objects
+ * - `removePrototypeMapDeep` — recursive sanitization of an array of objects (for deeply nested data)
+ *
  * @example
  * ```typescript
  * getObjectsCommon({ a: 1, b: 2 }, { a: 1, c: 3 });