umt 2.1.2 → 2.2.1

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

@@ -2,7 +2,7 @@
 
 var _randomSelect = require("@/Array/randomSelect");
 describe("randomSelect", function () {
-  it("指定された数の要素をランダムに選択する", 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);
@@ -10,7 +10,7 @@ describe("randomSelect", function () {
       expect(array).toContain(item);
     });
   });
-  it("選択する要素の数が配列の長さを超える場合、元の配列の長さと同じ数の要素を返す", function () {
+  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);
@@ -18,11 +18,11 @@ describe("randomSelect", function () {
       expect(array).toContain(item);
     });
   });
-  it("空の配列を渡した場合、空の配列を返す", function () {
+  it("should return an empty array when given an empty array", function () {
     var result = (0, _randomSelect.randomSelect)([], 3);
     expect(result).toEqual([]);
   });
-  it("重複を許す場合、指定された数の要素を返す", function () {
+  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);
@@ -30,7 +30,7 @@ describe("randomSelect", function () {
       expect(array).toContain(item);
     });
   });
-  it("重複を許さない場合、指定された数の要素を返す", function () {
+  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);
@@ -38,9 +38,14 @@ describe("randomSelect", function () {
       expect(array).toContain(item);
     });
   });
-  it("選択する要素の数がマイナスの場合、空の配列を返す", function () {
+  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.js

@@ -2,20 +2,41 @@
 
 var _range = require("@/Array/range");
 describe("range", function () {
-  test("-5から5までの連続した数字の配列を生成する。", 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("1から10までの連続した数字の配列を生成する。", function () {
+  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("空の配列が出力される。", function () {
+  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("0から5までの連続した数字の配列を生成する。", function () {
+  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.js

@@ -1,30 +1,30 @@
 "use strict";
 
 var _shuffle = require("@/Array/shuffle");
-describe("shuffle関数のテスト", function () {
-  it("配列の要素がシャッフルされること", function () {
+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("空の配列がそのまま返されること", function () {
+  it("should return empty array unchanged", function () {
     var array = [];
     var shuffledArray = (0, _shuffle.shuffle)(array);
     expect(shuffledArray).toEqual(array);
   });
-  it("シャッフルされた配列の長さが元の配列と同じであること", function () {
+  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("文字列と数値が混在した配列の要素がシャッフルされること", function () {
+  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("長い配列の要素がシャッフルされること", function () {
+  it("should shuffle large arrays", function () {
     var array = Array.from({
       length: 1000
     }, function (_, index) {
@@ -34,4 +34,51 @@ describe("shuffle関数のテスト", function () {
     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.js

@@ -1,18 +1,29 @@
 "use strict";
 
 var _shuffle2DArray = require("@/Array/shuffle2DArray");
-describe("shuffle2DArray関数のテスト", function () {
-  it("空の2次元配列がそのまま返されること", function () {
+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("サブ配列が空の場合もそのまま返されること", function () {
+  it("should return array with empty subarrays unchanged", function () {
     var array = [[], [], []];
     var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
     expect(shuffledArray).toEqual(array);
   });
-  it("シャッフルされた2次元配列の長さが元の配列と同じであること", function () {
+  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);
@@ -20,28 +31,60 @@ describe("shuffle2DArray関数のテスト", function () {
       expect(subArray.length).toBe(array[index].length);
     });
   });
-  it("異なる型を含む2次元配列がシャッフルされること", function () {
+  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("長い配列の要素がシャッフルされること", function () {
+  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.js

@@ -1,6 +1,44 @@
 "use strict";
 
 var _sum = require("@/Array/sum");
-test("{sum}", function () {
-  expect((0, _sum.sum)([1, 2, 3])).toBe(6);
+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.js

@@ -2,26 +2,26 @@
 
 var _timSort = require("@/Array/timSort");
 describe("timSort", function () {
-  it("空の配列をソートすると空の配列が返される", function () {
+  it("should return an empty array when sorting an empty array", function () {
     expect((0, _timSort.timSort)([])).toEqual([]);
   });
-  it("既にソートされた配列はそのまま返される", function () {
+  it("should return the same array when it's already sorted", function () {
     expect((0, _timSort.timSort)([1, 2, 3])).toEqual([1, 2, 3]);
   });
-  it("逆順にソートされた配列を正しくソートする", function () {
+  it("should correctly sort a reverse-sorted array", function () {
     expect((0, _timSort.timSort)([3, 2, 1])).toEqual([1, 2, 3]);
   });
-  it("ランダムな配列を正しくソートする", function () {
+  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("重複した要素を含む配列を正しくソートする", function () {
+  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("大量の要素を含む配列を正しくソートする", function () {
+  it("should correctly sort an array with large number of elements", function () {
     var largeArray = Array.from({
       length: 10000
     }, function () {
@@ -32,17 +32,97 @@ describe("timSort", function () {
     });
     expect((0, _timSort.timSort)(largeArray)).toEqual(sortedArray);
   });
-  it("負の数を含む配列を正しくソートする", function () {
+  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("配列を降順にソートする", function () {
+  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("部分配列をソートする", function () {
+  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.js

@@ -1,30 +1,69 @@
 "use strict";
 
 var _zip = require("@/Array/zip");
-describe("zip関数のテスト", function () {
-  it("複数の配列を組み合わせる", function () {
+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("異なる長さの配列を組み合わせる", function () {
+  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("空の配列を含む組み合わせ", function () {
+  it("should handle empty arrays correctly", function () {
     var array1 = [1, 2, 3];
-    // @ts-ignore
-    var array2 = [];
-    // @ts-ignore
-    var result = (0, _zip.zip)(array1, array2);
+    var emptyArray = [];
+    var result = (0, _zip.zip)(array1, emptyArray);
     expect(result).toEqual([]);
   });
-  it("引数がない場合は空の配列を返す", function () {
+  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.js

@@ -1,31 +1,74 @@
 "use strict";
 
 var _zipLongest = require("@/Array/zipLongest");
-describe("zipLongest関数のテスト", function () {
-  it("異なる長さの配列を組み合わせる", function () {
+describe("zipLongest function", function () {
+  it("should combine arrays of different lengths with undefined padding", function () {
     var array1 = [1, 2];
     var array2 = ["one", "two", "three"];
     var array3 = [true, false, true, false];
     var result = (0, _zipLongest.zipLongest)(array1, array2, array3);
     expect(result).toEqual([[1, "one", true], [2, "two", false], [undefined, "three", true], [undefined, undefined, false]]);
   });
-  it("すべての配列が同じ長さの場合", function () {
+  it("should combine arrays of equal length", function () {
     var array1 = [1, 2, 3];
     var array2 = ["one", "two", "three"];
     var array3 = [true, false, true];
     var result = (0, _zipLongest.zipLongest)(array1, array2, array3);
     expect(result).toEqual([[1, "one", true], [2, "two", false], [3, "three", true]]);
   });
-  it("空の配列を含む組み合わせ", function () {
+  it("should handle empty arrays correctly", function () {
     var array1 = [1, 2, 3];
-    // @ts-ignore
-    var array2 = [];
-    // @ts-ignore
-    var result = (0, _zipLongest.zipLongest)(array1, array2);
+    var emptyArray = [];
+    var result = (0, _zipLongest.zipLongest)(array1, emptyArray);
     expect(result).toEqual([[1, undefined], [2, undefined], [3, undefined]]);
   });
-  it("引数がない場合は空の配列を返す", function () {
+  it("should return an empty array when no arguments are provided", function () {
     var result = (0, _zipLongest.zipLongest)();
     expect(result).toEqual([]);
   });
+  it("should handle arrays with null and undefined values", function () {
+    var array1 = [1, null, 3];
+    var array2 = ["a", undefined, "c", "d"];
+    var result = (0, _zipLongest.zipLongest)(array1, array2);
+    expect(result).toEqual([[1, "a"], [null, undefined], [3, "c"], [undefined, "d"]]);
+  });
+  it("should handle nested arrays", function () {
+    var array1 = [[1], [2]];
+    var array2 = [["a"], ["b"], ["c"]];
+    var result = (0, _zipLongest.zipLongest)(array1, array2);
+    expect(result).toEqual([[[1], ["a"]], [[2], ["b"]], [undefined, ["c"]]]);
+  });
+  it("should handle arrays of objects", function () {
+    var array1 = [{
+      id: 1
+    }, {
+      id: 2
+    }];
+    var array2 = [{
+      name: "a"
+    }, {
+      name: "b"
+    }, {
+      name: "c"
+    }];
+    var result = (0, _zipLongest.zipLongest)(array1, array2);
+    expect(result).toEqual([[{
+      id: 1
+    }, {
+      name: "a"
+    }], [{
+      id: 2
+    }, {
+      name: "b"
+    }], [undefined, {
+      name: "c"
+    }]]);
+  });
+  it("should handle mixed type arrays with type safety", function () {
+    var numbers = [1, 2];
+    var strings = ["a", "b", "c"];
+    var booleans = [true];
+    var result = (0, _zipLongest.zipLongest)(numbers, strings, booleans);
+    expect(result).toEqual([[1, "a", true], [2, "b", undefined], [undefined, "c", undefined]]);
+  });
 });

package/module/es5/tests/unit/Color/cmykToRgba.test.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var _cmykToRgba = require("@/Color/cmykToRgba");
-describe("cmykToRgba関数のテスト", function () {
+describe("cmykToRgba function", function () {
   it.each([[100, 100, 0, 60.78, 1, {
     r: 0,
     g: 0,
@@ -32,10 +32,10 @@ describe("cmykToRgba関数のテスト", function () {
     g: 64,
     b: 64,
     a: 1
-  }]])("CMYK(%i, %i, %i, %i, %i)をRGBAに変換する", function (c, m, y, k, a, expected) {
+  }]])("should convert CMYK(%i, %i, %i, %i, %i) to RGBA", function (c, m, y, k, a, expected) {
     expect((0, _cmykToRgba.cmykToRgba)(c, m, y, k, a)).toEqual(expected);
   });
-  it("不正な値を渡した場合の挙動", function () {
+  it("should handle invalid values", function () {
     expect((0, _cmykToRgba.cmykToRgba)(-1, 100, 100, 0)).toEqual({
       r: 255,
       g: 0,