umt 2.3.0 → 2.4.0

package/module/es5/tests/unit/Array/quickSort.test.js

@@ -1,118 +0,0 @@
-"use strict";
-
-var _quickSort = require("@/Array/quickSort");
-describe("quickSort", function () {
-  it("should return an empty array when sorting an empty array", function () {
-    expect((0, _quickSort.quickSort)([])).toEqual([]);
-  });
-  it("should return the same array when it's already sorted", function () {
-    expect((0, _quickSort.quickSort)([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
-  });
-  it("should correctly sort a reverse-sorted array", function () {
-    expect((0, _quickSort.quickSort)([5, 4, 3, 2, 1])).toEqual([1, 2, 3, 4, 5]);
-  });
-  it("should correctly sort a random array", function () {
-    expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]);
-  });
-  it("should correctly sort an array with duplicate elements", function () {
-    expect((0, _quickSort.quickSort)([3, 3, 3, 2, 1, 1, 4, 4, 5])).toEqual([1, 1, 2, 3, 3, 3, 4, 4, 5]);
-  });
-  it("should correctly sort an array with large number of elements", function () {
-    var largeArray = Array.from({
-      length: 10000
-    }, function () {
-      return Math.floor(Math.random() * 10000);
-    });
-    var sortedArray = [].concat(largeArray).sort(function (a, b) {
-      return a - b;
-    });
-    expect((0, _quickSort.quickSort)(largeArray)).toEqual(sortedArray);
-  });
-  it("should correctly sort an array with negative numbers", function () {
-    expect((0, _quickSort.quickSort)([5, -1, 3, 2, 4, -5, 1, -2, 0])).toEqual([-5, -2, -1, 0, 1, 2, 3, 4, 5]);
-  });
-  it("should sort array in descending order", function () {
-    expect((0, _quickSort.quickSort)([1, 2, 3, 4, 5], function (a, b) {
-      return b - a;
-    })).toEqual([5, 4, 3, 2, 1]);
-  });
-  it("should sort a portion of the array", function () {
-    expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, 1, 3)).toEqual([3, 1, 1, 4, 5]);
-  });
-  it("should return single-element array unchanged", function () {
-    expect((0, _quickSort.quickSort)([1])).toEqual([1]);
-  });
-  it("should handle compareFunction throwing an error", function () {
-    var throwCompare = function throwCompare() {
-      throw new Error("Error during comparison");
-    };
-    expect(function () {
-      return (0, _quickSort.quickSort)([3, 1, 4], throwCompare);
-    }).toThrow("Error during comparison");
-  });
-  describe("median of three cases", function () {
-    it("should handle all elements equal", function () {
-      expect((0, _quickSort.quickSort)([5, 5, 5, 5, 5])).toEqual([5, 5, 5, 5, 5]);
-    });
-    it("should handle three-element arrays in all orders", function () {
-      expect((0, _quickSort.quickSort)([1, 2, 3])).toEqual([1, 2, 3]); // a < b < c
-      expect((0, _quickSort.quickSort)([1, 3, 2])).toEqual([1, 2, 3]); // a < c < b
-      expect((0, _quickSort.quickSort)([2, 1, 3])).toEqual([1, 2, 3]); // b < a < c
-      expect((0, _quickSort.quickSort)([2, 3, 1])).toEqual([1, 2, 3]); // b < c < a
-      expect((0, _quickSort.quickSort)([3, 1, 2])).toEqual([1, 2, 3]); // c < a < b
-      expect((0, _quickSort.quickSort)([3, 2, 1])).toEqual([1, 2, 3]); // c < b < a
-    });
-  });
-  describe("insertion sort threshold cases", function () {
-    it("should handle arrays at threshold size", function () {
-      var arr = Array.from({
-        length: 10
-      }, function (_, i) {
-        return 10 - i;
-      });
-      expect((0, _quickSort.quickSort)(arr)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    });
-    it("should handle arrays below threshold size", function () {
-      var arr = Array.from({
-        length: 5
-      }, function (_, i) {
-        return 5 - i;
-      });
-      expect((0, _quickSort.quickSort)(arr)).toEqual([1, 2, 3, 4, 5]);
-    });
-    it("should handle custom threshold", function () {
-      var arr = Array.from({
-        length: 20
-      }, function (_, i) {
-        return 20 - i;
-      });
-      expect((0, _quickSort.quickSort)(arr, undefined, 0, arr.length - 1, 5)).toEqual(Array.from({
-        length: 20
-      }, function (_, i) {
-        return i + 1;
-      }));
-    });
-  });
-  describe("boundary conditions", function () {
-    it("should handle invalid index ranges", function () {
-      // Out of bounds indices should be clamped to valid range
-      expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, -1, 10)).toEqual([1, 1, 3, 4, 5]);
-      expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, 10, -1)).toEqual([3, 1, 4, 1, 5]);
-
-      // When startIndex > endIndex, array should remain unchanged
-      var arr = [3, 1, 4, 1, 5];
-      expect((0, _quickSort.quickSort)([].concat(arr), undefined, 3, 1)).toEqual(arr);
-
-      // Sorting empty range should not change array
-      expect((0, _quickSort.quickSort)([].concat(arr), undefined, 2, 2)).toEqual(arr);
-    });
-    it("should handle two-element arrays", function () {
-      expect((0, _quickSort.quickSort)([2, 1])).toEqual([1, 2]);
-      expect((0, _quickSort.quickSort)([1, 2])).toEqual([1, 2]);
-    });
-    it("should handle arrays with all same value except one", function () {
-      expect((0, _quickSort.quickSort)([1, 1, 1, 0, 1])).toEqual([0, 1, 1, 1, 1]);
-      expect((0, _quickSort.quickSort)([1, 1, 1, 2, 1])).toEqual([1, 1, 1, 1, 2]);
-    });
-  });
-});

package/module/es5/tests/unit/Array/randomSelect.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/randomSelect.test.js

@@ -1,51 +0,0 @@
-"use strict";
-
-var _randomSelect = require("@/Array/randomSelect");
-describe("randomSelect", function () {
-  it("should randomly select the specified number of elements", function () {
-    var array = [1, 2, 3, 4, 5];
-    var result = (0, _randomSelect.randomSelect)(array, 2);
-    expect(result).toHaveLength(2);
-    result.forEach(function (item) {
-      expect(array).toContain(item);
-    });
-  });
-  it("should return elements equal to array length when count exceeds array length", function () {
-    var array = [1, 2, 3];
-    var result = (0, _randomSelect.randomSelect)(array, 5);
-    expect(result).toHaveLength(3);
-    result.forEach(function (item) {
-      expect(array).toContain(item);
-    });
-  });
-  it("should return an empty array when given an empty array", function () {
-    var result = (0, _randomSelect.randomSelect)([], 3);
-    expect(result).toEqual([]);
-  });
-  it("should return specified count with duplicates when allowDuplicates is true", function () {
-    var array = [1, 2, 3];
-    var result = (0, _randomSelect.randomSelect)(array, 5, true);
-    expect(result).toHaveLength(5);
-    result.forEach(function (item) {
-      expect(array).toContain(item);
-    });
-  });
-  it("should return specified count without duplicates when allowDuplicates is false", function () {
-    var array = [1, 2, 3, 4, 5];
-    var result = (0, _randomSelect.randomSelect)(array, 3, false);
-    expect(result).toHaveLength(3);
-    result.forEach(function (item) {
-      expect(array).toContain(item);
-    });
-  });
-  it("should return an empty array when count is negative", function () {
-    var array = [1, 2, 3, 4, 5];
-    var result = (0, _randomSelect.randomSelect)(array, -1);
-    expect(result).toEqual([]);
-  });
-  it("should return an empty array when count is zero", function () {
-    var array = [1, 2, 3, 4, 5];
-    var result = (0, _randomSelect.randomSelect)(array, 0);
-    expect(result).toEqual([]);
-  });
-});

package/module/es5/tests/unit/Array/range.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/range.test.js

@@ -1,42 +0,0 @@
-"use strict";
-
-var _range = require("@/Array/range");
-describe("range", function () {
-  test("should generate an array of consecutive numbers from -5 to 5", function () {
-    var result = (0, _range.range)(-5, 5);
-    expect(result).toEqual([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]);
-  });
-  test("should generate an array of consecutive numbers from 1 to 10", function () {
-    var result = (0, _range.range)(1, 10);
-    expect(result).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  });
-  test("should return an empty array when start equals end", function () {
-    expect((0, _range.range)(0, 0)).toEqual([]);
-    expect((0, _range.range)(5, 5)).toEqual([]);
-  });
-  test("should generate an array of consecutive numbers from 0 to start", function () {
-    var result = (0, _range.range)(5);
-    expect(result).toEqual([0, 1, 2, 3, 4]);
-  });
-  test("should generate an array with specified step", function () {
-    expect((0, _range.range)(0, 10, 2)).toEqual([0, 2, 4, 6, 8]);
-    expect((0, _range.range)(0, 5, 0.5)).toEqual([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5]);
-  });
-  test("should handle negative step", function () {
-    expect((0, _range.range)(5, 0, -1)).toEqual([5, 4, 3, 2, 1]);
-    expect((0, _range.range)(0, -5, -1)).toEqual([0, -1, -2, -3, -4]);
-    expect((0, _range.range)(10, 5, -2)).toEqual([10, 8, 6]);
-  });
-  test("should handle step of zero", function () {
-    expect((0, _range.range)(0, 5, 0)).toEqual([]); // Avoid infinite loop
-  });
-  test("should handle start greater than end", function () {
-    expect((0, _range.range)(10, 5)).toEqual([]); // Returns empty array when start > end
-  });
-  test("should handle floating point steps", function () {
-    expect((0, _range.range)(0, 1, 0.2)).toEqual([0, 0.2, 0.4, 0.6, 0.8]);
-  });
-  test("should handle single step from 0 to start", function () {
-    expect((0, _range.range)(3, undefined, 2)).toEqual([0, 2]);
-  });
-});

package/module/es5/tests/unit/Array/shuffle.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/shuffle.test.js

@@ -1,84 +0,0 @@
-"use strict";
-
-var _shuffle = require("@/Array/shuffle");
-describe("shuffle function", function () {
-  it("should shuffle array elements", function () {
-    var array = [1, 2, 3, 4, 5];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray).not.toEqual(array);
-    expect(shuffledArray.sort()).toEqual(array.sort());
-  });
-  it("should return empty array unchanged", function () {
-    var array = [];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray).toEqual(array);
-  });
-  it("should maintain the same length after shuffling", function () {
-    var array = [1, 2, 3, 4, 5];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray.length).toBe(array.length);
-  });
-  it("should shuffle array with mixed strings and numbers", function () {
-    var array = [1, "2", 3, "4", 5];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray).not.toEqual(array);
-    expect(shuffledArray.sort()).toEqual(array.sort());
-  });
-  it("should shuffle large arrays", function () {
-    var array = Array.from({
-      length: 1000
-    }, function (_, index) {
-      return index;
-    });
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray).not.toEqual(array);
-    expect(shuffledArray.sort()).toEqual(array.sort());
-  });
-  it("should return single-element array unchanged", function () {
-    var array = [1];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray).toEqual(array);
-  });
-  it("should maintain frequency of duplicate elements", function () {
-    var array = [1, 1, 2, 2, 3, 3];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    var countElements = function countElements(arr) {
-      return arr.reduce(function (acc, curr) {
-        acc[curr] = (acc[curr] || 0) + 1;
-        return acc;
-      }, {});
-    };
-    expect(countElements(shuffledArray)).toEqual(countElements(array));
-  });
-  it("should handle array of objects", function () {
-    var array = [{
-      id: 1,
-      value: "one"
-    }, {
-      id: 2,
-      value: "two"
-    }, {
-      id: 3,
-      value: "three"
-    }, {
-      id: 4,
-      value: "four"
-    }, {
-      id: 5,
-      value: "five"
-    }];
-    var shuffledArray = (0, _shuffle.shuffle)(array);
-    expect(shuffledArray).not.toEqual(array);
-    expect(shuffledArray.map(function (obj) {
-      return obj.id;
-    }).sort()).toEqual(array.map(function (obj) {
-      return obj.id;
-    }).sort());
-  });
-  it("should not modify the original array", function () {
-    var array = [1, 2, 3, 4, 5];
-    var originalArray = [].concat(array);
-    (0, _shuffle.shuffle)(array);
-    expect(array).toEqual(originalArray);
-  });
-});

package/module/es5/tests/unit/Array/shuffle2DArray.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/shuffle2DArray.test.js

@@ -1,90 +0,0 @@
-"use strict";
-
-var _shuffle2DArray = require("@/Array/shuffle2DArray");
-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; }
-describe("shuffle2DArray function", function () {
-  it("should handle single-element 2D array", function () {
-    var array = [[1]];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    expect(shuffledArray).toEqual(array);
-  });
-  it("should return empty 2D array unchanged", function () {
-    var array = [];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    expect(shuffledArray).toEqual(array);
-  });
-  it("should return array with empty subarrays unchanged", function () {
-    var array = [[], [], []];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    expect(shuffledArray).toEqual(array);
-  });
-  it("should maintain the same length of 2D array and subarrays after shuffling", function () {
-    var array = [[1, 2], [3, 4], [5, 6]];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    expect(shuffledArray.length).toBe(array.length);
-    shuffledArray.forEach(function (subArray, index) {
-      expect(subArray.length).toBe(array[index].length);
-    });
-  });
-  it("should shuffle 2D array with mixed types", function () {
-    var array = [[1, "2"], ["3", 4], [5, "6"]];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    // Check if the entire array is shuffled
-    expect(shuffledArray.map(function (subArray) {
-      return subArray.sort();
-    })).not.toEqual(array.map(function (subArray) {
-      return subArray.sort();
-    }));
-  });
-  it("should shuffle large 2D arrays", function () {
-    var array = Array.from({
-      length: 1000
-    }, function (_, index) {
-      return [index, index + 1];
-    });
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    // Check if the entire array is shuffled
-    expect(shuffledArray.map(function (subArray) {
-      return subArray.sort();
-    })).not.toEqual(array.map(function (subArray) {
-      return subArray.sort();
-    }));
-  });
-  it("should handle subarrays of different lengths", function () {
-    var array = [[1], [2, 3], [4, 5, 6]];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    expect(shuffledArray.length).toBe(array.length);
-    shuffledArray.forEach(function (subArray, index) {
-      expect(subArray.length).toBe(array[index].length);
-    });
-    // Verify the total number of elements remains the same
-    var flatOriginal = array.flat();
-    var flatShuffled = shuffledArray.flat();
-    expect(flatShuffled.sort()).toEqual(flatOriginal.sort());
-  });
-  it("should not modify the original array", function () {
-    var array = [[1, 2], [3, 4], [5, 6]];
-    var originalArray = array.map(function (subArray) {
-      return _toConsumableArray(subArray);
-    });
-    (0, _shuffle2DArray.shuffle2DArray)(array);
-    expect(array).toEqual(originalArray);
-  });
-  it("should maintain the total count of each unique element", function () {
-    var array = [[1, 1], [2, 2], [1, 2]];
-    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
-    var countElements = function countElements(arr) {
-      var counts = {};
-      arr.flat().forEach(function (num) {
-        counts[num] = (counts[num] || 0) + 1;
-      });
-      return counts;
-    };
-    expect(countElements(shuffledArray)).toEqual(countElements(array));
-  });
-});

package/module/es5/tests/unit/Array/sum.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/sum.test.js

@@ -1,44 +0,0 @@
-"use strict";
-
-var _sum = require("@/Array/sum");
-describe("sum function", function () {
-  it("should calculate sum of integer numbers", function () {
-    expect((0, _sum.sum)([1, 2, 3])).toBe(6);
-    expect((0, _sum.sum)([10, 20, 30])).toBe(60);
-    expect((0, _sum.sum)([-1, -2, -3])).toBe(-6);
-    expect((0, _sum.sum)([])).toBe(0);
-  });
-  it("should calculate sum of decimal numbers", function () {
-    expect((0, _sum.sum)([0.1, 0.2, 0.3])).toBe(0.6);
-    expect((0, _sum.sum)([1.1, 2.2, 3.3])).toBe(6.6);
-    expect((0, _sum.sum)([0.1, 0.02, 0.003])).toBe(0.123);
-  });
-  it("should handle mixed integer and decimal numbers", function () {
-    expect((0, _sum.sum)([1, 2.5, 3.7])).toBe(7.2);
-    expect((0, _sum.sum)([-1.5, 2, -3.7])).toBe(-3.2);
-  });
-  it("should handle large numbers", function () {
-    var largeNum = 1000000000; // 10^9
-    expect((0, _sum.sum)([largeNum, largeNum])).toBe(2 * largeNum);
-    expect((0, _sum.sum)([largeNum, -largeNum])).toBe(0);
-    expect((0, _sum.sum)([largeNum, 1, -1])).toBe(largeNum);
-    var mediumNum = 1000000; // 10^6
-    var count = 1000;
-    var arr = new Array(count).fill(mediumNum);
-    expect((0, _sum.sum)(arr)).toBe(mediumNum * count);
-  });
-  it("should handle very small numbers", function () {
-    var smallNum = Number.MIN_VALUE;
-    expect((0, _sum.sum)([smallNum, smallNum])).toBe(2 * smallNum);
-    expect((0, _sum.sum)([smallNum, -smallNum])).toBe(0);
-  });
-  it("should handle JavaScript number precision", function () {
-    // Testing number precision handling
-    expect((0, _sum.sum)([0.1, 0.2])).toBeCloseTo(0.3, 10);
-    expect((0, _sum.sum)([0.1, 0.2, 0.3, 0.4, 0.5])).toBeCloseTo(1.5, 10);
-  });
-  it("should maintain precision for many decimal places", function () {
-    expect((0, _sum.sum)([0.0001, 0.0002, 0.0003])).toBe(0.0006);
-    expect((0, _sum.sum)([1.23456, 2.34567, 3.45678])).toBeCloseTo(7.03701, 5);
-  });
-});

package/module/es5/tests/unit/Array/timSort.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/timSort.test.js

@@ -1,128 +0,0 @@
-"use strict";
-
-var _timSort = require("@/Array/timSort");
-describe("timSort", function () {
-  it("should return an empty array when sorting an empty array", function () {
-    expect((0, _timSort.timSort)([])).toEqual([]);
-  });
-  it("should return the same array when it's already sorted", function () {
-    expect((0, _timSort.timSort)([1, 2, 3])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort a reverse-sorted array", function () {
-    expect((0, _timSort.timSort)([3, 2, 1])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort a random array", function () {
-    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
-    var sortedArray = [].concat(array).sort(function (a, b) {
-      return a - b;
-    });
-    expect((0, _timSort.timSort)(array)).toEqual(sortedArray);
-  });
-  it("should correctly sort an array with duplicate elements", function () {
-    expect((0, _timSort.timSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
-  });
-  it("should correctly sort an array with large number of elements", function () {
-    var largeArray = Array.from({
-      length: 10000
-    }, function () {
-      return Math.floor(Math.random() * 10000);
-    });
-    var sortedArray = [].concat(largeArray).sort(function (a, b) {
-      return a - b;
-    });
-    expect((0, _timSort.timSort)(largeArray)).toEqual(sortedArray);
-  });
-  it("should correctly sort an array with negative numbers", function () {
-    expect((0, _timSort.timSort)([5, -1, 3, 2, 4, -5, 1, -2, 0])).toEqual([-5, -2, -1, 0, 1, 2, 3, 4, 5]);
-  });
-  it("should sort array in descending order", function () {
-    expect((0, _timSort.timSort)([1, 2, 3], function (a, b) {
-      return b - a;
-    })).toEqual([3, 2, 1]);
-  });
-  it("should sort a portion of the array", function () {
-    expect((0, _timSort.timSort)([1, 3, 2, 5, 4], function (a, b) {
-      return a - b;
-    }, 1, 3)).toEqual([1, 2, 3, 5, 4]);
-  });
-  it("should maintain stability when sorting objects", function () {
-    var array = [{
-      value: 2,
-      order: 1
-    }, {
-      value: 1,
-      order: 2
-    }, {
-      value: 2,
-      order: 3
-    }, {
-      value: 1,
-      order: 4
-    }];
-    var result = (0, _timSort.timSort)(array, function (a, b) {
-      return a.value - b.value;
-    });
-    expect(result.map(function (x) {
-      return x.order;
-    })).toEqual([2, 4, 1, 3]); // original order within same values
-  });
-  it("should handle arrays just larger than MIN_RUN", function () {
-    var array = Array.from({
-      length: 33
-    }, function (_, i) {
-      return 33 - i;
-    });
-    var result = (0, _timSort.timSort)(array);
-    expect(result).toEqual(Array.from({
-      length: 33
-    }, function (_, i) {
-      return i + 1;
-    }));
-  });
-  it("should handle arrays with repeated elements near run boundaries", function () {
-    // Creates runs with repeated elements at boundaries
-    var array = [];
-    for (var i = 0; i < 64; i++) {
-      array.push(Math.floor(i / 16)); // Creates 4 values, each repeated 16 times
-    }
-    var shuffled = [].concat(array).sort(function () {
-      return Math.random() - 0.5;
-    });
-    expect((0, _timSort.timSort)(shuffled)).toEqual(array);
-  });
-  it("should handle arrays with all identical elements", function () {
-    var array = new Array(100).fill(1);
-    expect((0, _timSort.timSort)(array)).toEqual(array);
-  });
-  it("should handle strings and numbers separately", function () {
-    var strings = ["b", "a", "d", "c"];
-    var numbers = [3, 1, 4, 2];
-    expect((0, _timSort.timSort)(strings)).toEqual(["a", "b", "c", "d"]);
-    expect((0, _timSort.timSort)(numbers)).toEqual([1, 2, 3, 4]);
-  });
-  it("should handle booleans", function () {
-    var array = [true, false, true, false];
-    expect((0, _timSort.timSort)(array)).toEqual([false, false, true, true]);
-  });
-  it("should handle null and undefined", function () {
-    var array = [null, undefined, null, undefined];
-    var compareFunction = function compareFunction(a, b) {
-      if (a === b) return 0;
-      if (a === null) return -1;
-      if (b === null) return 1;
-      if (a === undefined) return -1;
-      if (b === undefined) return 1;
-      return 0;
-    };
-    expect((0, _timSort.timSort)(array, compareFunction)).toEqual([null, null, undefined, undefined]);
-  });
-  it("should handle custom comparison for mixed types", function () {
-    var array = ["b", 2, "a", 1];
-    var compareFunction = function compareFunction(a, b) {
-      var aStr = String(a);
-      var bStr = String(b);
-      return aStr.localeCompare(bStr);
-    };
-    expect((0, _timSort.timSort)(array, compareFunction)).toEqual([1, 2, "a", "b"]);
-  });
-});

package/module/es5/tests/unit/Array/zip.test.d.ts

@@ -1 +0,0 @@
-export {};

package/module/es5/tests/unit/Array/zip.test.js

@@ -1,69 +0,0 @@
-"use strict";
-
-var _zip = require("@/Array/zip");
-describe("zip function", function () {
-  it("should combine multiple arrays", function () {
-    var array1 = [1, 2, 3];
-    var array2 = ["one", "two", "three"];
-    var array3 = [true, false, true];
-    var result = (0, _zip.zip)(array1, array2, array3);
-    expect(result).toEqual([[1, "one", true], [2, "two", false], [3, "three", true]]);
-  });
-  it("should combine arrays of different lengths", function () {
-    var array1 = [1, 2];
-    var array2 = ["one", "two", "three"];
-    var result = (0, _zip.zip)(array1, array2);
-    expect(result).toEqual([[1, "one"], [2, "two"]]);
-  });
-  it("should handle empty arrays correctly", function () {
-    var array1 = [1, 2, 3];
-    var emptyArray = [];
-    var result = (0, _zip.zip)(array1, emptyArray);
-    expect(result).toEqual([]);
-  });
-  it("should return an empty array when no arguments are provided", function () {
-    var result = (0, _zip.zip)();
-    expect(result).toEqual([]);
-  });
-  it("should handle arrays with null and undefined values", function () {
-    var array1 = [1, null, 3];
-    var array2 = ["a", undefined, "c"];
-    var result = (0, _zip.zip)(array1, array2);
-    expect(result).toEqual([[1, "a"], [null, undefined], [3, "c"]]);
-  });
-  it("should handle nested arrays", function () {
-    var array1 = [[1], [2], [3]];
-    var array2 = [["a"], ["b"], ["c"]];
-    var result = (0, _zip.zip)(array1, array2);
-    expect(result).toEqual([[[1], ["a"]], [[2], ["b"]], [[3], ["c"]]]);
-  });
-  it("should handle arrays of objects", function () {
-    var array1 = [{
-      id: 1
-    }, {
-      id: 2
-    }];
-    var array2 = [{
-      name: "a"
-    }, {
-      name: "b"
-    }];
-    var result = (0, _zip.zip)(array1, array2);
-    expect(result).toEqual([[{
-      id: 1
-    }, {
-      name: "a"
-    }], [{
-      id: 2
-    }, {
-      name: "b"
-    }]]);
-  });
-  it("should handle mixed type arrays without type errors", function () {
-    var numbers = [1, 2];
-    var strings = ["a", "b"];
-    var booleans = [true, false];
-    var result = (0, _zip.zip)(numbers, strings, booleans);
-    expect(result).toEqual([[1, "a", true], [2, "b", false]]);
-  });
-});

package/module/es5/tests/unit/Array/zipLongest.test.d.ts

@@ -1 +0,0 @@
-export {};