umt 2.12.3 → 2.13.0

package/module/es5/Array/ultraNumberSort.js

@@ -19,18 +19,16 @@ 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 result = _toConsumableArray(array);
-  var length = result.length;
+  var length = array.length;
   if (length <= 1) {
-    return result;
+    return _toConsumableArray(array);
   }
-
-  // For tiny arrays, use optimized inline sort
+  var result = _toConsumableArray(array);
   if (length === 2) {
     if (result[0] > result[1] === ascending) {
-      var _ref = [result[1], result[0]];
-      result[0] = _ref[0];
-      result[1] = _ref[1];
+      var temporary = result[0];
+      result[0] = result[1];
+      result[1] = temporary;
     }
     return result;
   }
@@ -39,13 +37,25 @@ var ultraNumberSort = exports.ultraNumberSort = function ultraNumberSort(array)
     return result;
   }
 
+  // For small-medium arrays, skip integer/range analysis
+  if (length <= 128) {
+    for (var index = 0; index < length; index++) {
+      // biome-ignore lint/suspicious/noSelfCompare: NaN detection
+      if (result[index] !== result[index]) {
+        return handleNaNSort(result, ascending);
+      }
+    }
+    numericQuickSort(result, 0, length - 1, ascending);
+    return result;
+  }
+
   // Check if all numbers are integers and find range
   var allIntegers = true;
   var min = result[0];
   var max = result[0];
   var hasNaN = false;
-  for (var index = 0; index < length; index++) {
-    var value = result[index];
+  for (var _index = 0; _index < length; _index++) {
+    var value = result[_index];
     // biome-ignore lint/suspicious/noSelfCompare: ignore
     if (value !== value) {
       hasNaN = true;
@@ -62,23 +72,155 @@ var ultraNumberSort = exports.ultraNumberSort = function ultraNumberSort(array)
     }
   }
 
-  // Handle NaN values
+  // For small integer ranges, use counting sort
+  if (!hasNaN && allIntegers && max - min < length * 2 && max - min < 1000000) {
+    return countingSort(result, min, max, ascending);
+  }
+
+  // For medium arrays, quicksort is faster than radix sort
+  // due to typed array allocation overhead
+  if (length < 4096) {
+    if (hasNaN) {
+      return handleNaNSort(result, ascending);
+    }
+    numericQuickSort(result, 0, length - 1, ascending);
+    return result;
+  }
+
+  // Use IEEE 754 Float64 radix sort for large arrays
+  return float64RadixSort(result, ascending, hasNaN);
+};
+
+/**
+ * IEEE 754 Float64 radix sort
+ * Works on all number types (integers and floats) by treating
+ * the 64-bit IEEE 754 bit pattern as a sortable unsigned integer.
+ *
+ * Bit transformation:
+ * - Positive numbers (sign bit 0): flip only the sign bit
+ * - Negative numbers (sign bit 1): flip ALL 64 bits
+ * After this transformation, unsigned integer comparison matches
+ * the original floating-point numerical order.
+ */
+var float64RadixSort = function float64RadixSort(array, ascending, hasNaN) {
+  var length = array.length;
+  var sourceBuffer = new ArrayBuffer(length * 8);
+  var sourceF64 = new Float64Array(sourceBuffer);
+  var sourceU32 = new Uint32Array(sourceBuffer);
+  var validLength;
   if (hasNaN) {
-    return handleNaNSort(result, ascending);
+    var writeIndex = 0;
+    for (var index = 0; index < length; index++) {
+      var v = array[index];
+      // biome-ignore lint/suspicious/noSelfCompare: NaN detection
+      if (v === v) {
+        sourceF64[writeIndex++] = v;
+      }
+    }
+    validLength = writeIndex;
+  } else {
+    for (var _index2 = 0; _index2 < length; _index2++) {
+      sourceF64[_index2] = array[_index2];
+    }
+    validLength = length;
+  }
+  if (validLength === 0) {
+    return array;
   }
 
-  // For small integer ranges, use counting sort
-  if (allIntegers && max - min < length * 2 && max - min < 1000000) {
-    return countingSort(result, min, max, ascending);
+  // Transform IEEE 754 bit patterns to sortable unsigned form
+  for (var _index3 = 0; _index3 < validLength; _index3++) {
+    var hiIndex = _index3 * 2 + 1;
+    var loIndex = _index3 * 2;
+    if (sourceU32[hiIndex] & 0x80000000) {
+      sourceU32[hiIndex] = ~sourceU32[hiIndex] >>> 0;
+      sourceU32[loIndex] = ~sourceU32[loIndex] >>> 0;
+    } else {
+      sourceU32[hiIndex] ^= 0x80000000;
+    }
   }
+  var destinationBuffer = new ArrayBuffer(validLength * 8);
+  var destinationU32 = new Uint32Array(destinationBuffer);
+  var count = new Uint32Array(256);
+  var currentSource = sourceU32;
+  var currentDestination = destinationU32;
+  var resultInSource = true;
+
+  // 8-pass LSD radix sort (8 bits per pass)
+  // Passes 0-3: low 32-bit word (index i*2)
+  // Passes 4-7: high 32-bit word (index i*2+1)
+  for (var pass = 0; pass < 8; pass++) {
+    count.fill(0);
+    var wordOffset = pass < 4 ? 0 : 1;
+    var shift = pass % 4 * 8;
+    for (var _index4 = 0; _index4 < validLength; _index4++) {
+      count[currentSource[_index4 * 2 + wordOffset] >>> shift & 0xff]++;
+    }
+
+    // Skip pass if all elements have the same byte value
+    var skipPass = false;
+    for (var _index5 = 0; _index5 < 256; _index5++) {
+      if (count[_index5] === validLength) {
+        skipPass = true;
+        break;
+      }
+    }
+    if (skipPass) {
+      continue;
+    }
+
+    // Prefix sum (reverse for descending sort)
+    if (ascending) {
+      for (var _index6 = 1; _index6 < 256; _index6++) {
+        count[_index6] += count[_index6 - 1];
+      }
+    } else {
+      for (var _index7 = 254; _index7 >= 0; _index7--) {
+        count[_index7] += count[_index7 + 1];
+      }
+    }
 
-  // For larger arrays, use radix sort if applicable
-  if (allIntegers && length > 100) {
-    return radixSort(result, ascending);
+    // Scatter (backward for stability)
+    for (var _index8 = validLength - 1; _index8 >= 0; _index8--) {
+      var _byte = currentSource[_index8 * 2 + wordOffset] >>> shift & 0xff;
+      var pos = --count[_byte];
+      currentDestination[pos * 2] = currentSource[_index8 * 2];
+      currentDestination[pos * 2 + 1] = currentSource[_index8 * 2 + 1];
+    }
+
+    // Ping-pong swap
+    var temporary = currentSource;
+    currentSource = currentDestination;
+    currentDestination = temporary;
+    resultInSource = !resultInSource;
   }
 
-  // Fall back to optimized quicksort for floating point
-  return numericQuickSort(result, 0, length - 1, ascending);
+  // Determine which buffer holds the result
+  var resultU32 = currentSource;
+  var resultBuffer = resultInSource ? sourceBuffer : destinationBuffer;
+  var resultF64 = new Float64Array(resultBuffer);
+
+  // Reverse bit transformation
+  for (var _index9 = 0; _index9 < validLength; _index9++) {
+    var _hiIndex = _index9 * 2 + 1;
+    if (resultU32[_hiIndex] & 0x80000000) {
+      resultU32[_hiIndex] ^= 0x80000000;
+    } else {
+      resultU32[_hiIndex] = ~resultU32[_hiIndex] >>> 0;
+      resultU32[_index9 * 2] = ~resultU32[_index9 * 2] >>> 0;
+    }
+  }
+
+  // Copy results back
+  for (var _index0 = 0; _index0 < validLength; _index0++) {
+    array[_index0] = resultF64[_index0];
+  }
+
+  // Append NaN values at the end
+  for (var _index1 = validLength; _index1 < length; _index1++) {
+    array[_index1] = Number.NaN;
+  }
+  return array;
 };
 
 /**
@@ -88,36 +230,37 @@ var inlineSort3 = function inlineSort3(array, ascending) {
   var a = array[0];
   var b = array[1];
   var c = array[2];
+  var temporary;
   if (ascending) {
     if (a > b) {
-      var _ref2 = [b, a];
-      a = _ref2[0];
-      b = _ref2[1];
+      temporary = a;
+      a = b;
+      b = temporary;
     }
     if (b > c) {
-      var _ref3 = [c, b];
-      b = _ref3[0];
-      c = _ref3[1];
+      temporary = b;
+      b = c;
+      c = temporary;
       if (a > b) {
-        var _ref4 = [b, a];
-        a = _ref4[0];
-        b = _ref4[1];
+        temporary = a;
+        a = b;
+        b = temporary;
       }
     }
   } else {
     if (a < b) {
-      var _ref5 = [b, a];
-      a = _ref5[0];
-      b = _ref5[1];
+      temporary = a;
+      a = b;
+      b = temporary;
     }
     if (b < c) {
-      var _ref6 = [c, b];
-      b = _ref6[0];
-      c = _ref6[1];
+      temporary = b;
+      b = c;
+      c = temporary;
       if (a < b) {
-        var _ref7 = [b, a];
-        a = _ref7[0];
-        b = _ref7[1];
+        temporary = a;
+        a = b;
+        b = temporary;
       }
     }
   }
@@ -157,8 +300,8 @@ var handleNaNSort = function handleNaNSort(array, ascending) {
   }
 
   // Copy back
-  for (var _index = 0; _index < array.length; _index++) {
-    array[_index] = valid[_index];
+  for (var _index10 = 0; _index10 < array.length; _index10++) {
+    array[_index10] = valid[_index10];
   }
   return array;
 };
@@ -206,136 +349,6 @@ var countingSort = function countingSort(array, min, max, ascending) {
   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_2 = negative.length - 1; _index_2 >= 0; _index_2--) {
-      array[index++] = -negative[_index_2];
-    }
-    // Zeros
-    for (var _index_3 = 0; _index_3 < zeroCount; _index_3++) {
-      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_4 = positive.length - 1; _index_4 >= 0; _index_4--) {
-      array[index++] = positive[_index_4];
-    }
-    // Zeros
-    for (var _index_5 = 0; _index_5 < zeroCount; _index_5++) {
-      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
  */
@@ -382,14 +395,14 @@ var numericInsertionSort = function numericInsertionSort(array, low, high, ascen
       array[index_ + 1] = key;
     }
   } else {
-    for (var _index6 = low + 1; _index6 <= high; _index6++) {
-      var _key = array[_index6];
-      var _index_6 = _index6 - 1;
-      while (_index_6 >= low && array[_index_6] < _key) {
-        array[_index_6 + 1] = array[_index_6];
-        _index_6--;
+    for (var _index11 = low + 1; _index11 <= high; _index11++) {
+      var _key = array[_index11];
+      var _index_2 = _index11 - 1;
+      while (_index_2 >= low && array[_index_2] < _key) {
+        array[_index_2 + 1] = array[_index_2];
+        _index_2--;
       }
-      array[_index_6 + 1] = _key;
+      array[_index_2 + 1] = _key;
     }
   }
 };
@@ -400,44 +413,45 @@ var numericInsertionSort = function numericInsertionSort(array, low, high, ascen
 var numericPartition = function numericPartition(array, low, high, ascending) {
   // Median-of-three pivot selection
   var mid = low + (high - low >> 1);
+  var temporary;
   if (ascending) {
     if (array[mid] < array[low]) {
-      var _ref8 = [array[mid], array[low]];
-      array[low] = _ref8[0];
-      array[mid] = _ref8[1];
+      temporary = array[low];
+      array[low] = array[mid];
+      array[mid] = temporary;
     }
     if (array[high] < array[low]) {
-      var _ref9 = [array[high], array[low]];
-      array[low] = _ref9[0];
-      array[high] = _ref9[1];
+      temporary = array[low];
+      array[low] = array[high];
+      array[high] = temporary;
     }
     if (array[high] < array[mid]) {
-      var _ref0 = [array[high], array[mid]];
-      array[mid] = _ref0[0];
-      array[high] = _ref0[1];
+      temporary = array[mid];
+      array[mid] = array[high];
+      array[high] = temporary;
     }
   } else {
     if (array[mid] > array[low]) {
-      var _ref1 = [array[mid], array[low]];
-      array[low] = _ref1[0];
-      array[mid] = _ref1[1];
+      temporary = array[low];
+      array[low] = array[mid];
+      array[mid] = temporary;
     }
     if (array[high] > array[low]) {
-      var _ref10 = [array[high], array[low]];
-      array[low] = _ref10[0];
-      array[high] = _ref10[1];
+      temporary = array[low];
+      array[low] = array[high];
+      array[high] = temporary;
     }
     if (array[high] > array[mid]) {
-      var _ref11 = [array[high], array[mid]];
-      array[mid] = _ref11[0];
-      array[high] = _ref11[1];
+      temporary = array[mid];
+      array[mid] = array[high];
+      array[high] = temporary;
     }
   }
 
   // Move pivot to end-1
-  var _ref12 = [array[high - 1], array[mid]];
-  array[mid] = _ref12[0];
-  array[high - 1] = _ref12[1];
+  temporary = array[mid];
+  array[mid] = array[high - 1];
+  array[high - 1] = temporary;
   var pivot = array[high - 1];
   var index = low;
   var index_ = high - 1;
@@ -452,9 +466,9 @@ var numericPartition = function numericPartition(array, low, high, ascending) {
       if (index >= index_) {
         break;
       }
-      var _ref13 = [array[index_], array[index]];
-      array[index] = _ref13[0];
-      array[index_] = _ref13[1];
+      temporary = array[index];
+      array[index] = array[index_];
+      array[index_] = temporary;
     }
   } else {
     while (true) {
@@ -467,13 +481,13 @@ var numericPartition = function numericPartition(array, low, high, ascending) {
       if (index >= index_) {
         break;
       }
-      var _ref14 = [array[index_], array[index]];
-      array[index] = _ref14[0];
-      array[index_] = _ref14[1];
+      temporary = array[index];
+      array[index] = array[index_];
+      array[index_] = temporary;
     }
   }
-  var _ref15 = [array[high - 1], array[index]];
-  array[index] = _ref15[0];
-  array[high - 1] = _ref15[1];
+  temporary = array[index];
+  array[index] = array[high - 1];
+  array[high - 1] = temporary;
   return index;
 };

package/module/es5/Async/defer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A deferred promise with externally accessible resolve and reject
+ */
+export interface Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+}
+/**
+ * Creates a deferred promise whose resolve and reject can be
+ * called externally
+ * @returns {Deferred<T>} An object with promise, resolve, and reject
+ * @example
+ * const d = defer<number>();
+ * d.resolve(42);
+ * const value = await d.promise;
+ */
+export declare const defer: <T>() => Deferred<T>;

package/module/es5/Async/defer.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defer = void 0;
+/**
+ * A deferred promise with externally accessible resolve and reject
+ */
+
+/**
+ * Creates a deferred promise whose resolve and reject can be
+ * called externally
+ * @returns {Deferred<T>} An object with promise, resolve, and reject
+ * @example
+ * const d = defer<number>();
+ * d.resolve(42);
+ * const value = await d.promise;
+ */
+var defer = exports.defer = function defer() {
+  var resolve;
+  var reject;
+  var promise = new Promise(function (resolver, rejector) {
+    resolve = resolver;
+    reject = rejector;
+  });
+  return {
+    promise: promise,
+    resolve: resolve,
+    reject: reject
+  };
+};

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

@@ -0,0 +1,4 @@
+export * from "./defer";
+export * from "./parallel";
+export * from "./sleep";
+export * from "./timeout";

package/module/es5/Async/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _defer = require("./defer");
+Object.keys(_defer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _defer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _defer[key];
+    }
+  });
+});
+var _parallel = require("./parallel");
+Object.keys(_parallel).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parallel[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _parallel[key];
+    }
+  });
+});
+var _sleep = require("./sleep");
+Object.keys(_sleep).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sleep[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _sleep[key];
+    }
+  });
+});
+var _timeout = require("./timeout");
+Object.keys(_timeout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _timeout[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _timeout[key];
+    }
+  });
+});

package/module/es5/Async/parallel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Executes async functions in parallel with a concurrency limit
+ * @param {number} limit - Maximum number of concurrent executions
+ * @param {T[]} items - The items to process
+ * @param {(item: T, index: number) => Promise<U>} function_ - The async function to apply to each item
+ * @returns {Promise<U[]>} Results in the same order as the input items
+ * @example
+ * const results = await parallel(2, [1, 2, 3], async (n) => n * 2);
+ */
+export declare const parallel: <T, U>(limit: number, items: T[], function_: (item: T, index: number) => Promise<U>) => Promise<U[]>;