umt 2.13.0 → 2.15.0

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

@@ -0,0 +1,9 @@
+/**
+ * Creates a new array of objects with prototype polluting properties removed
+ * from each item.
+ *
+ * @param objects - The objects to remove the prototype polluting properties
+ * from.
+ * @returns A new array with shallowly sanitized objects.
+ */
+export declare const removePrototypeMap: <T extends Record<string, unknown>>(objects: readonly T[]) => Omit<T, "__proto__" | "constructor" | "prototype">[];

package/module/es5/Object/removePrototypeMap.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removePrototypeMap = void 0;
+var _removePrototype = require("../Object/removePrototype");
+/**
+ * Creates a new array of objects with prototype polluting properties removed
+ * from each item.
+ *
+ * @param objects - The objects to remove the prototype polluting properties
+ * from.
+ * @returns A new array with shallowly sanitized objects.
+ */
+var removePrototypeMap = exports.removePrototypeMap = function removePrototypeMap(objects) {
+  return objects.map(function (object) {
+    return (0, _removePrototype.removePrototype)(object);
+  });
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Creates a new array of objects with prototype polluting properties removed
+ * recursively from each item.
+ *
+ * @param objects - The objects to remove the prototype polluting properties
+ * from recursively.
+ * @returns A new array with deeply sanitized objects.
+ */
+export declare const removePrototypeMapDeep: <T extends Record<string, unknown>>(objects: readonly T[]) => T[];

package/module/es5/Object/removePrototypeMapDeep.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removePrototypeMapDeep = void 0;
+var _removePrototypeDeep = require("../Object/removePrototypeDeep");
+/**
+ * Creates a new array of objects with prototype polluting properties removed
+ * recursively from each item.
+ *
+ * @param objects - The objects to remove the prototype polluting properties
+ * from recursively.
+ * @returns A new array with deeply sanitized objects.
+ */
+var removePrototypeMapDeep = exports.removePrototypeMapDeep = function removePrototypeMapDeep(objects) {
+  return objects.map(function (object) {
+    return (0, _removePrototypeDeep.removePrototypeDeep)(object);
+  });
+};

package/module/es5/String/escapeHtml.js

@@ -5,14 +5,23 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.escapeHtml = void 0;
 /**
- * HTML entities map for escaping
+ * HTML entities map for escaping.
+ *
+ * Security: The backtick (`) is included because it can be used as an HTML
+ * attribute delimiter in older browsers (e.g. IE), enabling XSS via
+ * constructs like <img src=`javascript:alert(1)`>. The forward slash (/)
+ * is included per OWASP XSS prevention recommendations to mitigate tag-
+ * closing injection (e.g. "</script>") when user input is embedded inside
+ * HTML elements.
  */
 var htmlEscapeMap = {
   "&": "&amp;",
   "<": "&lt;",
   ">": "&gt;",
   '"': "&quot;",
-  "'": "&#39;"
+  "'": "&#39;",
+  "`": "&#x60;",
+  "/": "&#x2F;"
 };
 
 /**
@@ -21,7 +30,7 @@ var htmlEscapeMap = {
  * @returns The escaped string
  */
 var escapeHtml = exports.escapeHtml = function escapeHtml(string_) {
-  return string_.replaceAll(/["&'<>]/g, function (match) {
+  return string_.replaceAll(/["&'/<>`]/g, function (match) {
     return htmlEscapeMap[match];
   });
 };

package/module/es5/String/formatString/applyFormatter.js

@@ -61,7 +61,7 @@ function applyFormatter(value, formatterString, formatters) {
  */
 function parseArguments(argumentsString) {
   var arguments_ = [];
-  var current = "";
+  var chars = [];
   var inQuotes = false;
   var quoteChar = "";
   var _iterator = _createForOfIteratorHelper(argumentsString),
@@ -80,12 +80,12 @@ function parseArguments(argumentsString) {
         continue;
       }
       if (!inQuotes && _char === ",") {
-        var _trimmed = current.trim();
+        var _trimmed = chars.join("").trim();
         arguments_.push(_trimmed === "" ? " " : _trimmed);
-        current = "";
+        chars.length = 0;
         continue;
       }
-      current += _char;
+      chars.push(_char);
     }
 
     // Handle last argument
@@ -94,7 +94,7 @@ function parseArguments(argumentsString) {
   } finally {
     _iterator.f();
   }
-  var trimmed = current.trim();
+  var trimmed = chars.join("").trim();
   arguments_.push(trimmed === "" ? " " : trimmed);
   return arguments_;
 }

package/module/es5/String/formatString/getValue.js

@@ -12,6 +12,9 @@ function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" ==
 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; }
+// Pre-compiled regex pattern for array index notation to avoid recompilation per path segment
+var ARRAY_INDEX_PATTERN = /^(.+?)\[(-?\d+)]$/;
+
 /**
  * Retrieves a value from an object using a dot-notation path with array index support.
  *
@@ -46,7 +49,7 @@ function getValue(object, path) {
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var part = _step.value;
-      var arrayMatch = /^(.+?)\[(-?\d+)]$/.exec(part);
+      var arrayMatch = ARRAY_INDEX_PATTERN.exec(part);
       if (arrayMatch) {
         var _arrayMatch = _slicedToArray(arrayMatch, 3),
           key = _arrayMatch[1],

package/module/es5/String/levenshteinDistance.js

@@ -11,52 +11,67 @@ exports.levenshteinDistance = void 0;
  * @param string2 - Second string to compare
  * @returns The Levenshtein distance
  */
-var _levenshteinDistance = exports.levenshteinDistance = function levenshteinDistance(string1, string2) {
+var levenshteinDistance = exports.levenshteinDistance = function levenshteinDistance(string1, string2) {
   if (string1 === string2) {
     return 0;
   }
-  var length1 = string1.length;
-  var length2 = string2.length;
-  if (length1 === 0) {
-    return length2;
+  var _short = string1;
+  var _long = string2;
+  var shortLength = _short.length;
+  var longLength = _long.length;
+  if (shortLength === 0) {
+    return longLength;
   }
-  if (length2 === 0) {
-    return length1;
+  if (longLength === 0) {
+    return shortLength;
   }
 
-  // Ensure string1 is the shorter string to minimize space complexity to O(min(N, M))
-  if (length1 > length2) {
-    return _levenshteinDistance(string2, string1);
+  // Ensure short is the shorter string to minimize space complexity to O(min(N, M))
+  if (shortLength > longLength) {
+    _short = string2;
+    _long = string1;
+    shortLength = _short.length;
+    longLength = _long.length;
   }
 
   // Create a single row array to store distances
   // We only need the current row and the previous diagonal value
   var row = Array.from({
-    length: length1 + 1
+    length: shortLength + 1
   });
 
-  // Initialize first row (0 to length1)
-  for (var index = 0; index <= length1; index++) {
+  // Initialize first row (0 to shortLength)
+  for (var index = 0; index <= shortLength; index++) {
     row[index] = index;
   }
 
-  // Iterate through each character of string2
-  for (var _index = 1; _index <= length2; _index++) {
-    var previousDiagonal = row[0]; // Stores the value of matrix[i-1][j-1]
-    row[0] = _index; // Update first element for the new row (matrix[0][j])
+  // Iterate through each character of the longer string (rows)
+  for (var rowIndex = 1; rowIndex <= longLength; rowIndex++) {
+    var previousDiagonal = row[0];
+    row[0] = rowIndex;
 
-    var char2 = string2[_index - 1];
-    for (var _index2 = 1; _index2 <= length1; _index2++) {
-      var temporary = row[_index2]; // Store current value to become prevDiagonal for next iteration
-      var cost = string1[_index2 - 1] === char2 ? 0 : 1;
-      row[_index2] = Math.min(row[_index2] + 1,
-      // deletion (value from previous row, same column)
-      row[_index2 - 1] + 1,
-      // insertion (value from current row, previous column)
-      previousDiagonal + cost // substitution (value from previous row, previous column)
-      );
+    // eslint-disable-next-line unicorn/prefer-code-point
+    var charCode = _long.charCodeAt(rowIndex - 1);
+    for (var colIndex = 1; colIndex <= shortLength; colIndex++) {
+      var temporary = row[colIndex];
+      // eslint-disable-next-line unicorn/prefer-code-point
+      var cost = _short.charCodeAt(colIndex - 1) === charCode ? 0 : 1;
+
+      // Inline min of three values instead of Math.min() call to avoid
+      // function-call overhead in this hot loop
+      var deletion = row[colIndex] + 1;
+      var insertion = row[colIndex - 1] + 1;
+      var substitution = previousDiagonal + cost;
+      var value = deletion;
+      if (insertion < value) {
+        value = insertion;
+      }
+      if (substitution < value) {
+        value = substitution;
+      }
+      row[colIndex] = value;
       previousDiagonal = temporary;
     }
   }
-  return row[length1];
+  return row[shortLength];
 };

package/module/es5/String/slugify.js

@@ -14,5 +14,12 @@ exports.slugify = void 0;
  * slugify("Japanese: こんにちは"); // "japanese"
  */
 var slugify = exports.slugify = function slugify(string_) {
-  return string_.normalize("NFD").replaceAll(/[\u0300-\u036F]/g, "").toLowerCase().replaceAll(/[^\s\w-]/g, "-").replaceAll(/\s+/g, "-").replaceAll(/_+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-+|-+$/g, "");
+  return string_.normalize("NFD")
+  // Strip combining diacritical marks (e.g. accents)
+  .replaceAll(/[\u0300-\u036F]/g, "").toLowerCase()
+  // Consolidate non-word chars, whitespace, and underscores into a single
+  // hyphen in one pass instead of three separate regex scans
+  .replaceAll(/[^\w-]+|_+/g, "-")
+  // Collapse consecutive hyphens and strip leading/trailing hyphens
+  .replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
 };

package/module/es5/String/trimEndCharacters.js

@@ -18,8 +18,10 @@ exports.trimEndCharacters = void 0;
  * ```
  */
 var trimEndCharacters = exports.trimEndCharacters = function trimEndCharacters(string_, chars) {
+  // Use Set for O(1) character lookups instead of O(m) string.includes()
+  var charSet = new Set(chars);
   var endIndex = string_.length - 1;
-  while (endIndex >= 0 && chars.includes(string_[endIndex])) {
+  while (endIndex >= 0 && charSet.has(string_[endIndex])) {
     endIndex--;
   }
   return string_.slice(0, endIndex + 1);

package/module/es5/String/trimStartCharacters.js

@@ -18,8 +18,10 @@ exports.trimStartCharacters = void 0;
  * ```
  */
 var trimStartCharacters = exports.trimStartCharacters = function trimStartCharacters(string_, chars) {
+  // Use Set for O(1) character lookups instead of O(m) string.includes()
+  var charSet = new Set(chars);
   var startIndex = 0;
-  while (startIndex < string_.length && chars.includes(string_[startIndex])) {
+  while (startIndex < string_.length && charSet.has(string_[startIndex])) {
     startIndex++;
   }
   return string_.slice(startIndex);

package/module/es5/String/unescapeHtml.d.ts

@@ -5,7 +5,7 @@
  * @example
  * ```typescript
  * unescapeHtml("<script>alert("Hello");</script>");
- * // Returns: "<script>alert("Hello");</script>"
+ * // Returns: "<script>alert(\"Hello\");</script>"
  *
  * unescapeHtml("Tom &amp; Jerry");
  * // Returns: "Tom & Jerry"

package/module/es5/String/unescapeHtml.js

@@ -19,6 +19,34 @@ var htmlUnescapeMap = {
   "=": "="
 };
 
+/**
+ * Security: Checks whether a numeric code point is safe to decode.
+ * Rejects NULL (0), C0 control chars (1-31 except TAB 9, LF 10, CR 13),
+ * DEL (127), C1 control chars (128-159), lone surrogates (0xD800-0xDFFF),
+ * and values beyond the Unicode maximum (>0x10FFFF).
+ */
+var isSafeCodePoint = function isSafeCodePoint(codePoint) {
+  if (codePoint > 0x10ffff) {
+    return false;
+  }
+  if (codePoint === 0) {
+    return false;
+  }
+  if (codePoint >= 0xd800 && codePoint <= 0xdfff) {
+    return false;
+  }
+  if (codePoint <= 0x1f && codePoint !== 0x09 && codePoint !== 0x0a && codePoint !== 0x0d) {
+    return false;
+  }
+  if (codePoint === 0x7f) {
+    return false;
+  }
+  if (codePoint >= 0x80 && codePoint <= 0x9f) {
+    return false;
+  }
+  return true;
+};
+
 /**
  * Unescapes HTML entities in a string
  * @param string_ - The string to unescape
@@ -26,7 +54,7 @@ var htmlUnescapeMap = {
  * @example
  * ```typescript
  * unescapeHtml("&lt;script&gt;alert(&quot;Hello&quot;);&lt;/script&gt;");
- * // Returns: "<script>alert("Hello");</script>"
+ * // Returns: "<script>alert(\"Hello\");</script>"
  *
  * unescapeHtml("Tom &amp; Jerry");
  * // Returns: "Tom & Jerry"
@@ -36,15 +64,29 @@ var htmlUnescapeMap = {
  * ```
  */
 var unescapeHtml = exports.unescapeHtml = function unescapeHtml(string_) {
-  var entityRegex = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D);|&#(\d*);|&#x([\dA-Fa-f]*);/g;
+  var entityRegex = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D);|&#(\d{1,7});|&#x([\dA-Fa-f]{1,6});/g;
   return string_.replaceAll(entityRegex, function (match, dec, hex) {
     if (dec !== undefined) {
       var codePoint = Number.parseInt(dec, 10);
-      return Number.isNaN(codePoint) ? match : String.fromCodePoint(codePoint);
+      // Security: reject dangerous code points to prevent injection attacks.
+      // NULL bytes (0) enable null-byte injection that can truncate strings in
+      // downstream systems. C0 control chars (1-31 except TAB/LF/CR) and the
+      // DEL char (127) can break parsers. C1 control chars (128-159) are
+      // invalid in HTML. Surrogate code points (0xD800-0xDFFF) produce
+      // malformed strings. Out-of-range values (>0x10FFFF) are not valid
+      // Unicode. Leave these entity references unmodified rather than decoding
+      // them into potentially dangerous characters.
+      if (!isSafeCodePoint(codePoint)) {
+        return match;
+      }
+      return String.fromCodePoint(codePoint);
     }
     if (hex !== undefined) {
       var _codePoint = Number.parseInt(hex, 16);
-      return Number.isNaN(_codePoint) ? match : String.fromCodePoint(_codePoint);
+      if (!isSafeCodePoint(_codePoint)) {
+        return match;
+      }
+      return String.fromCodePoint(_codePoint);
     }
     return htmlUnescapeMap[match];
   });

package/module/es5/Tool/parseJson.js

@@ -4,6 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseJson = void 0;
+// Security: Keys that must be stripped during JSON parsing to prevent
+// prototype pollution. If an attacker controls the JSON input, they can
+// embed keys like "__proto__" which, when the parsed object is later
+// spread or merged (e.g. via Object.assign, spread operator, or any
+// deep-merge utility), can overwrite properties on Object.prototype
+// and affect all objects in the runtime.
+var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
 /**
  * Parses a JSON string into a typed JavaScript value
  * @template T The expected type of the parsed value (defaults to unknown)
@@ -12,5 +20,10 @@ exports.parseJson = void 0;
  * @throws {SyntaxError} If the JSON string is invalid
  */
 var parseJson = exports.parseJson = function parseJson(json) {
-  return JSON.parse(json);
+  return JSON.parse(json, function (key, value) {
+    if (DANGEROUS_KEYS.has(key)) {
+      return;
+    }
+    return value;
+  });
 };

package/module/es5/URL/buildUrl.js

@@ -25,6 +25,10 @@ var buildUrl = exports.buildUrl = function buildUrl(base) {
   var url = new URL(base);
   for (var _i = 0, _Object$keys = Object.keys(parameters); _i < _Object$keys.length; _i++) {
     var key = _Object$keys[_i];
+    // Prevent prototype pollution by rejecting dangerous keys
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
     url.searchParams.append(key, parameters[key]);
   }
   return url.toString();

package/module/es5/URL/parseQueryString.js

@@ -46,6 +46,10 @@ var parseQueryString = exports.parseQueryString = function parseQueryString(quer
       var _step$value = _slicedToArray(_step.value, 2),
         key = _step$value[0],
         value = _step$value[1];
+      // Prevent prototype pollution by rejecting dangerous keys
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        continue;
+      }
       result[key] = value;
     }
   } catch (err) {

package/module/es5/Validate/isDeepEqual.js

@@ -4,10 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isDeepEqual = isDeepEqual;
-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 _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; } }
@@ -93,19 +89,32 @@ function isDeepEqual(a, b) {
           _iterator.f();
         }
       } else {
-        var yCopy = _toConsumableArray(y);
+        // Performance: Use Set<number> to track matched indices instead of
+        // splice(), avoiding O(n) array shifts per removal (O(n²) → O(n)).
+        var usedIndices = new Set();
         var _iterator2 = _createForOfIteratorHelper(x),
           _step2;
         try {
           for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
             var itemX = _step2.value;
             var found = false;
-            for (var _index = 0; _index < yCopy.length; _index++) {
-              if (compare(itemX, yCopy[_index])) {
-                yCopy.splice(_index, 1);
-                found = true;
-                break;
+            var _iterator3 = _createForOfIteratorHelper(y.entries()),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _step3$value = _slicedToArray(_step3.value, 2),
+                  _index = _step3$value[0],
+                  itemY = _step3$value[1];
+                if (!usedIndices.has(_index) && compare(itemX, itemY)) {
+                  usedIndices.add(_index);
+                  found = true;
+                  break;
+                }
               }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
             }
             if (!found) {
               return false;
@@ -116,7 +125,7 @@ function isDeepEqual(a, b) {
         } finally {
           _iterator2.f();
         }
-        return yCopy.length === 0;
+        return usedIndices.size === y.length;
       }
       return true;
     }
@@ -124,35 +133,35 @@ function isDeepEqual(a, b) {
       if (x.size !== y.size) {
         return false;
       }
-      var _iterator3 = _createForOfIteratorHelper(x),
-        _step3;
+      var _iterator4 = _createForOfIteratorHelper(x),
+        _step4;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var item = _step3.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var item = _step4.value;
           var _found = false;
-          var _iterator4 = _createForOfIteratorHelper(y),
-            _step4;
+          var _iterator5 = _createForOfIteratorHelper(y),
+            _step5;
           try {
-            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              var otherItem = _step4.value;
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var otherItem = _step5.value;
               if (compare(item, otherItem)) {
                 _found = true;
                 break;
               }
             }
           } catch (err) {
-            _iterator4.e(err);
+            _iterator5.e(err);
           } finally {
-            _iterator4.f();
+            _iterator5.f();
           }
           if (!_found) {
             return false;
           }
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
       return true;
     }
@@ -160,39 +169,39 @@ function isDeepEqual(a, b) {
       if (x.size !== y.size) {
         return false;
       }
-      var _iterator5 = _createForOfIteratorHelper(x),
-        _step5;
+      var _iterator6 = _createForOfIteratorHelper(x),
+        _step6;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var _step5$value = _slicedToArray(_step5.value, 2),
-            key = _step5$value[0],
-            value = _step5$value[1];
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _step6$value = _slicedToArray(_step6.value, 2),
+            key = _step6$value[0],
+            value = _step6$value[1];
           var _found2 = false;
-          var _iterator6 = _createForOfIteratorHelper(y),
-            _step6;
+          var _iterator7 = _createForOfIteratorHelper(y),
+            _step7;
           try {
-            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-              var _step6$value = _slicedToArray(_step6.value, 2),
-                otherKey = _step6$value[0],
-                otherValue = _step6$value[1];
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var _step7$value = _slicedToArray(_step7.value, 2),
+                otherKey = _step7$value[0],
+                otherValue = _step7$value[1];
               if (compare(key, otherKey) && compare(value, otherValue)) {
                 _found2 = true;
                 break;
               }
             }
           } catch (err) {
-            _iterator6.e(err);
+            _iterator7.e(err);
           } finally {
-            _iterator6.f();
+            _iterator7.f();
           }
           if (!_found2) {
             return false;
           }
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
       return true;
     }

package/module/es5/Validate/isPrimeNumber.js

@@ -18,8 +18,20 @@ var isPrimeNumber = exports.isPrimeNumber = function isPrimeNumber(n) {
   if (n <= 1 || !Number.isInteger(n)) {
     return false;
   }
-  for (var index = 2; index <= Math.sqrt(n); index++) {
-    if (n % index === 0) {
+
+  // Handle small primes and eliminate even numbers / multiples of 3 early
+  if (n <= 3) {
+    return true;
+  }
+  if (n % 2 === 0 || n % 3 === 0) {
+    return false;
+  }
+
+  // Performance: only test divisors of the form 6k +/- 1.
+  // All primes > 3 are of this form, so we skip ~2/3 of candidates
+  // compared to the naive loop that checks every integer from 2 to sqrt(n).
+  for (var index = 5; index * index <= n; index += 6) {
+    if (n % index === 0 || n % (index + 2) === 0) {
       return false;
     }
   }

package/module/es5/Validate/object/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./core";
+export * from "./intersection";
 export * from "./optional";
+export * from "./union";

package/module/es5/Validate/object/index.js

@@ -14,6 +14,17 @@ Object.keys(_core).forEach(function (key) {
     }
   });
 });
+var _intersection = require("./intersection");
+Object.keys(_intersection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _intersection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _intersection[key];
+    }
+  });
+});
 var _optional = require("./optional");
 Object.keys(_optional).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -24,4 +35,15 @@ Object.keys(_optional).forEach(function (key) {
       return _optional[key];
     }
   });
+});
+var _union = require("./union");
+Object.keys(_union).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _union[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _union[key];
+    }
+  });
 });