umt 2.6.0 → 2.8.0

package/module/es5/Math/percentile.js

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

package/module/es5/Math/solveEquation.js

@@ -70,7 +70,7 @@ var solveEquation = exports.solveEquation = function solveEquation(coefficients,
   }
 
   // Return the solution vector with values rounded to 1 decimal place
-  return solution.reverse().map(function (value) {
+  return solution.toReversed().map(function (value) {
     return (0, _roundOf.roundOf)(value, 1);
   });
 };

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

@@ -0,0 +1,14 @@
+/**
+ * Perform fuzzy string matching on an array of strings
+ * @param query - The search query
+ * @param items - Array of strings to search in
+ * @param threshold - Similarity threshold (0-1) for matching (default: 0.6)
+ * @returns Array of matching items with their similarity scores, sorted by best match
+ * @example
+ * fuzzySearch("hello", ["hello", "world", "helo", "help"]);
+ * // [{ item: "hello", score: 1 }, { item: "helo", score: 0.8 }, { item: "help", score: 0.6 }]
+ */
+export declare const fuzzySearch: (query: string, items: string[], threshold?: number) => Array<{
+    item: string;
+    score: number;
+}>;

package/module/es5/String/fuzzySearch.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fuzzySearch = void 0;
+var _levenshteinDistance = require("./levenshteinDistance");
+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; }
+/**
+ * Perform fuzzy string matching on an array of strings
+ * @param query - The search query
+ * @param items - Array of strings to search in
+ * @param threshold - Similarity threshold (0-1) for matching (default: 0.6)
+ * @returns Array of matching items with their similarity scores, sorted by best match
+ * @example
+ * fuzzySearch("hello", ["hello", "world", "helo", "help"]);
+ * // [{ item: "hello", score: 1 }, { item: "helo", score: 0.8 }, { item: "help", score: 0.6 }]
+ */
+var fuzzySearch = exports.fuzzySearch = function fuzzySearch(query, items) {
+  var threshold = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.6;
+  if (query.length === 0) {
+    return [];
+  }
+  var results = [];
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var distance = (0, _levenshteinDistance.levenshteinDistance)(query.toLowerCase(), item.toLowerCase());
+      var maxLength = Math.max(query.length, item.length);
+      var score = 1 - distance / maxLength;
+      if (score >= threshold) {
+        results.push({
+          item: item,
+          score: score
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return results.sort(function (a, b) {
+    return b.score - a.score;
+  });
+};

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

@@ -3,6 +3,7 @@ export * from "./deleteSpaces";
 export * from "./escapeHtml";
 export * from "./formatString";
 export * from "./fromBase64";
+export * from "./fuzzySearch";
 export * from "./hasNoLetters";
 export * from "./kebabCase";
 export * from "./levenshteinDistance";
@@ -11,9 +12,12 @@ export * from "./padStart";
 export * from "./randomString";
 export * from "./randomStringInitialization";
 export * from "./reverseString";
+export * from "./slugify";
 export * from "./stringSimilarity";
 export * from "./toBase64";
 export * from "./toHalfWidth";
 export * from "./trimCharacters";
 export * from "./trimEndCharacters";
 export * from "./trimStartCharacters";
+export * from "./truncate";
+export * from "./unescapeHtml";

package/module/es5/String/index.js

@@ -58,6 +58,17 @@ Object.keys(_fromBase).forEach(function (key) {
     }
   });
 });
+var _fuzzySearch = require("./fuzzySearch");
+Object.keys(_fuzzySearch).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fuzzySearch[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _fuzzySearch[key];
+    }
+  });
+});
 var _hasNoLetters = require("./hasNoLetters");
 Object.keys(_hasNoLetters).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -146,6 +157,17 @@ Object.keys(_reverseString).forEach(function (key) {
     }
   });
 });
+var _slugify = require("./slugify");
+Object.keys(_slugify).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _slugify[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _slugify[key];
+    }
+  });
+});
 var _stringSimilarity = require("./stringSimilarity");
 Object.keys(_stringSimilarity).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -211,4 +233,26 @@ Object.keys(_trimStartCharacters).forEach(function (key) {
       return _trimStartCharacters[key];
     }
   });
+});
+var _truncate = require("./truncate");
+Object.keys(_truncate).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _truncate[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _truncate[key];
+    }
+  });
+});
+var _unescapeHtml = require("./unescapeHtml");
+Object.keys(_unescapeHtml).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _unescapeHtml[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _unescapeHtml[key];
+    }
+  });
 });

package/module/es5/String/reverseString.js

@@ -11,5 +11,5 @@ exports.reverseString = void 0;
  * @example reverseString("Hello"); // "olleH"
  */
 var reverseString = exports.reverseString = function reverseString(_char) {
-  return _char.split("").reverse().join("");
+  return _char.split("").toReversed().join("");
 };

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

@@ -0,0 +1,10 @@
+/**
+ * Convert a string to a URL-friendly slug
+ * @param str - The string to convert
+ * @returns The slugified string
+ * @example
+ * slugify("Hello World!"); // "hello-world"
+ * slugify("This is a Test"); // "this-is-a-test"
+ * slugify("Japanese: こんにちは"); // "japanese"
+ */
+export declare const slugify: (string_: string) => string;

package/module/es5/String/slugify.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.slugify = void 0;
+/**
+ * Convert a string to a URL-friendly slug
+ * @param str - The string to convert
+ * @returns The slugified string
+ * @example
+ * slugify("Hello World!"); // "hello-world"
+ * slugify("This is a Test"); // "this-is-a-test"
+ * slugify("Japanese: こんにちは"); // "japanese"
+ */
+var slugify = exports.slugify = function slugify(string_) {
+  return string_.normalize("NFD").replaceAll(/[\u0300-\u036F]/g, "").toLowerCase().replaceAll(/[^\w\s-]/g, "-").replaceAll(/\s+/g, "-").replaceAll(/_+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-+|-+$/g, "");
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Truncate a string to a specified length
+ * @param str - The string to truncate
+ * @param length - The maximum length
+ * @param suffix - The suffix to add when truncating (default: "...")
+ * @returns The truncated string
+ * @example
+ * truncate("Hello World", 5); // "Hello..."
+ * truncate("Hello World", 5, "~"); // "Hello~"
+ * truncate("Hello", 10); // "Hello"
+ */
+export declare const truncate: (string_: string, length: number, suffix?: string) => string;

package/module/es5/String/truncate.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.truncate = void 0;
+/**
+ * Truncate a string to a specified length
+ * @param str - The string to truncate
+ * @param length - The maximum length
+ * @param suffix - The suffix to add when truncating (default: "...")
+ * @returns The truncated string
+ * @example
+ * truncate("Hello World", 5); // "Hello..."
+ * truncate("Hello World", 5, "~"); // "Hello~"
+ * truncate("Hello", 10); // "Hello"
+ */
+var truncate = exports.truncate = function truncate(string_, length) {
+  var suffix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "...";
+  if (length < 0) {
+    throw new Error("Length must be non-negative");
+  }
+  if (string_.length <= length) {
+    return string_;
+  }
+  return string_.slice(0, length) + suffix;
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Unescapes HTML entities in a string
+ * @param string_ - The string to unescape
+ * @returns The unescaped string with HTML entities converted back to their original characters
+ * @example
+ * ```typescript
+ * unescapeHtml("<script>alert("Hello");</script>");
+ * // Returns: "<script>alert("Hello");</script>"
+ *
+ * unescapeHtml("Tom &amp; Jerry");
+ * // Returns: "Tom & Jerry"
+ *
+ * unescapeHtml("5 &lt; 10 &amp;&amp; 10 &gt; 5");
+ * // Returns: "5 < 10 && 10 > 5"
+ * ```
+ */
+export declare const unescapeHtml: (string_: string) => string;

package/module/es5/String/unescapeHtml.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unescapeHtml = void 0;
+/**
+ * HTML entities map for unescaping
+ */
+var htmlUnescapeMap = {
+  "&": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#x2F;": "/",
+  "&#x60;": "`",
+  "&#x3D;": "="
+};
+
+/**
+ * Unescapes HTML entities in a string
+ * @param string_ - The string to unescape
+ * @returns The unescaped string with HTML entities converted back to their original characters
+ * @example
+ * ```typescript
+ * unescapeHtml("&lt;script&gt;alert(&quot;Hello&quot;);&lt;/script&gt;");
+ * // Returns: "<script>alert("Hello");</script>"
+ *
+ * unescapeHtml("Tom &amp; Jerry");
+ * // Returns: "Tom & Jerry"
+ *
+ * unescapeHtml("5 &lt; 10 &amp;&amp; 10 &gt; 5");
+ * // Returns: "5 < 10 && 10 > 5"
+ * ```
+ */
+var unescapeHtml = exports.unescapeHtml = function unescapeHtml(string_) {
+  var entityRegex = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D);|&#(\d*);|&#x([0-9a-fA-F]*);/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);
+    }
+    if (hex !== undefined) {
+      var _codePoint = Number.parseInt(hex, 16);
+      return Number.isNaN(_codePoint) ? match : String.fromCodePoint(_codePoint);
+    }
+    return htmlUnescapeMap[match];
+  });
+};

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

@@ -3,6 +3,7 @@ export * from "./boolean";
 export * from "./number";
 export * from "./object";
 export * from "./string";
+export * from "./isDeepEqual";
 export * from "./isArray";
 export * from "./isBrowser";
 export * from "./isBun";

package/module/es5/Validate/index.js

@@ -58,6 +58,17 @@ Object.keys(_string).forEach(function (key) {
     }
   });
 });
+var _isDeepEqual = require("./isDeepEqual");
+Object.keys(_isDeepEqual).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isDeepEqual[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _isDeepEqual[key];
+    }
+  });
+});
 var _isArray = require("./isArray");
 Object.keys(_isArray).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/isDeepEqual.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Options for isDeepEqual comparison
+ */
+export interface IsDeepEqualOptions {
+    /**
+     * Whether to ignore array order when comparing arrays
+     * @default true
+     */
+    strictOrder?: boolean;
+}
+/**
+ * Performs a deep equality comparison between two values
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @param options - Comparison options
+ * @returns true if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isDeepEqual({ a: 1, b: [2, 3] }, { b: [2, 3], a: 1 }); // true
+ * isDeepEqual([1, 2, 3], [3, 2, 1]); // false
+ * isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false }); // true
+ * isDeepEqual(new Set([1, 2]), new Set([2, 1])); // true
+ * isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]])); // true
+ * ```
+ */
+export declare function isDeepEqual(a: unknown, b: unknown, options?: IsDeepEqualOptions): boolean;

package/module/es5/Validate/isDeepEqual.js

@@ -0,0 +1,232 @@
+"use strict";
+
+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; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+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); }
+/**
+ * Options for isDeepEqual comparison
+ */
+
+/**
+ * Performs a deep equality comparison between two values
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @param options - Comparison options
+ * @returns true if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isDeepEqual({ a: 1, b: [2, 3] }, { b: [2, 3], a: 1 }); // true
+ * isDeepEqual([1, 2, 3], [3, 2, 1]); // false
+ * isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false }); // true
+ * isDeepEqual(new Set([1, 2]), new Set([2, 1])); // true
+ * isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]])); // true
+ * ```
+ */
+function isDeepEqual(a, b) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var _options$strictOrder = options.strictOrder,
+    strictOrder = _options$strictOrder === void 0 ? true : _options$strictOrder;
+  var visited = new WeakSet();
+  function compare(x, y) {
+    if (Object.is(x, y)) {
+      return true;
+    }
+    if (x == null || y == null) {
+      return false;
+    }
+    if (_typeof(x) !== _typeof(y)) {
+      return false;
+    }
+    if (_typeof(x) !== "object" || _typeof(y) !== "object") {
+      return false;
+    }
+    if (visited.has(x) || visited.has(y)) {
+      return true;
+    }
+    visited.add(x);
+    visited.add(y);
+    var ctorX = x.constructor;
+    var ctorY = y.constructor;
+    if (ctorX !== ctorY) {
+      return false;
+    }
+    if (x instanceof Date && y instanceof Date) {
+      return x.getTime() === y.getTime();
+    }
+    if (x instanceof RegExp && y instanceof RegExp) {
+      return x.toString() === y.toString();
+    }
+    if (Array.isArray(x) && Array.isArray(y)) {
+      if (x.length !== y.length) {
+        return false;
+      }
+      if (strictOrder) {
+        var _iterator = _createForOfIteratorHelper(x.entries()),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _slicedToArray(_step.value, 2),
+              index = _step$value[0],
+              element = _step$value[1];
+            if (!compare(element, y[index])) {
+              return false;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      } else {
+        var yCopy = _toConsumableArray(y);
+        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;
+              }
+            }
+            if (!found) {
+              return false;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return yCopy.length === 0;
+      }
+      return true;
+    }
+    if (x instanceof Set && y instanceof Set) {
+      if (x.size !== y.size) {
+        return false;
+      }
+      var _iterator3 = _createForOfIteratorHelper(x),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var item = _step3.value;
+          var _found = false;
+          var _iterator4 = _createForOfIteratorHelper(y),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var otherItem = _step4.value;
+              if (compare(item, otherItem)) {
+                _found = true;
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+          if (!_found) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return true;
+    }
+    if (x instanceof Map && y instanceof Map) {
+      if (x.size !== y.size) {
+        return false;
+      }
+      var _iterator5 = _createForOfIteratorHelper(x),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _step5$value = _slicedToArray(_step5.value, 2),
+            key = _step5$value[0],
+            value = _step5$value[1];
+          var _found2 = false;
+          var _iterator6 = _createForOfIteratorHelper(y),
+            _step6;
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var _step6$value = _slicedToArray(_step6.value, 2),
+                otherKey = _step6$value[0],
+                otherValue = _step6$value[1];
+              if (compare(key, otherKey) && compare(value, otherValue)) {
+                _found2 = true;
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+          if (!_found2) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return true;
+    }
+    if (ArrayBuffer.isView(x) && ArrayBuffer.isView(y)) {
+      var xArray = x;
+      var yArray = y;
+      if (xArray.byteLength !== yArray.byteLength) {
+        return false;
+      }
+      for (var _index2 = 0; _index2 < xArray.byteLength; _index2++) {
+        if (xArray[_index2] !== yArray[_index2]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    var keysX = Object.keys(x);
+    var keysY = Object.keys(y);
+    if (keysX.length !== keysY.length) {
+      return false;
+    }
+    for (var _i = 0, _keysX = keysX; _i < _keysX.length; _i++) {
+      var _key = _keysX[_i];
+      if (!(_key in y)) {
+        return false;
+      }
+    }
+    for (var _i2 = 0, _keysX2 = keysX; _i2 < _keysX2.length; _i2++) {
+      var _key2 = _keysX2[_i2];
+      if (!compare(x[_key2], y[_key2])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return compare(a, b);
+}

package/module/es5/Validate/isNode.js

@@ -4,13 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isNode = void 0;
+var _nodeProcess = _interopRequireDefault(require("node:process"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+// biome-ignore lint/correctness/noNodejsModules: ignore
+
 /**
  * Determines if the current environment is Node.js
  */
 var isNode = exports.isNode = function isNode() {
   try {
-    // biome-ignore lint/nursery/noProcessGlobal: ignore
-    return typeof process !== "undefined" && typeof require !== "undefined";
+    return _nodeProcess["default"] !== undefined && typeof require !== "undefined";
   } catch (_unused) {
     return false;
   }