umt 2.10.1 → 2.12.0

package/module/es5/Array/insertionSort.js

@@ -5,6 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.insertionSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+var _insertionSortRange = require("./sortingHelpers/insertionSortRange");
+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; }
 /**
  * Sort an array using insertion sort algorithm
  *
@@ -30,14 +37,7 @@ var insertionSort = exports.insertionSort = function insertionSort(array) {
   var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
   var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
-  for (var index = start + 1; index <= end; index++) {
-    var index_ = index;
-    var target = array[index];
-    while (index_ > start && compareFunction(array[index_ - 1], target) > 0) {
-      array[index_] = array[index_ - 1];
-      index_--;
-    }
-    array[index_] = target;
-  }
-  return array;
+  var result = _toConsumableArray(array);
+  (0, _insertionSortRange.insertionSortRange)(result, compareFunction, start, end);
+  return result;
 };

package/module/es5/Array/quickSort.js

@@ -7,6 +7,12 @@ exports.quickSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
 var _applyInsertionSortIfNeeded = require("./sortingHelpers/applyInsertionSortIfNeeded");
 var _rangeValidator = require("./sortingHelpers/rangeValidator");
+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; }
 /**
  * Finds the median value among three elements in the array
  * @param array The array containing the elements
@@ -110,12 +116,13 @@ var quickSort = exports.quickSort = function quickSort(array) {
   var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
   var insertionSortThreshold = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
-  var _validateRange = (0, _rangeValidator.validateRange)(array, startIndex, endIndex),
+  var result = _toConsumableArray(array);
+  var _validateRange = (0, _rangeValidator.validateRange)(result, startIndex, endIndex),
     validStartIndex = _validateRange.startIndex,
     validEndIndex = _validateRange.endIndex,
     shouldSort = _validateRange.shouldSort;
   if (shouldSort) {
-    _sortImpl(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+    _sortImpl(result, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
   }
-  return array;
+  return result;
 };

package/module/es5/Array/range.js

@@ -22,7 +22,7 @@ var range = exports.range = function range(start, end) {
     return array;
   }
   var actualStart = end === undefined ? 0 : start;
-  var actualEnd = end === undefined ? start : end;
+  var actualEnd = end !== null && end !== void 0 ? end : start;
 
   // Return empty array if invalid range
   if (step > 0 && actualStart >= actualEnd || step < 0 && actualStart <= actualEnd) {

package/module/es5/Array/sortingHelpers/applyInsertionSortIfNeeded.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applyInsertionSortIfNeeded = void 0;
-var _insertionSort = require("@/Array/insertionSort");
+var _insertionSortRange = require("./insertionSortRange");
 /**
  * Checks if a partition is small enough to apply insertion sort and applies it if so.
  *
@@ -18,7 +18,7 @@ var _insertionSort = require("@/Array/insertionSort");
  */
 var applyInsertionSortIfNeeded = exports.applyInsertionSortIfNeeded = function applyInsertionSortIfNeeded(array, low, high, compareFunction, insertionSortThreshold) {
   if (high - low + 1 <= insertionSortThreshold) {
-    (0, _insertionSort.insertionSort)(array, compareFunction, low, high);
+    (0, _insertionSortRange.insertionSortRange)(array, compareFunction, low, high);
     return true;
   }
   return false;

package/module/es5/Array/sortingHelpers/insertionSortRange.d.ts

@@ -0,0 +1,5 @@
+import type { CompareFunction } from "$/array/compareFunction";
+/**
+ * @internal
+ */
+export declare const insertionSortRange: <T>(array: T[], compareFunction: CompareFunction<T>, start: number, end: number) => void;

package/module/es5/Array/sortingHelpers/insertionSortRange.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertionSortRange = void 0;
+/**
+ * @internal
+ */
+var insertionSortRange = exports.insertionSortRange = function insertionSortRange(array, compareFunction, start, end) {
+  for (var index = start + 1; index <= end; index++) {
+    var index_ = index;
+    var target = array[index];
+    while (index_ > start && compareFunction(array[index_ - 1], target) > 0) {
+      array[index_] = array[index_ - 1];
+      index_--;
+    }
+    array[index_] = target;
+  }
+};

package/module/es5/Array/timSort.js

@@ -5,7 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.timSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
-var _insertionSort = require("@/Array/insertionSort");
+var _insertionSortRange = require("./sortingHelpers/insertionSortRange");
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 var MIN_RUN = 32;
 
 /**
@@ -79,19 +85,21 @@ var timSort = exports.timSort = function timSort(array) {
   var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
   var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
+  var result = _toConsumableArray(array);
   var n = end - start + 1;
   var minRun = getMinRunLength(n);
-  for (var index = start; index <= end; index += minRun) {
-    (0, _insertionSort.insertionSort)(array, compareFunction, index, Math.min(index + MIN_RUN - 1, end));
+  for (var runStart = start; runStart <= end; runStart += minRun) {
+    var runEnd = Math.min(runStart + minRun - 1, end);
+    (0, _insertionSortRange.insertionSortRange)(result, compareFunction, runStart, runEnd);
   }
   for (var size = minRun; size < n; size *= 2) {
     for (var left = start; left <= end; left += 2 * size) {
       var mid = left + size - 1;
       var right = Math.min(left + 2 * size - 1, end);
       if (mid < right) {
-        merge(array, left, mid, right, compareFunction);
+        merge(result, left, mid, right, compareFunction);
       }
     }
   }
-  return array;
+  return result;
 };

package/module/es5/Array/ultraNumberSort.js

@@ -5,7 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ultraNumberSort = void 0;
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _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; }
 /**
  * Ultra-fast sorting specifically optimized for number arrays
@@ -15,32 +19,33 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  */
 var ultraNumberSort = exports.ultraNumberSort = function ultraNumberSort(array) {
   var ascending = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  var length = array.length;
+  var result = _toConsumableArray(array);
+  var length = result.length;
   if (length <= 1) {
-    return array;
+    return result;
   }
 
   // For tiny arrays, use optimized inline sort
   if (length === 2) {
-    if (array[0] > array[1] === ascending) {
-      var _ref = [array[1], array[0]];
-      array[0] = _ref[0];
-      array[1] = _ref[1];
+    if (result[0] > result[1] === ascending) {
+      var _ref = [result[1], result[0]];
+      result[0] = _ref[0];
+      result[1] = _ref[1];
     }
-    return array;
+    return result;
   }
   if (length === 3) {
-    inlineSort3(array, ascending);
-    return array;
+    inlineSort3(result, ascending);
+    return result;
   }
 
   // Check if all numbers are integers and find range
   var allIntegers = true;
-  var min = array[0];
-  var max = array[0];
+  var min = result[0];
+  var max = result[0];
   var hasNaN = false;
   for (var index = 0; index < length; index++) {
-    var value = array[index];
+    var value = result[index];
     // biome-ignore lint/suspicious/noSelfCompare: ignore
     if (value !== value) {
       hasNaN = true;
@@ -59,21 +64,21 @@ var ultraNumberSort = exports.ultraNumberSort = function ultraNumberSort(array)
 
   // Handle NaN values
   if (hasNaN) {
-    return handleNaNSort(array, ascending);
+    return handleNaNSort(result, ascending);
   }
 
   // For small integer ranges, use counting sort
   if (allIntegers && max - min < length * 2 && max - min < 1000000) {
-    return countingSort(array, min, max, ascending);
+    return countingSort(result, min, max, ascending);
   }
 
   // For larger arrays, use radix sort if applicable
   if (allIntegers && length > 100) {
-    return radixSort(array, ascending);
+    return radixSort(result, ascending);
   }
 
   // Fall back to optimized quicksort for floating point
-  return numericQuickSort(array, 0, length - 1, ascending);
+  return numericQuickSort(result, 0, length - 1, ascending);
 };
 
 /**
@@ -185,15 +190,15 @@ var countingSort = function countingSort(array, min, max, ascending) {
     for (var index_ = 0; index_ < range; index_++) {
       var cnt = count[index_];
       var value = index_ + min;
-      for (var _index_ = 0; _index_ < cnt; _index_++) {
+      for (var index__ = 0; index__ < cnt; index__++) {
         array[index++] = value;
       }
     }
   } else {
-    for (var _index_2 = range - 1; _index_2 >= 0; _index_2--) {
-      var _cnt = count[_index_2];
-      var _value = _index_2 + min;
-      for (var _index_3 = 0; _index_3 < _cnt; _index_3++) {
+    for (var _index_ = range - 1; _index_ >= 0; _index_--) {
+      var _cnt = count[_index_];
+      var _value = _index_ + min;
+      for (var _index__ = 0; _index__ < _cnt; _index__++) {
         array[index++] = _value;
       }
     }
@@ -235,11 +240,11 @@ var radixSort = function radixSort(array, ascending) {
   var index = 0;
   if (ascending) {
     // Negative numbers first (in reverse order)
-    for (var _index_4 = negative.length - 1; _index_4 >= 0; _index_4--) {
-      array[index++] = -negative[_index_4];
+    for (var _index_2 = negative.length - 1; _index_2 >= 0; _index_2--) {
+      array[index++] = -negative[_index_2];
     }
     // Zeros
-    for (var _index_5 = 0; _index_5 < zeroCount; _index_5++) {
+    for (var _index_3 = 0; _index_3 < zeroCount; _index_3++) {
       array[index++] = 0;
     }
     // Positive numbers
@@ -257,11 +262,11 @@ var radixSort = function radixSort(array, ascending) {
     }
   } else {
     // Positive numbers first (in reverse order)
-    for (var _index_6 = positive.length - 1; _index_6 >= 0; _index_6--) {
-      array[index++] = positive[_index_6];
+    for (var _index_4 = positive.length - 1; _index_4 >= 0; _index_4--) {
+      array[index++] = positive[_index_4];
     }
     // Zeros
-    for (var _index_7 = 0; _index_7 < zeroCount; _index_7++) {
+    for (var _index_5 = 0; _index_5 < zeroCount; _index_5++) {
       array[index++] = 0;
     }
     // Negative numbers
@@ -335,8 +340,7 @@ var radixSortPositive = function radixSortPositive(array) {
  * Optimized quicksort for numbers
  */
 var numericQuickSort = function numericQuickSort(array, low, high, ascending) {
-  var stack = [];
-  stack.push(low, high);
+  var stack = [low, high];
   while (stack.length > 0) {
     var h = stack.pop();
     var l = stack.pop();
@@ -380,12 +384,12 @@ var numericInsertionSort = function numericInsertionSort(array, low, high, ascen
   } else {
     for (var _index6 = low + 1; _index6 <= high; _index6++) {
       var _key = array[_index6];
-      var _index_8 = _index6 - 1;
-      while (_index_8 >= low && array[_index_8] < _key) {
-        array[_index_8 + 1] = array[_index_8];
-        _index_8--;
+      var _index_6 = _index6 - 1;
+      while (_index_6 >= low && array[_index_6] < _key) {
+        array[_index_6 + 1] = array[_index_6];
+        _index_6--;
       }
-      array[_index_8 + 1] = _key;
+      array[_index_6 + 1] = _key;
     }
   }
 };

package/module/es5/Color/hexaToRgba.d.ts

@@ -2,7 +2,7 @@
  * Convert hexadecimal color code to RGBA color values
  * @param hex Hexadecimal color code (3, 6, or 8 digits with #)
  * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
- * @example hexToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
+ * @example hexaToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
  * @throws {Error} If the hex code format is invalid
  */
 export declare const hexaToRgba: (hex: string) => {

package/module/es5/Color/hexaToRgba.js

@@ -10,7 +10,7 @@ var _roundOf = require("@/Math/roundOf");
  * Convert hexadecimal color code to RGBA color values
  * @param hex Hexadecimal color code (3, 6, or 8 digits with #)
  * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
- * @example hexToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
+ * @example hexaToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
  * @throws {Error} If the hex code format is invalid
  */
 var hexaToRgba = exports.hexaToRgba = function hexaToRgba(hex) {

package/module/es5/Consts/clock.d.ts

@@ -1,7 +1,7 @@
 /**
  * Number of milliseconds in one second
  */
-export declare const OneSecondMs: 1000;
+export declare const OneSecondMs = 1000;
 /**
  * Number of milliseconds in one minute
  */

package/module/es5/Crypto/decodeBase58.js

@@ -19,7 +19,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  */
 var decodeBase58 = exports.decodeBase58 = function decodeBase58(input) {
   var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-  var bigNumber = BigInt(0);
+  var bigNumber = 0n;
   var _iterator = _createForOfIteratorHelper(input),
     _step;
   try {
@@ -29,7 +29,7 @@ var decodeBase58 = exports.decodeBase58 = function decodeBase58(input) {
       if (value === -1) {
         throw new Error("Invalid base58 character: ".concat(_char));
       }
-      bigNumber = bigNumber * BigInt(58) + BigInt(value);
+      bigNumber = bigNumber * 58n + BigInt(value);
     }
   } catch (err) {
     _iterator.e(err);
@@ -38,8 +38,8 @@ var decodeBase58 = exports.decodeBase58 = function decodeBase58(input) {
   }
   var bytes = [];
   while (bigNumber > 0) {
-    bytes.unshift(Number(bigNumber % BigInt(256)));
-    bigNumber /= BigInt(256);
+    bytes.unshift(Number(bigNumber % 256n));
+    bigNumber /= 256n;
   }
   var leadingOnes = 0;
   var _iterator2 = _createForOfIteratorHelper(input),

package/module/es5/Crypto/encodeBase58.js

@@ -17,13 +17,13 @@ var encodeBase58 = exports.encodeBase58 = function encodeBase58(input) {
   var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
   var bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
   var encoded = "";
-  var bigNumber = BigInt(0);
+  var bigNumber = 0n;
   var _iterator = _createForOfIteratorHelper(bytes),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var _byte = _step.value;
-      bigNumber = bigNumber * BigInt(256) + BigInt(_byte);
+      bigNumber = bigNumber * 256n + BigInt(_byte);
     }
   } catch (err) {
     _iterator.e(err);
@@ -31,9 +31,9 @@ var encodeBase58 = exports.encodeBase58 = function encodeBase58(input) {
     _iterator.f();
   }
   while (bigNumber > 0) {
-    var remainder = Number(bigNumber % BigInt(58));
+    var remainder = Number(bigNumber % 58n);
     encoded = alphabet[remainder] + encoded;
-    bigNumber /= BigInt(58);
+    bigNumber /= 58n;
   }
   var leadingZeros = 0;
   var _iterator2 = _createForOfIteratorHelper(bytes),

package/module/es5/DataStructure/priorityQueue.d.ts

@@ -64,10 +64,10 @@ export declare class PriorityQueue<T> {
      * ]);
      * ```
      */
-    constructor(initialElements?: Array<{
+    constructor(initialElements?: {
         value: T;
         priority: number;
-    }>);
+    }[]);
     /**
      * Returns the number of elements in the queue.
      * @returns The number of elements in the queue
@@ -205,10 +205,10 @@ export declare class PriorityQueue<T> {
      * // [{ value: "high", priority: 10 }, { value: "low", priority: 1 }] (order may vary)
      * ```
      */
-    toArrayWithPriorities(): Array<{
+    toArrayWithPriorities(): {
         value: T;
         priority: number;
-    }>;
+    }[];
     /**
      * Updates the minimum priority when adding elements.
      * @param priority - The priority being added

package/module/es5/DataStructure/priorityQueue.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PriorityQueue = void 0;
+var _unwrap = require("@/Tool/unwrap");
 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 _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."); }
@@ -204,8 +205,8 @@ var PriorityQueue = exports.PriorityQueue = /*#__PURE__*/function () {
         return (_this$heap$pop = this.heap.pop()) === null || _this$heap$pop === void 0 ? void 0 : _this$heap$pop.value;
       }
       var result = this.heap[0].value;
-      // biome-ignore lint/style/noNonNullAssertion: pop() cannot return undefined when heap.length > 1
-      this.heap[0] = this.heap.pop();
+      // pop() cannot return undefined when heap.length > 1
+      this.heap[0] = (0, _unwrap.unwrap)(this.heap.pop(), "panic: heap is empty");
       this.heapifyDown(0);
       return result;
     }

package/module/es5/Date/dayOfWeek.js

@@ -17,7 +17,8 @@ var dayOfWeek = exports.dayOfWeek = function dayOfWeek(properties) {
   var timeDifference = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 9;
   var nowTime = (0, _now.now)(timeDifference);
   if (properties) {
-    return (0, _new.newDateInt)(properties.year || nowTime.getFullYear(), properties.mon || nowTime.getMonth() + 1, properties.day || nowTime.getDate()).getDay();
+    var _properties$year, _properties$mon, _properties$day;
+    return (0, _new.newDateInt)((_properties$year = properties.year) !== null && _properties$year !== void 0 ? _properties$year : nowTime.getFullYear(), (_properties$mon = properties.mon) !== null && _properties$mon !== void 0 ? _properties$mon : nowTime.getMonth() + 1, (_properties$day = properties.day) !== null && _properties$day !== void 0 ? _properties$day : nowTime.getDate()).getDay();
   }
   return nowTime.getDay();
 };

package/module/es5/Date/format.js

@@ -77,6 +77,6 @@ var format = exports.format = function format(date) {
     ZZ: timezoneOffsetString.replace(":", "")
   };
   return formatString.replaceAll(/\[([^\]]+)]|(Y{1,4}|M{1,2}|D{1,2}|d{1,2}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS)/g, function (_match, $1, $2) {
-    return $1 || matches[$2];
+    return $1 !== null && $1 !== void 0 ? $1 : matches[$2];
   });
 };

package/module/es5/IP/ipToBinaryString.js

@@ -34,7 +34,7 @@ var ipToBinaryString = exports.ipToBinaryString = function ipToBinaryString(ip)
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var octet = _step.value;
       // Check for empty octet or leading zeros
-      if (!octet || octet.length > 1 && octet[0] === "0") {
+      if (!octet || octet.length > 1 && octet.startsWith("0")) {
         throw new Error("Invalid IP address format");
       }
       var number = Number.parseInt(octet, 10);

package/module/es5/IP/subnetMaskToCidr.js

@@ -33,7 +33,7 @@ var subnetMaskToCidr = exports.subnetMaskToCidr = function subnetMaskToCidr(subn
 
   // Join octets and count consecutive 1s
   var binaryString = binaryOctets.join("");
-  var match = binaryString.match(/^1*0*$/);
+  var match = /^1*0*$/.exec(binaryString);
   if (!match) {
     throw new Error("Invalid subnet mask: must be consecutive 1s followed by 0s");
   }

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

@@ -78,12 +78,22 @@ var calculatorCore = exports.calculatorCore = function calculatorCore(expression
 var sanitizeSigns = function sanitizeSigns(expr) {
   return expr.replaceAll("--", "+").replaceAll("++", "+").replaceAll("+-", "+0-").replaceAll("-+", "+0-");
 };
+var currencyRegexCache = new Map();
+var getCurrencyRegex = function getCurrencyRegex(currencySymbol) {
+  var cached = currencyRegexCache.get(currencySymbol);
+  if (cached) {
+    return cached;
+  }
+  var regex = new RegExp("\\".concat(currencySymbol, "([0-9]+)"));
+  currencyRegexCache.set(currencySymbol, regex);
+  return regex;
+};
 var applyCurrencyExchange = function applyCurrencyExchange(expr, rates) {
   var returnExpr = expr;
   // Currency exchange logic
   for (var index in rates) {
     if (returnExpr.includes(index)) {
-      var $ = returnExpr.match(new RegExp("\\".concat(index, "([0-9]+)")));
+      var $ = getCurrencyRegex(index).exec(returnExpr);
       if ($) {
         returnExpr = returnExpr.replace($[0], (0, _convertCurrency.convertCurrency)($[0], rates));
       }
@@ -96,7 +106,7 @@ var containsParentheses = function containsParentheses(expr) {
 };
 var resolveParentheses = function resolveParentheses(expr) {
   // Logic for calculations inside parentheses
-  var match = expr.match(/\((-?\d+(?:\.\d+)?)([*+/-])(-?\d+(?:\.\d+)?)\)/);
+  var match = /\((-?\d+(?:\.\d+)?)([*+/-])(-?\d+(?:\.\d+)?)\)/.exec(expr);
   if (match) {
     return expr.replace(match[0], calculatorCore(match[0].replaceAll(/\(|\)/g, "")));
   }
@@ -110,7 +120,7 @@ var containsDiv = function containsDiv(expr) {
 };
 var resolveMulExp = function resolveMulExp(expr) {
   // Logic for multiplication and exponentiation
-  var match = expr.match(/(.*?)(-?\d+(?:\.\d+)?)([*^])(-?\d+(?:\.\d+)?)$/);
+  var match = /(.*?)(-?\d+(?:\.\d+)?)([*^])(-?\d+(?:\.\d+)?)$/.exec(expr);
   if (match) {
     var result = match[3] === "^" ? Math.pow(Number(match[2]), Number(match[4])) : (0, _multiplication.multiplication)(Number(match[2]), Number(match[4]));
     return "".concat(match[1]).concat(result);
@@ -119,7 +129,7 @@ var resolveMulExp = function resolveMulExp(expr) {
 };
 var resolveDiv = function resolveDiv(expr) {
   // Logic for division
-  var match = expr.match(/(-?\d+(?:\.\d+)?)\/(-?\d+(?:\.\d+)?)/);
+  var match = /(-?\d+(?:\.\d+)?)\/(-?\d+(?:\.\d+)?)/.exec(expr);
   if (match) {
     var result = (0, _division.division)(Number(match[1]), Number(match[2]));
     return expr.replace(match[0], String(result));
@@ -131,7 +141,7 @@ var containsAddSub = function containsAddSub(expr) {
 };
 var resolveAddSub = function resolveAddSub(expr) {
   // Logic for addition and subtraction
-  var match = expr.match(/(-?\d+(?:\.\d+)?)(\+|-)(-?\d+(?:\.\d+)?)/);
+  var match = /(-?\d+(?:\.\d+)?)(\+|-)(-?\d+(?:\.\d+)?)/.exec(expr);
   if (match) {
     var result = match[2] === "+" ? (0, _addition.addition)(Number(match[1]), Number(match[3])) : (0, _subtract.subtract)(Number(match[1]), Number(match[3]));
     return expr.replace(match[0], String(result));

package/module/es5/Math/gcd.js

@@ -62,8 +62,11 @@ var _gcdInteger = function gcdInteger(x, y) {
   var copyZ = z.map(function (element) {
     return Math.abs(Math.round(element));
   });
-  if (copyX === 0 || copyY === 0) {
-    return 0;
+  if (copyX === 0) {
+    return copyY;
+  }
+  if (copyY === 0) {
+    return copyX;
   }
   /* Euclidean algorithm */
   var _ref = [Math.max(copyX, copyY), Math.min(copyX, copyY)];

package/module/es5/Math/mathConverter.js

@@ -24,7 +24,7 @@ function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 var _mathConverter = exports.mathConverter = function mathConverter(equation) {
   var convertedEquation = equation;
   while (true) {
-    var multiplicationOrExponentiation = convertedEquation.match(/\d+\.?(\d+)?(\*|\^)\d+\.?(\d+)?/);
+    var multiplicationOrExponentiation = /\d+\.?(\d+)?(\*|\^)\d+\.?(\d+)?/.exec(convertedEquation);
     if (!multiplicationOrExponentiation) {
       return convertedEquation;
     }

package/module/es5/Math/mode.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.mode = void 0;
+var _ultraNumberSort = require("@/Array/ultraNumberSort");
 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; } }
@@ -32,8 +33,9 @@ var mode = exports.mode = function mode(array) {
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _frequency$get;
       var value = _step.value;
-      var count = (frequency.get(value) || 0) + 1;
+      var count = ((_frequency$get = frequency.get(value)) !== null && _frequency$get !== void 0 ? _frequency$get : 0) + 1;
       frequency.set(value, count);
       maxFrequency = Math.max(maxFrequency, count);
     }
@@ -61,7 +63,5 @@ var mode = exports.mode = function mode(array) {
   } finally {
     _iterator2.f();
   }
-  return modes.sort(function (a, b) {
-    return a - b;
-  });
+  return (0, _ultraNumberSort.ultraNumberSort)(modes);
 };

package/module/es5/Math/nCr.js

@@ -16,9 +16,12 @@ var _nPr = require("./nPr");
  * where the order doesn't matter. Uses the formula nCr = nPr / r!
  */
 var nCr = exports.nCr = function nCr(n, r) {
-  if (n === 0 || r === 0 || n < r) {
+  if (n < r || n < 0 || r < 0) {
     return Number.NaN;
   }
+  if (r === 0 || n === r) {
+    return 1;
+  }
   var numerator = (0, _nPr.nPr)(n, r);
   var denominator = 1;
   for (var index = 2; index <= r; index++) {