umt 2.12.3 → 2.14.0

package/module/URL/parseQueryString.js

@@ -0,0 +1,34 @@
+/**
+ * Parses a query string into a key-value record.
+ *
+ * Accepts either a full URL or a raw query string
+ * (with or without leading "?").
+ *
+ * @param query - The query string or URL to parse
+ * @returns A record of key-value pairs from the query string
+ *
+ * @example
+ * ```typescript
+ * parseQueryString("?page=1&q=search");
+ * // { page: "1", q: "search" }
+ *
+ * parseQueryString("foo=bar&baz=qux");
+ * // { foo: "bar", baz: "qux" }
+ *
+ * parseQueryString("https://example.com?a=1&b=2");
+ * // { a: "1", b: "2" }
+ * ```
+ */
+export const parseQueryString = (query) => {
+    let searchString = query;
+    if (query.includes("://")) {
+        searchString = new URL(query).search;
+    }
+    const parameters = new URLSearchParams(searchString);
+    const result = {};
+    for (const [key, value] of parameters) {
+        result[key] = value;
+    }
+    return result;
+};
+//# sourceMappingURL=parseQueryString.js.map

package/module/URL/parseQueryString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseQueryString.js","sourceRoot":"","sources":["../../src/URL/parseQueryString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAA0B,EAAE;IACxE,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,YAAY,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IACvC,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,eAAe,CAAC,YAAY,CAAC,CAAC;IACrD,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,UAAU,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACtB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/module/Validate/parseEmail.js

@@ -1,9 +1,9 @@
 const EMAIL_PATTERNS = {
-    basic: /^(?<local>[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+)@(?<domain>[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/,
-    rfc822: /^(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*(?<local>"(?:[^"\\]|\\[\s\S]){0,62}"|[a-zA-Z0-9!#$%&'*/=?^_`{|}~-]{1,64}(?:\.[a-zA-Z0-9!#$%&'*/=?^_`{|}~-]+)*)(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*@(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*(?<domain>[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*$/,
-    rfc2822: /^(?=.{1,998}$)(?!.*\.\.)(?<local>[a-zA-Z0-9!#$%&'*/=?^_`{|}~-](?:[a-zA-Z0-9!#$%&'*/=?^_`{|}~.+-]{0,62}[a-zA-Z0-9!#$%&'*/=?^_`{|}~-])?)@(?<domain>[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\.[a-zA-Z]{2,})$/,
-    rfc5321: /^(?=.{1,256}$)(?=(?:[^@]{1,64})@)(?!.*\.\.)(?<local>(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\s\S]){0,62}"))@(?<domain>[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+|\[(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}|IPv6:[0-9a-fA-F:]+)\])$/,
-    rfc5322: /^(?=.{1,998}$)(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*(?<local>"(?:[^"\\]|\\[\s\S]){0,62}"(?:\."(?:[^"\\]|\\[\s\S]){0,62}")*|"(?:[^"\\]|\\[\s\S]){0,62}"(?:\.[a-zA-Z0-9!#$%&'*/=?^_`{|}~+-]{1,64}(?:\.[a-zA-Z0-9!#$%&'*/=?^_`{|}~+-]{1,64})*)+|[a-zA-Z0-9!#$%&'*/=?^_`{|}~+-]{1,64}(?:\.[a-zA-Z0-9!#$%&'*/=?^_`{|}~+-]{1,64})*(?:\."(?:[^"\\]|\\[\s\S]){0,62}")+|[a-zA-Z0-9!#$%&'*/=?^_`{|}~+-]{1,64}(?:(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*\.(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*[a-zA-Z0-9!#$%&'*/=?^_`{|}~+-]{1,64})*)(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*@(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*(?<domain>[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*\.(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+|\[(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}|IPv6:[0-9a-fA-F:]+)\])(?:\s|\((?:[^()\\]|\\[\s\S])*(?:\((?:[^()\\]|\\[\s\S])*\)(?:[^()\\]|\\[\s\S])*)*\))*$/,
+    basic: /^(?<local>[\w!#$%&'*+./=?^`{|}~-]+)@(?<domain>[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?(?:\.[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?)*)$/,
+    rfc822: /^(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*(?<local>"(?:[^"\\]|\\[\S\s]){0,62}"|[\w!#$%&'*/=?^`{|}~-]{1,64}(?:\.[\w!#$%&'*/=?^`{|}~-]+)*)(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*@(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*(?<domain>[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?(?:\.[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?)*)(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*$/,
+    rfc2822: /^(?=.{1,998}$)(?!.*\.\.)(?<local>[\w!#$%&'*/=?^`{|}~-](?:[\w!#$%&'*+./=?^`{|}~-]{0,62}[\w!#$%&'*/=?^`{|}~-])?)@(?<domain>[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?(?:\.[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?)*\.[A-Za-z]{2,})$/,
+    rfc5321: /^(?=.{1,256}$)(?=[^@]{1,64}@)(?!.*\.\.)(?<local>(?:[\w!#$%&'*+/=?^`{|}~-]+(?:\.[\w!#$%&'*+/=?^`{|}~-]+)*|"(?:[^"\\]|\\[\S\s]){0,62}"))@(?<domain>[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?(?:\.[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?)+|\[(?:(?:\d{1,3}\.){3}\d{1,3}|IPv6:[\d:A-Fa-f]+)])$/,
+    rfc5322: /^(?=.{1,998}$)(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*(?<local>"(?:[^"\\]|\\[\S\s]){0,62}"(?:\."(?:[^"\\]|\\[\S\s]){0,62}")*|"(?:[^"\\]|\\[\S\s]){0,62}"(?:(?:\.[\w!#$%&'*+/=?^`{|}~-]{1,64})+)+|[\w!#$%&'*+/=?^`{|}~-]{1,64}(?:\.[\w!#$%&'*+/=?^`{|}~-]{1,64})*(?:\."(?:[^"\\]|\\[\S\s]){0,62}")+|[\w!#$%&'*+/=?^`{|}~-]{1,64}(?:(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*\.(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*[\w!#$%&'*+/=?^`{|}~-]{1,64})*)(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*@(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*(?<domain>[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?(?:(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*\.(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*[\dA-Za-z](?:[\dA-Za-z-]{0,61}[\dA-Za-z])?)+|\[(?:(?:\d{1,3}\.){3}\d{1,3}|IPv6:[\d:A-Fa-f]+)])(?:\s|\((?:[^()\\]|\\[\S\s])*(?:\((?:[^()\\]|\\[\S\s])*\)(?:[^()\\]|\\[\S\s])*)*\))*$/,
 };
 export const parseEmail = ({ email, options, }) => {
     const { level } = options;

package/module/Validate/parseEmail.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseEmail.js","sourceRoot":"","sources":["../../src/Validate/parseEmail.ts"],"names":[],"mappings":"AAOA,MAAM,cAAc,GAAG;IACrB,KAAK,EACH,2JAA2J;IAC7J,MAAM,EACJ,+iBAA+iB;IACjjB,OAAO,EACL,oQAAoQ;IACtQ,OAAO,EACL,mUAAmU;IACrU,OAAO,EACL,ktCAAktC;CAC5sC,CAAC;AAMX,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,EACzB,KAAK,EACL,OAAO,GAIR,EAGC,EAAE;IACF,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAC1B,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAElC,OAAO;QACL,KAAK,EAAE,KAAK,KAAK,IAAI;QACrB,KAAK,EAAE,KAAK,EAAE,MAAM;YAClB,CAAC,CAAC;gBACE,qFAAqF;gBACrF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC;gBAC5B,qFAAqF;gBACrF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;aAC/B;YACH,CAAC,CAAC,SAAS;KACd,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"parseEmail.js","sourceRoot":"","sources":["../../src/Validate/parseEmail.ts"],"names":[],"mappings":"AAOA,MAAM,cAAc,GAAG;IACrB,KAAK,EACH,6IAA6I;IAC/I,MAAM,EACJ,yhBAAyhB;IAC3hB,OAAO,EACL,sOAAsO;IACxO,OAAO,EACL,iSAAiS;IACnS,OAAO,EACL,snCAAsnC;CAChnC,CAAC;AAMX,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,EACzB,KAAK,EACL,OAAO,GAIR,EAGC,EAAE;IACF,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAC1B,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAElC,OAAO;QACL,KAAK,EAAE,KAAK,KAAK,IAAI;QACrB,KAAK,EAAE,KAAK,EAAE,MAAM;YAClB,CAAC,CAAC;gBACE,qFAAqF;gBACrF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC;gBAC5B,qFAAqF;gBACrF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;aAC/B;YACH,CAAC,CAAC,SAAS;KACd,CAAC;AACJ,CAAC,CAAC"}

package/module/es5/Array/arraysJoin.js

@@ -21,5 +21,5 @@ var arraysJoin = exports.arraysJoin = function arraysJoin(array) {
   for (var _len = arguments.length, arrays = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     arrays[_key - 1] = arguments[_key];
   }
-  return _toConsumableArray(new Set(array.concat.apply(array, arrays)));
+  return _toConsumableArray(new Set([].concat(_toConsumableArray(array), _toConsumableArray(arrays.flat()))));
 };

package/module/es5/Array/chunk.js

@@ -13,8 +13,9 @@ exports.chunk = void 0;
 */
 var chunk = exports.chunk = function chunk(array, n) {
   var length = array.length;
-  // eslint-disable-next-line unicorn/no-new-array
-  var result = new Array(Math.ceil(length / n));
+  var result = Array.from({
+    length: Math.ceil(length / n)
+  });
   for (var index = 0, k = 0; index < length; index += n, k++) {
     result[k] = array.slice(index, index + n);
   }

package/module/es5/Array/generateNumberArray.js

@@ -27,19 +27,37 @@ var generateNumberArray = exports.generateNumberArray = function generateNumberA
   if (actualLength <= 0) {
     return [];
   }
-  if (min > actualMax) {
-    throw new Error("min should be less than or equal to max");
-  }
   if (actualLength === 1) {
     return [min];
   }
+  var isIntegerInputs = Number.isSafeInteger(min) && Number.isSafeInteger(actualMax);
   if (random) {
+    if (isIntegerInputs) {
+      var range = actualMax - min + 1;
+      return Array.from({
+        length: actualLength
+      }, function () {
+        return Math.floor(Math.random() * range) + min;
+      });
+    }
     return Array.from({
       length: actualLength
     }, function () {
       return (0, _addition.addition)(Math.floor((0, _multiplication.multiplication)(Math.random(), (0, _addition.addition)((0, _subtract.subtract)(actualMax, min), 1))), min);
     });
   }
+  if (isIntegerInputs) {
+    var _range = actualMax - min;
+    var steps = actualLength - 1;
+    if (_range % steps === 0) {
+      var _step = _range / steps;
+      return Array.from({
+        length: actualLength
+      }, function (_, index) {
+        return min + index * _step;
+      });
+    }
+  }
   var step = (0, _division.division)((0, _subtract.subtract)(actualMax, min), (0, _subtract.subtract)(actualLength, 1));
   return Array.from({
     length: actualLength

package/module/es5/Array/getArraysDiff.js

@@ -31,7 +31,11 @@ var getArraysDiff = exports.getArraysDiff = function getArraysDiff(array) {
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var value = _step.value;
+        if (duplicates.has(value)) {
+          continue;
+        }
         if (allValues.has(value)) {
+          allValues["delete"](value);
           duplicates.add(value);
         } else {
           allValues.add(value);
@@ -43,7 +47,5 @@ var getArraysDiff = exports.getArraysDiff = function getArraysDiff(array) {
       _iterator.f();
     }
   }
-  return _toConsumableArray(allValues).filter(function (value) {
-    return !duplicates.has(value);
-  });
+  return _toConsumableArray(allValues);
 };

package/module/es5/Array/mergeSort.js

@@ -5,6 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.mergeSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+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; }
 /**
  * Merge sort implementation
  * @param  {T[]} array Array to sort
@@ -12,34 +18,60 @@ var _compareFunctionDefault = require("./compareFunctionDefault");
  * @returns {T[]} Sorted array
  * @example mergeSort([1, 3, 2, 4, 5], (a, b) => a - b); // [1, 2, 3, 4, 5]
  */
-var _mergeSort = exports.mergeSort = function mergeSort(array) {
+var mergeSort = exports.mergeSort = function mergeSort(array) {
   var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
   if (array.length <= 1) {
     return array;
   }
-  var middle = Math.floor(array.length / 2);
-  var left = array.slice(0, middle);
-  var right = array.slice(middle);
-  return merge(_mergeSort(left, compareFunction), _mergeSort(right, compareFunction), compareFunction);
+  var length = array.length;
+  var result = _toConsumableArray(array);
+  var aux = _toConsumableArray(array);
+  mergeSortRecursive(result, aux, 0, length, compareFunction);
+  return result;
 };
 
 /**
- * Helper function to merge two sorted arrays
- * @param left Left array to merge
- * @param right Right array to merge
- * @param compareFunction Comparison function to determine order
- * @returns New merged array in sorted order
+ * Recursive merge sort implementation
+ * @param array Array to sort
+ * @param aux Auxiliary array
+ * @param start Start index
+ * @param end End index
+ * @param compareFunction Comparison function
  */
-function merge(left, right, compareFunction) {
-  var array = [];
-  var lIndex = 0;
-  var rIndex = 0;
-  while (lIndex < left.length && rIndex < right.length) {
-    if (compareFunction(left[lIndex], right[rIndex]) <= 0) {
-      array.push(left[lIndex++]);
+function mergeSortRecursive(array, aux, start, end, compareFunction) {
+  if (end - start <= 1) {
+    return;
+  }
+  var mid = start + end >>> 1;
+  mergeSortRecursive(array, aux, start, mid, compareFunction);
+  mergeSortRecursive(array, aux, mid, end, compareFunction);
+  merge(array, aux, start, mid, end, compareFunction);
+}
+
+/**
+ * Merges two sorted subarrays
+ * @param array Array containing the subarrays
+ * @param aux Auxiliary array
+ * @param start Start index
+ * @param mid Middle index
+ * @param end End index
+ * @param compareFunction Comparison function
+ */
+function merge(array, aux, start, mid, end, compareFunction) {
+  for (var index = start; index < end; index++) {
+    aux[index] = array[index];
+  }
+  var leftIndex = start;
+  var rightIndex = mid;
+  for (var k = start; k < end; k++) {
+    if (leftIndex >= mid) {
+      array[k] = aux[rightIndex++];
+    } else if (rightIndex >= end) {
+      array[k] = aux[leftIndex++];
+    } else if (compareFunction(aux[leftIndex], aux[rightIndex]) <= 0) {
+      array[k] = aux[leftIndex++];
     } else {
-      array.push(right[rIndex++]);
+      array[k] = aux[rightIndex++];
     }
   }
-  return array.concat(left.slice(lIndex)).concat(right.slice(rIndex));
 }

package/module/es5/Array/pop.js

@@ -4,17 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.pop = 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 the last element from an array and returns it.
  * @param {T[]} array - The array to remove the last element from.
  * @returns {T | undefined} - The last element of the array, or undefined if the array is empty.
  */
 var pop = exports.pop = function pop(array) {
-  return _toConsumableArray(array).pop();
+  // O(1) performance instead of O(N) from [...array].pop()
+  return array.at(-1);
 };

package/module/es5/Array/randomSelect.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.randomSelect = void 0;
+var _shuffle = require("./shuffle");
 /**
  * Randomly selects a specified number of elements from an array
  * @param array Source array
@@ -14,6 +15,13 @@ exports.randomSelect = void 0;
  */
 var randomSelect = exports.randomSelect = function randomSelect(array, count) {
   var allowDuplicates = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (!allowDuplicates && count > array.length * 0.8) {
+    var shuffled = (0, _shuffle.shuffle)(array);
+    if (count < shuffled.length) {
+      shuffled.length = count;
+    }
+    return shuffled;
+  }
   var result = [];
   var usedIndices = new Set();
   while (result.length < count && (allowDuplicates || result.length < array.length)) {

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.validateRange = void 0;
+var _clamp = require("../../Math/clamp");
 /**
  * Validates and adjusts the start and end indices for an operation on an array.
  * Ensures indices are within the bounds of the array.
@@ -25,8 +26,8 @@ var validateRange = exports.validateRange = function validateRange(array, startI
       shouldSort: false
     };
   }
-  var validatedStartIndex = Math.max(0, Math.min(startIndex, length - 1));
-  var validatedEndIndex = Math.max(validatedStartIndex, Math.min(endIndex, length - 1));
+  var validatedStartIndex = (0, _clamp.clamp)(startIndex, 0, length - 1);
+  var validatedEndIndex = Math.max(validatedStartIndex, (0, _clamp.clamp)(endIndex, 0, length - 1));
   return {
     startIndex: validatedStartIndex,
     endIndex: validatedEndIndex,

package/module/es5/Array/timSort.js

@@ -21,32 +21,33 @@ var MIN_RUN = 32;
  * @param mid Middle index separating the two portions
  * @param end Ending index of the second portion
  * @param compareFunction Function to compare elements
+ * @param temporary Temporary array for merging
  */
-var merge = function merge(array, start, mid, end, compareFunction) {
-  var left = array.slice(start, mid + 1);
-  var right = array.slice(mid + 1, end + 1);
-  var leftIndex = 0;
-  var rightIndex = 0;
-  var arrayIndex = start;
-  while (leftIndex < left.length && rightIndex < right.length) {
-    if (compareFunction(left[leftIndex], right[rightIndex]) <= 0) {
-      array[arrayIndex] = left[leftIndex];
-      leftIndex++;
+var merge = function merge(array, start, mid, end, compareFunction, temporary) {
+  var length1 = mid - start + 1;
+  if (compareFunction(array[mid], array[mid + 1]) <= 0) {
+    return;
+  }
+  for (var _index = 0; _index < length1; _index++) {
+    temporary[_index] = array[start + _index];
+  }
+  var index = 0;
+  var index_ = mid + 1;
+  var k = start;
+  while (index < length1 && index_ <= end) {
+    if (compareFunction(temporary[index], array[index_]) <= 0) {
+      array[k] = temporary[index];
+      index++;
     } else {
-      array[arrayIndex] = right[rightIndex];
-      rightIndex++;
+      array[k] = array[index_];
+      index_++;
     }
-    arrayIndex++;
-  }
-  while (leftIndex < left.length) {
-    array[arrayIndex] = left[leftIndex];
-    leftIndex++;
-    arrayIndex++;
+    k++;
   }
-  while (rightIndex < right.length) {
-    array[arrayIndex] = right[rightIndex];
-    rightIndex++;
-    arrayIndex++;
+  while (index < length1) {
+    array[k] = temporary[index];
+    k++;
+    index++;
   }
 };
 
@@ -92,12 +93,13 @@ var timSort = exports.timSort = function timSort(array) {
     var runEnd = Math.min(runStart + minRun - 1, end);
     (0, _insertionSortRange.insertionSortRange)(result, compareFunction, runStart, runEnd);
   }
+  var temporary = [];
   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(result, left, mid, right, compareFunction);
+        merge(result, left, mid, right, compareFunction, temporary);
       }
     }
   }