umt 2.4.0 → 2.6.0

package/module/es5/Array/ultraNumberSort.js

@@ -0,0 +1,475 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _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; }
+/**
+ * Ultra-fast sorting specifically optimized for number arrays
+ * @param array Array of numbers to sort
+ * @param ascending Sort in ascending order if true, descending if false
+ * @returns Sorted array
+ */
+var ultraNumberSort = exports.ultraNumberSort = function ultraNumberSort(array) {
+  var ascending = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var length = array.length;
+  if (length <= 1) {
+    return array;
+  }
+
+  // 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];
+    }
+    return array;
+  }
+  if (length === 3) {
+    inlineSort3(array, ascending);
+    return array;
+  }
+
+  // Check if all numbers are integers and find range
+  var allIntegers = true;
+  var min = array[0];
+  var max = array[0];
+  var hasNaN = false;
+  for (var index = 0; index < length; index++) {
+    var value = array[index];
+    // biome-ignore lint/suspicious/noSelfCompare: ignore
+    if (value !== value) {
+      hasNaN = true;
+      break;
+    }
+    if (value < min) {
+      min = value;
+    }
+    if (value > max) {
+      max = value;
+    }
+    if (allIntegers && value !== Math.floor(value)) {
+      allIntegers = false;
+    }
+  }
+
+  // Handle NaN values
+  if (hasNaN) {
+    return handleNaNSort(array, ascending);
+  }
+
+  // For small integer ranges, use counting sort
+  if (allIntegers && max - min < length * 2 && max - min < 1000000) {
+    return countingSort(array, min, max, ascending);
+  }
+
+  // For larger arrays, use radix sort if applicable
+  if (allIntegers && length > 100) {
+    return radixSort(array, ascending);
+  }
+
+  // Fall back to optimized quicksort for floating point
+  return numericQuickSort(array, 0, length - 1, ascending);
+};
+
+/**
+ * Inline sort for 3 elements
+ */
+var inlineSort3 = function inlineSort3(array, ascending) {
+  var a = array[0];
+  var b = array[1];
+  var c = array[2];
+  if (ascending) {
+    if (a > b) {
+      var _ref2 = [b, a];
+      a = _ref2[0];
+      b = _ref2[1];
+    }
+    if (b > c) {
+      var _ref3 = [c, b];
+      b = _ref3[0];
+      c = _ref3[1];
+      if (a > b) {
+        var _ref4 = [b, a];
+        a = _ref4[0];
+        b = _ref4[1];
+      }
+    }
+  } else {
+    if (a < b) {
+      var _ref5 = [b, a];
+      a = _ref5[0];
+      b = _ref5[1];
+    }
+    if (b < c) {
+      var _ref6 = [c, b];
+      b = _ref6[0];
+      c = _ref6[1];
+      if (a < b) {
+        var _ref7 = [b, a];
+        a = _ref7[0];
+        b = _ref7[1];
+      }
+    }
+  }
+  array[0] = a;
+  array[1] = b;
+  array[2] = c;
+};
+
+/**
+ * Handle arrays with NaN values
+ */
+var handleNaNSort = function handleNaNSort(array, ascending) {
+  var valid = [];
+  var nanCount = 0;
+  var _iterator = _createForOfIteratorHelper(array),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var element = _step.value;
+      // biome-ignore lint/suspicious/noSelfCompare: ignore
+      if (element === element) {
+        valid.push(element);
+      } else {
+        nanCount++;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  numericQuickSort(valid, 0, valid.length - 1, ascending);
+
+  // NaN values go to the end
+  for (var index = 0; index < nanCount; index++) {
+    valid.push(Number.NaN);
+  }
+
+  // Copy back
+  for (var _index = 0; _index < array.length; _index++) {
+    array[_index] = valid[_index];
+  }
+  return array;
+};
+
+/**
+ * Counting sort for small integer ranges
+ */
+var countingSort = function countingSort(array, min, max, ascending) {
+  var range = max - min + 1;
+  var count = new Uint32Array(range);
+
+  // Count occurrences
+  var _iterator2 = _createForOfIteratorHelper(array),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var element = _step2.value;
+      count[element - min]++;
+    }
+
+    // Reconstruct array
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var index = 0;
+  if (ascending) {
+    for (var index_ = 0; index_ < range; index_++) {
+      var cnt = count[index_];
+      var value = index_ + min;
+      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++) {
+        array[index++] = _value;
+      }
+    }
+  }
+  return array;
+};
+
+/**
+ * Radix sort for integers
+ */
+var radixSort = function radixSort(array, ascending) {
+  var length = array.length;
+
+  // Separate positive and negative numbers
+  var positive = [];
+  var negative = [];
+  var zeroCount = 0;
+  for (var index_ = 0; index_ < length; index_++) {
+    if (array[index_] > 0) {
+      positive.push(array[index_]);
+    } else if (array[index_] < 0) {
+      negative.push(-array[index_]);
+    } else {
+      zeroCount++;
+    }
+  }
+
+  // Sort positive numbers
+  if (positive.length > 0) {
+    radixSortPositive(positive);
+  }
+
+  // Sort negative numbers
+  if (negative.length > 0) {
+    radixSortPositive(negative);
+  }
+
+  // Merge results
+  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];
+    }
+    // Zeros
+    for (var _index_5 = 0; _index_5 < zeroCount; _index_5++) {
+      array[index++] = 0;
+    }
+    // Positive numbers
+    var _iterator3 = _createForOfIteratorHelper(positive),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var element = _step3.value;
+        array[index++] = element;
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  } else {
+    // Positive numbers first (in reverse order)
+    for (var _index_6 = positive.length - 1; _index_6 >= 0; _index_6--) {
+      array[index++] = positive[_index_6];
+    }
+    // Zeros
+    for (var _index_7 = 0; _index_7 < zeroCount; _index_7++) {
+      array[index++] = 0;
+    }
+    // Negative numbers
+    var _iterator4 = _createForOfIteratorHelper(negative),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _element = _step4.value;
+        array[index++] = -_element;
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  }
+  return array;
+};
+
+/**
+ * Radix sort for positive integers
+ */
+var radixSortPositive = function radixSortPositive(array) {
+  var length = array.length;
+  if (length <= 1) {
+    return;
+  }
+
+  // Find maximum to determine number of digits
+  var max = array[0];
+  for (var index = 1; index < length; index++) {
+    if (array[index] > max) {
+      max = array[index];
+    }
+  }
+
+  // Use typed arrays for better performance
+  var output = new Float64Array(length);
+  var count = new Uint32Array(256);
+
+  // Process 8 bits at a time
+  for (var shift = 0; max >> shift > 0; shift += 8) {
+    // Reset count array
+    count.fill(0);
+
+    // Count occurrences
+    for (var _index2 = 0; _index2 < length; _index2++) {
+      var digit = array[_index2] >> shift & 0xff;
+      count[digit]++;
+    }
+
+    // Change count[i] to actual position
+    for (var _index3 = 1; _index3 < 256; _index3++) {
+      count[_index3] += count[_index3 - 1];
+    }
+
+    // Build output array
+    for (var _index4 = length - 1; _index4 >= 0; _index4--) {
+      var _digit = array[_index4] >> shift & 0xff;
+      output[--count[_digit]] = array[_index4];
+    }
+
+    // Copy back
+    for (var _index5 = 0; _index5 < length; _index5++) {
+      array[_index5] = output[_index5];
+    }
+  }
+};
+
+/**
+ * Optimized quicksort for numbers
+ */
+var numericQuickSort = function numericQuickSort(array, low, high, ascending) {
+  var stack = [];
+  stack.push(low, high);
+  while (stack.length > 0) {
+    var h = stack.pop();
+    var l = stack.pop();
+    if (h === undefined || l === undefined || h <= l) {
+      continue;
+    }
+
+    // For small subarrays, use insertion sort
+    if (h - l < 16) {
+      numericInsertionSort(array, l, h, ascending);
+      continue;
+    }
+
+    // Partition
+    var pivot = numericPartition(array, l, h, ascending);
+
+    // Push larger partition first to limit stack depth
+    if (pivot - l > h - pivot) {
+      stack.push(l, pivot - 1, pivot + 1, h);
+    } else {
+      stack.push(pivot + 1, h, l, pivot - 1);
+    }
+  }
+  return array;
+};
+
+/**
+ * Numeric insertion sort
+ */
+var numericInsertionSort = function numericInsertionSort(array, low, high, ascending) {
+  if (ascending) {
+    for (var index = low + 1; index <= high; index++) {
+      var key = array[index];
+      var index_ = index - 1;
+      while (index_ >= low && array[index_] > key) {
+        array[index_ + 1] = array[index_];
+        index_--;
+      }
+      array[index_ + 1] = key;
+    }
+  } 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--;
+      }
+      array[_index_8 + 1] = _key;
+    }
+  }
+};
+
+/**
+ * Numeric partition with median-of-three pivot
+ */
+var numericPartition = function numericPartition(array, low, high, ascending) {
+  // Median-of-three pivot selection
+  var mid = low + (high - low >> 1);
+  if (ascending) {
+    if (array[mid] < array[low]) {
+      var _ref8 = [array[mid], array[low]];
+      array[low] = _ref8[0];
+      array[mid] = _ref8[1];
+    }
+    if (array[high] < array[low]) {
+      var _ref9 = [array[high], array[low]];
+      array[low] = _ref9[0];
+      array[high] = _ref9[1];
+    }
+    if (array[high] < array[mid]) {
+      var _ref0 = [array[high], array[mid]];
+      array[mid] = _ref0[0];
+      array[high] = _ref0[1];
+    }
+  } else {
+    if (array[mid] > array[low]) {
+      var _ref1 = [array[mid], array[low]];
+      array[low] = _ref1[0];
+      array[mid] = _ref1[1];
+    }
+    if (array[high] > array[low]) {
+      var _ref10 = [array[high], array[low]];
+      array[low] = _ref10[0];
+      array[high] = _ref10[1];
+    }
+    if (array[high] > array[mid]) {
+      var _ref11 = [array[high], array[mid]];
+      array[mid] = _ref11[0];
+      array[high] = _ref11[1];
+    }
+  }
+
+  // Move pivot to end-1
+  var _ref12 = [array[high - 1], array[mid]];
+  array[mid] = _ref12[0];
+  array[high - 1] = _ref12[1];
+  var pivot = array[high - 1];
+  var index = low;
+  var index_ = high - 1;
+  if (ascending) {
+    while (true) {
+      while (array[++index] < pivot) {
+        // Continue
+      }
+      while (array[--index_] > pivot) {
+        // Continue
+      }
+      if (index >= index_) {
+        break;
+      }
+      var _ref13 = [array[index_], array[index]];
+      array[index] = _ref13[0];
+      array[index_] = _ref13[1];
+    }
+  } else {
+    while (true) {
+      while (array[++index] > pivot) {
+        // Continue
+      }
+      while (array[--index_] < pivot) {
+        // Continue
+      }
+      if (index >= index_) {
+        break;
+      }
+      var _ref14 = [array[index_], array[index]];
+      array[index] = _ref14[0];
+      array[index_] = _ref14[1];
+    }
+  }
+  var _ref15 = [array[high - 1], array[index]];
+  array[index] = _ref15[0];
+  array[high - 1] = _ref15[1];
+  return index;
+};

package/module/es5/Array/uniqBy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes duplicate values from an array based on a selector function
+ * @param array - The array to process
+ * @param selector - Function that returns the value to compare for uniqueness
+ * @returns A new array with unique values based on the selector
+ */
+export declare const uniqBy: <T extends unknown[], K>(array: T, selector: (item: T[number]) => K) => T;

package/module/es5/Array/uniqBy.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uniqBy = 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 _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; }
+/**
+ * Removes duplicate values from an array based on a selector function
+ * @param array - The array to process
+ * @param selector - Function that returns the value to compare for uniqueness
+ * @returns A new array with unique values based on the selector
+ */
+var uniqBy = exports.uniqBy = function uniqBy(array, selector) {
+  var seen = new Set();
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(array),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var key = selector(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(item);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+};

package/module/es5/Array/unique.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Removes duplicate values from an array
+ * @param array - The array to process
+ * @returns A new array with unique values
+ */
+export declare const unique: <T>(array: T[]) => T[];

package/module/es5/Array/unique.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unique = void 0;
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Removes duplicate values from an array
+ * @param array - The array to process
+ * @returns A new array with unique values
+ */
+var unique = exports.unique = function unique(array) {
+  return _toConsumableArray(new Set(array));
+};

package/module/es5/Color/rgbaToHsla.js

@@ -36,7 +36,7 @@ var rgbaToHsla = exports.rgbaToHsla = function rgbaToHsla(_ref) {
   var l = (0, _division.division)((0, _addition.addition)(max, min), 2);
   var s = diff === 0 ? 0 : (0, _division.division)(diff, (0, _subtract.subtract)(1, Math.abs((0, _subtract.subtract)((0, _addition.addition)(max, min), 1))));
   if (diff !== 0) {
-    // biome-ignore lint/style/useDefaultSwitchClause: <explanation>
+    // biome-ignore lint/style/useDefaultSwitchClause: ignore
     switch (max) {
       case rPrime:
         {

package/module/es5/Date/birthday.js

@@ -19,7 +19,21 @@ var birthday = exports.birthday = function birthday(year, mon, day) {
   var timeDifference = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 9;
   var birthdayDate = new Date((0, _new.newDateInt)(year, mon, day));
   var nowTime = (0, _now.now)(timeDifference);
-  var y = nowTime.getFullYear() - birthdayDate.getFullYear();
-  var r = nowTime < (0, _new.newDateInt)(nowTime.getFullYear(), birthdayDate.getMonth() - 1, birthdayDate.getDay()) ? y - 1 : y;
-  return year < 100 ? 1900 + y : r;
+  var currentYear = nowTime.getFullYear();
+  var birthYear = birthdayDate.getFullYear();
+
+  // Calculate base age
+  var age = currentYear - birthYear;
+
+  // Check if birthday hasn't occurred this year yet
+  var thisYearBirthday = new Date(currentYear, birthdayDate.getMonth(), birthdayDate.getDate());
+  if (nowTime < thisYearBirthday) {
+    age -= 1;
+  }
+
+  // Handle future birthdays (should return 0 or non-negative)
+  if (age < 0) {
+    return 0;
+  }
+  return age;
 };

package/module/es5/Date/isLeapYear.js

@@ -15,5 +15,8 @@ exports.isLeapYear = void 0;
  * isLeapYear(2023); // Returns false (not divisible by 4)
  */
 var isLeapYear = exports.isLeapYear = function isLeapYear(year) {
+  if (!Number.isInteger(year)) {
+    return false;
+  }
   return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
 };

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

@@ -1 +1,2 @@
+export * from "./retry";
 export * from "./safeExecute";

package/module/es5/Error/index.js

@@ -3,6 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _retry = require("./retry");
+Object.keys(_retry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _retry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _retry[key];
+    }
+  });
+});
 var _safeExecute = require("./safeExecute");
 Object.keys(_safeExecute).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Error/retry.d.ts

@@ -0,0 +1,37 @@
+export interface RetryOptions {
+    retries?: number;
+    delay?: number;
+    shouldRetry?: (error: unknown) => boolean;
+}
+/**
+ * Retries a given async function with configurable retry logic
+ *
+ * @template T - The return type of the function
+ * @param function_ - The async function to retry
+ * @param options - Configuration options for retry behavior
+ * @param options.retries - Maximum number of retry attempts (default: 3)
+ * @param options.delay - Delay between retries in milliseconds (default: 1000)
+ * @param options.shouldRetry - Function to determine if an error should trigger a retry (default: always retry)
+ * @returns Promise that resolves with the function result or rejects with the final error
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with default options
+ * const result = await retry(async () => {
+ *   const response = await fetch('/api/data');
+ *   if (!response.ok) throw new Error('Failed to fetch');
+ *   return response.json();
+ * });
+ *
+ * // Custom retry configuration
+ * const result = await retry(
+ *   () => riskyOperation(),
+ *   {
+ *     retries: 5,
+ *     delay: 2000,
+ *     shouldRetry: (error) => error instanceof NetworkError
+ *   }
+ * );
+ * ```
+ */
+export declare const retry: <T>(function_: () => Promise<T>, options?: RetryOptions) => Promise<T>;