umt 2.14.0 → 2.16.0

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,10 +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];
-    if (key === "__proto__" || key === "constructor" || key === "prototype") {
-      continue;
-    }
-    result[key] = _cloneValue(value[key]);
+    result[key] = _cloneValue(value[key], depth + 1);
   }
   return result;
 };
@@ -101,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 });

package/module/es5/Object/getObjectsCommon.js

@@ -34,6 +34,16 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
  * @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 });

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

@@ -13,6 +13,16 @@
  * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
  * @returns {Partial<T>} Object containing only key-value pairs unique to one input.
  *
+ * @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
  * getObjectsDiff({ a: 1, b: 2 }, { b: 2, c: 3 });

package/module/es5/Object/getObjectsDiff.js

@@ -37,6 +37,16 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
  * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
  * @returns {Partial<T>} Object containing only key-value pairs unique to one input.
  *
+ * @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
  * getObjectsDiff({ a: 1, b: 2 }, { b: 2, c: 3 });
@@ -111,27 +121,32 @@ var _getObjectsDiff = exports.getObjectsDiff = function getObjectsDiff(object) {
       }
       var lastUniqueValue = void 0;
       var hasUnique = false;
+
+      // Count occurrences in a single pass using a Map — O(n) instead of O(n²).
+      // Map keys use SameValueZero which matches === for all values except NaN,
+      // an acceptable trade-off for object-diff use cases.
+      var valueCounts = new Map();
       for (var _i2 = 0, _values = values; _i2 < _values.length; _i2++) {
+        var _valueCounts$get;
         var value = _values[_i2];
-        var count = 0;
-        var _iterator4 = _createForOfIteratorHelper(values),
-          _step4;
-        try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            var other = _step4.value;
-            if (value === other) {
-              count++;
-            }
+        valueCounts.set(value, ((_valueCounts$get = valueCounts.get(value)) !== null && _valueCounts$get !== void 0 ? _valueCounts$get : 0) + 1);
+      }
+      var _iterator4 = _createForOfIteratorHelper(valueCounts),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _step4$value = _slicedToArray(_step4.value, 2),
+            _value = _step4$value[0],
+            count = _step4$value[1];
+          if (count === 1) {
+            lastUniqueValue = _value;
+            hasUnique = true;
           }
-        } catch (err) {
-          _iterator4.e(err);
-        } finally {
-          _iterator4.f();
-        }
-        if (count === 1) {
-          lastUniqueValue = value;
-          hasUnique = true;
         }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
       }
       if (hasUnique) {
         result[_key2] = lastUniqueValue;

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

@@ -6,6 +6,16 @@
  * @example has({ a: { b: 1 } }, "a.b"); // true
  * has({ a: { b: 1 } }, ["a", "b"]); // true
  * has({ a: { b: 1 } }, "a.c"); // false
+ *
+ * @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 has: <T extends {
     [key: string]: unknown;

package/module/es5/Object/has.js

@@ -4,15 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.has = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 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; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /**
  * Determines if an object has a specified path
  * @param {T} object - Object to check
@@ -21,10 +15,20 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
  * @example has({ a: { b: 1 } }, "a.b"); // true
  * has({ a: { b: 1 } }, ["a", "b"]); // true
  * has({ a: { b: 1 } }, "a.c"); // false
+ *
+ * @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 has = exports.has = function has(object, path) {
   var localPath = typeof path === "string" ? path.split(".") : path;
-  var current = _objectSpread({}, object);
+  var current = object;
   var _iterator = _createForOfIteratorHelper(localPath),
     _step;
   try {

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

@@ -12,3 +12,7 @@ export * from "./mergeDeep";
 export * from "./omit";
 export * from "./pick";
 export * from "./pickDeep";
+export * from "./removePrototype";
+export * from "./removePrototypeDeep";
+export * from "./removePrototypeMap";
+export * from "./removePrototypeMapDeep";

package/module/es5/Object/index.js

@@ -156,4 +156,48 @@ Object.keys(_pickDeep).forEach(function (key) {
       return _pickDeep[key];
     }
   });
+});
+var _removePrototype = require("./removePrototype");
+Object.keys(_removePrototype).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _removePrototype[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _removePrototype[key];
+    }
+  });
+});
+var _removePrototypeDeep = require("./removePrototypeDeep");
+Object.keys(_removePrototypeDeep).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _removePrototypeDeep[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _removePrototypeDeep[key];
+    }
+  });
+});
+var _removePrototypeMap = require("./removePrototypeMap");
+Object.keys(_removePrototypeMap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _removePrototypeMap[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _removePrototypeMap[key];
+    }
+  });
+});
+var _removePrototypeMapDeep = require("./removePrototypeMapDeep");
+Object.keys(_removePrototypeMapDeep).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _removePrototypeMapDeep[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _removePrototypeMapDeep[key];
+    }
+  });
 });

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

@@ -5,6 +5,16 @@ type Iteratee<T> = IterateeFunction<T> | keyof T;
  * Creates an object composed of keys generated from the results of running each element of collection through iteratee
  * @param collection The collection to iterate over
  * @param iteratee The iteratee function or property name to generate the key
+ *
+ * @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 function keyBy<T>(collection: T[] | Record<PropertyName, T>, iteratee?: Iteratee<T>): Record<PropertyName, T>;
 export {};

package/module/es5/Object/keyBy.js

@@ -11,6 +11,16 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * Creates an object composed of keys generated from the results of running each element of collection through iteratee
  * @param collection The collection to iterate over
  * @param iteratee The iteratee function or property name to generate the key
+ *
+ * @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)
  */
 function keyBy(collection, iteratee) {
   var getKey = normalizeIteratee(iteratee);

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

@@ -6,6 +6,16 @@
  * @param function_ - The function invoked per key. Receives (value, key).
  * @returns A new object with transformed keys.
  *
+ * @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
  * mapKeys({ a: 1, b: 2 }, (_value, key) => key.toUpperCase());

package/module/es5/Object/mapKeys.js

@@ -12,6 +12,16 @@ exports.mapKeys = void 0;
  * @param function_ - The function invoked per key. Receives (value, key).
  * @returns A new object with transformed keys.
  *
+ * @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
  * mapKeys({ a: 1, b: 2 }, (_value, key) => key.toUpperCase());
@@ -26,7 +36,8 @@ var mapKeys = exports.mapKeys = function mapKeys(object, function_) {
   while (index < length) {
     var key = keys[index];
     var value = object[key];
-    result[function_(value, key)] = value;
+    var newKey = function_(value, key);
+    result[newKey] = value;
     index += 1;
   }
   return result;

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

@@ -6,6 +6,16 @@
  * @param function_ - The function invoked per value. Receives (value, key).
  * @returns A new object with transformed values.
  *
+ * @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
  * mapValues({ a: 1, b: 2 }, (value) => value * 2);

package/module/es5/Object/mapValues.js

@@ -12,6 +12,16 @@ exports.mapValues = void 0;
  * @param function_ - The function invoked per value. Receives (value, key).
  * @returns A new object with transformed values.
  *
+ * @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
  * mapValues({ a: 1, b: 2 }, (value) => value * 2);

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

@@ -4,5 +4,15 @@ import type { UnionToIntersection } from "../types/logic/unionToIntersection";
  * @param target - The target object to merge into
  * @param sources - The source objects to merge from
  * @returns The merged object
+ *
+ * @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 merge: <T extends Record<string, unknown>, U extends Record<string, unknown>[]>(target: T, ...sources: U) => T & UnionToIntersection<U[number]>;