umt 1.9.0 → 2.0.0

package/module/es5/Array/quickSort.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.quickSort = void 0;
+var _compareFunctionDefault = require("./compareFunctionDefault");
+var medianOfThree = function medianOfThree(array, a, b, c, compareFunction) {
+  var ab = compareFunction(array[a], array[b]);
+  if (ab < 0) {
+    var bc = compareFunction(array[b], array[c]);
+    if (bc < 0) {
+      return array[b];
+    }
+    if (compareFunction(array[a], array[c]) < 0) {
+      return array[c];
+    }
+    return array[a];
+  }
+  var ac = compareFunction(array[a], array[c]);
+  if (ac < 0) {
+    return array[a];
+  }
+  if (compareFunction(array[b], array[c]) < 0) {
+    return array[c];
+  }
+  return array[b];
+};
+var partition = function partition(array, low, high, compareFunction) {
+  var pivot = medianOfThree(array, low, Math.floor((low + high) / 2), high, compareFunction);
+  var left = low - 1;
+  var right = high + 1;
+  while (true) {
+    do {
+      left++;
+    } while (compareFunction(array[left], pivot) < 0);
+    do {
+      right--;
+    } while (compareFunction(array[right], pivot) > 0);
+    if (left >= right) {
+      return right;
+    }
+    var _ref = [array[right], array[left]];
+    array[left] = _ref[0];
+    array[right] = _ref[1];
+  }
+};
+var insertionSort = function insertionSort(array, low, high, compareFunction) {
+  for (var index = low + 1; index <= high; index++) {
+    var key = array[index];
+    var currentIndex = index - 1;
+    while (currentIndex >= low && compareFunction(array[currentIndex], key) > 0) {
+      array[currentIndex + 1] = array[currentIndex];
+      currentIndex--;
+    }
+    array[currentIndex + 1] = key;
+  }
+};
+var _sortImpl = function sortImpl(array, lowInit, highInit, compareFunction, insertionSortThreshold) {
+  var low = lowInit;
+  var high = highInit;
+  while (low < high) {
+    if (high - low < insertionSortThreshold) {
+      insertionSort(array, low, high, compareFunction);
+      return;
+    }
+    var pivotIndex = partition(array, low, high, compareFunction);
+    if (pivotIndex - low < high - pivotIndex) {
+      _sortImpl(array, low, pivotIndex, compareFunction, insertionSortThreshold);
+      low = pivotIndex + 1;
+    } else {
+      _sortImpl(array, pivotIndex + 1, high, compareFunction, insertionSortThreshold);
+      high = pivotIndex;
+    }
+  }
+};
+
+/**
+ * 配列を高速にソート
+ * QuickSortとInsertionSortを組み合わせたアルゴリズムで配列を高速にソートします
+ * @param {T[]} array 配列
+ * @param {CompareFunction<T>} compareFunction 比較関数
+ * @param {number} startIndex 開始インデックス
+ * @param {number} endIndex 終了インデックス
+ * @param {number} insertionSortThreshold 挿入ソートの閾値
+ * @returns T[]
+ * @example quickSort([1, 3, 2, 4, 5], (a, b) => a - b); // [1, 2, 3, 4, 5]
+ */
+var quickSort = exports.quickSort = function quickSort(array) {
+  var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
+  var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
+  var insertionSortThreshold = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
+  // 有効な範囲内でのみソートを行う
+  var validStartIndex = Math.max(0, Math.min(startIndex, array.length - 1));
+  var validEndIndex = Math.max(validStartIndex, Math.min(endIndex, array.length - 1));
+  _sortImpl(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+  return array;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * 配列から指定された数の要素をランダムに選択する
+ * @param array 元の配列
+ * @param count 選択する要素の数
+ * @param allowDuplicates 重複を許すかどうか (デフォルトは false)
+ * @returns ランダムに選択された要素の配列
+ * @example randomSelect([1, 2, 3, 4, 5], 2); // [3, 1]
+ */
+export declare const randomSelect: <T>(array: T[], count: number, allowDuplicates?: boolean) => T[];

package/module/es5/Array/randomSelect.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomSelect = void 0;
+/**
+ * 配列から指定された数の要素をランダムに選択する
+ * @param array 元の配列
+ * @param count 選択する要素の数
+ * @param allowDuplicates 重複を許すかどうか (デフォルトは false)
+ * @returns ランダムに選択された要素の配列
+ * @example randomSelect([1, 2, 3, 4, 5], 2); // [3, 1]
+ */
+var randomSelect = exports.randomSelect = function randomSelect(array, count) {
+  var allowDuplicates = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var result = [];
+  var usedIndices = new Set();
+  while (result.length < count && (allowDuplicates || result.length < array.length)) {
+    var randomIndex = Math.floor(Math.random() * array.length);
+    if (allowDuplicates || !usedIndices.has(randomIndex)) {
+      usedIndices.add(randomIndex);
+      result.push(array[randomIndex]);
+    }
+  }
+  return result;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * 連続した数値の配列を生成する
+ * @param start 開始数値
+ * @param end 終了数値 (省略した場合は0からstartまでの配列を生成)
+ * @param step ステップ数 (省略した場合は1)
+ * @returns 連続した数値の配列
+ * @example range(5); // [0, 1, 2, 3, 4]
+ * @example range(2, 10, 2); // [2, 4, 6, 8]
+ */
+declare const range: (start: number, end?: number, step?: number) => number[];
+export { range };

package/module/es5/Array/range.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.range = void 0;
+/**
+ * 連続した数値の配列を生成する
+ * @param start 開始数値
+ * @param end 終了数値 (省略した場合は0からstartまでの配列を生成)
+ * @param step ステップ数 (省略した場合は1)
+ * @returns 連続した数値の配列
+ * @example range(5); // [0, 1, 2, 3, 4]
+ * @example range(2, 10, 2); // [2, 4, 6, 8]
+ */
+var range = exports.range = function range(start, end) {
+  var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var array = [];
+  if (end) {
+    for (var index = start; index < end; index += step) {
+      array.push(index);
+    }
+  } else {
+    for (var _index = 0; _index < start; _index += step) {
+      array.push(_index);
+    }
+  }
+  return array;
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 配列の要素をランダムにシャッフルする
+ * @param array シャッフルする配列
+ * @returns シャッフルされた配列
+ * @example shuffle([1, 2, 3, 4, 5]); // [3, 5, 2, 4, 1]
+ */
+export declare const shuffle: <T>(array: T[]) => T[];

package/module/es5/Array/shuffle.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shuffle = 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; }
+/**
+ * 配列の要素をランダムにシャッフルする
+ * @param array シャッフルする配列
+ * @returns シャッフルされた配列
+ * @example shuffle([1, 2, 3, 4, 5]); // [3, 5, 2, 4, 1]
+ */
+var shuffle = exports.shuffle = function shuffle(array) {
+  var shuffledArray = _toConsumableArray(array);
+  for (var index = shuffledArray.length - 1; index > 0; index--) {
+    var index_ = Math.floor(Math.random() * (index + 1));
+    if (index !== index_) {
+      var _ref = [shuffledArray[index_], shuffledArray[index]];
+      shuffledArray[index] = _ref[0];
+      shuffledArray[index_] = _ref[1];
+    }
+  }
+  return shuffledArray;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * 2次元配列全体の配列をシャッフルします。
+ * @param array シャッフルする2次元配列
+ * @returns シャッフルされた2次元配列
+ * @example
+ * shuffle2DArray([[1, 2], [3, 4], [5, 6]]);
+ * // 例: [[1, 3], [6, 4], [2, 5]]
+ */
+export declare const shuffle2DArray: <T>(array: T[][]) => T[][];

package/module/es5/Array/shuffle2DArray.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shuffle2DArray = 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 _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 _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * 2次元配列全体の配列をシャッフルします。
+ * @param array シャッフルする2次元配列
+ * @returns シャッフルされた2次元配列
+ * @example
+ * shuffle2DArray([[1, 2], [3, 4], [5, 6]]);
+ * // 例: [[1, 3], [6, 4], [2, 5]]
+ */
+var shuffle2DArray = exports.shuffle2DArray = function shuffle2DArray(array) {
+  // 2次元配列の要素を1次元配列に平坦化し、シャッフルする
+  var flatArray = [];
+  var _iterator = _createForOfIteratorHelper(array),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var subArray = _step.value;
+      flatArray.push.apply(flatArray, _toConsumableArray(subArray));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  for (var index = flatArray.length - 1; index > 0; index--) {
+    var index_ = Math.floor(Math.random() * (index + 1));
+    var _ref = [flatArray[index_], flatArray[index]];
+    flatArray[index] = _ref[0];
+    flatArray[index_] = _ref[1];
+  }
+
+  // シャッフルされた1次元配列を2次元配列に再構成する
+  var rowIndex = 0;
+  return array.map(function (subArray) {
+    var newRow = flatArray.slice(rowIndex, rowIndex + subArray.length);
+    rowIndex += subArray.length;
+    return newRow;
+  });
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 配列の合計を返す
+ * @param {number[]} x 数値型の配列
+ * @returns 配列の合計
+ * @example sum([1, 2, 3]); // 6
+ */
+export declare const sum: (x: number[]) => number;

package/module/es5/Array/sum.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sum = void 0;
+var _addition = require("@/Math/addition");
+/**
+ * 配列の合計を返す
+ * @param {number[]} x 数値型の配列
+ * @returns 配列の合計
+ * @example sum([1, 2, 3]); // 6
+ */
+var sum = exports.sum = function sum(x) {
+  return x.reduce(function (a, b) {
+    return (0, _addition.addition)(a, b);
+  });
+};

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

@@ -0,0 +1,15 @@
+type CompareFunction<T> = (a: T, b: T) => number;
+/**
+ * TimSortアルゴリズムを実装した関数です。
+ * 挿入ソートとマージソートの良い特性を組み合わせたソートアルゴリズムで、
+ * 安定なソートを提供し、最悪のケースでもO(n log n)の時間複雑度を持ちます。
+ *
+ * @param {T[]} array - ソートする配列
+ * @param {CompareFunction<T>} [compareFunction=compareFunctionDefault<T>] -
+ *        要素比較のための関数
+ * @param {number} [start=0] - ソートを開始する配列のインデックス
+ * @param {number} [end=array.length - 1] - ソートを終了する配列のインデックス
+ * @returns {T[]} - ソートされた配列
+ */
+export declare const timSort: <T>(array: T[], compareFunction?: CompareFunction<T>, start?: number, end?: number) => T[];
+export {};

package/module/es5/Array/timSort.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timSort = void 0;
+var _compareFunctionDefault = require("./compareFunctionDefault");
+var MIN_RUN = 32;
+var insertionSort = function insertionSort(array, start, end, compareFunction) {
+  for (var index = start + 1; index <= end; index++) {
+    var temporary = array[index];
+    var currentIndex = index - 1;
+    while (currentIndex >= start && compareFunction(array[currentIndex], temporary) > 0) {
+      array[currentIndex + 1] = array[currentIndex];
+      currentIndex--;
+    }
+    array[currentIndex + 1] = temporary;
+  }
+};
+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++;
+    } else {
+      array[arrayIndex] = right[rightIndex];
+      rightIndex++;
+    }
+    arrayIndex++;
+  }
+  while (leftIndex < left.length) {
+    array[arrayIndex] = left[leftIndex];
+    leftIndex++;
+    arrayIndex++;
+  }
+  while (rightIndex < right.length) {
+    array[arrayIndex] = right[rightIndex];
+    rightIndex++;
+    arrayIndex++;
+  }
+};
+var getMinRunLength = function getMinRunLength(input) {
+  var n = input;
+  var r = 0;
+  while (n >= MIN_RUN) {
+    r |= n & 1;
+    n >>= 1;
+  }
+  return n + r;
+};
+
+/**
+ * TimSortアルゴリズムを実装した関数です。
+ * 挿入ソートとマージソートの良い特性を組み合わせたソートアルゴリズムで、
+ * 安定なソートを提供し、最悪のケースでもO(n log n)の時間複雑度を持ちます。
+ *
+ * @param {T[]} array - ソートする配列
+ * @param {CompareFunction<T>} [compareFunction=compareFunctionDefault<T>] -
+ *        要素比較のための関数
+ * @param {number} [start=0] - ソートを開始する配列のインデックス
+ * @param {number} [end=array.length - 1] - ソートを終了する配列のインデックス
+ * @returns {T[]} - ソートされた配列
+ */
+var timSort = exports.timSort = function timSort(array) {
+  var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
+  var n = end - start + 1;
+  var minRun = getMinRunLength(n);
+  for (var index = start; index <= end; index += minRun) {
+    insertionSort(array, index, Math.min(index + MIN_RUN - 1, end), compareFunction);
+  }
+  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(array, left, mid, right, compareFunction);
+      }
+    }
+  }
+  return array;
+};

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

@@ -0,0 +1,7 @@
+import type { ZipArrayType } from "$/array/zip";
+/**
+ * 複数の配列を受け取り、それらの配列の要素を組み合わせて新しい配列を作成します。
+ * @param {T} arrays - 組み合わせる配列のリスト
+ * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列
+ */
+export declare const zip: <T extends unknown[][]>(...arrays: T) => ZipArrayType<T>;

package/module/es5/Array/zip.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zip = 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; }
+/**
+ * 複数の配列を受け取り、それらの配列の要素を組み合わせて新しい配列を作成します。
+ * @param {T} arrays - 組み合わせる配列のリスト
+ * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列
+ */
+var zip = exports.zip = function zip() {
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+  if (arrays.length === 0) {
+    return [];
+  }
+  var length = Math.min.apply(Math, _toConsumableArray(arrays.map(function (array) {
+    return array.length;
+  })));
+  return Array.from({
+    length: length
+  }, function (_, index) {
+    return arrays.map(function (array) {
+      return array[index];
+    });
+  });
+};

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

@@ -0,0 +1,10 @@
+import type { ZipArrayType } from "$/array/zip";
+/**
+ * 異なる長さの配列を組み合わせて、最も長い配列の長さに合わせた配列を生成します。
+ * 短い配列の不足分は`undefined`で埋められます。
+ *
+ * @param {T} arrays - 組み合わせる配列のリスト。
+ * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列。
+ *                             最も長い配列の長さに合わせて、短い配列の不足分は`undefined`で埋められます。
+ */
+export declare const zipLongest: <T extends unknown[][]>(...arrays: T) => ZipArrayType<T>;

package/module/es5/Array/zipLongest.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zipLongest = 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; }
+/**
+ * 異なる長さの配列を組み合わせて、最も長い配列の長さに合わせた配列を生成します。
+ * 短い配列の不足分は`undefined`で埋められます。
+ *
+ * @param {T} arrays - 組み合わせる配列のリスト。
+ * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列。
+ *                             最も長い配列の長さに合わせて、短い配列の不足分は`undefined`で埋められます。
+ */
+var zipLongest = exports.zipLongest = function zipLongest() {
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+  var maxLength = Math.max.apply(Math, _toConsumableArray(arrays.map(function (array) {
+    return array.length;
+  })));
+  return Array.from({
+    length: maxLength
+  }, function (_, index) {
+    return arrays.map(function (array) {
+      return array[index];
+    });
+  });
+};

package/module/es5/Color/cmykToRgba.d.ts

@@ -0,0 +1,16 @@
+/**
+ * cmykをrgbaに変換する
+ * @param {number} c
+ * @param {number} m
+ * @param {number} y
+ * @param {number} k
+ * @param {number} a
+ * @returns { r: number; g: number; b: number; a: number; }
+ * @example cmykToRgba(100, 100, 0, 60.78) // { r: 0, g: 0, b: 100, a: 1 }
+ */
+export declare const cmykToRgba: (c: number, m: number, y: number, k: number, a?: number) => {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};

package/module/es5/Color/cmykToRgba.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cmykToRgba = void 0;
+var _division = require("@/Math/division");
+var _max = require("@/Math/max");
+var _min = require("@/Math/min");
+var _multiplication = require("@/Math/multiplication");
+var _roundOf = require("@/Math/roundOf");
+var _subtract = require("@/Math/subtract");
+/**
+ * cmykをrgbaに変換する
+ * @param {number} c
+ * @param {number} m
+ * @param {number} y
+ * @param {number} k
+ * @param {number} a
+ * @returns { r: number; g: number; b: number; a: number; }
+ * @example cmykToRgba(100, 100, 0, 60.78) // { r: 0, g: 0, b: 100, a: 1 }
+ */
+var cmykToRgba = exports.cmykToRgba = function cmykToRgba(c, m, y, k) {
+  var a = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+  // CMYKの値を0から100の範囲に制限
+  var clampedC = (0, _max.max)(0, (0, _min.min)(100, c));
+  var clampedM = (0, _max.max)(0, (0, _min.min)(100, m));
+  var clampedY = (0, _max.max)(0, (0, _min.min)(100, y));
+  var clampedK = (0, _max.max)(0, (0, _min.min)(100, k));
+
+  // CMYKの値を0から1の範囲に変換
+  var cPercentage = (0, _division.division)(clampedC, 100);
+  var mPercentage = (0, _division.division)(clampedM, 100);
+  var yPercentage = (0, _division.division)(clampedY, 100);
+  var kPercentage = (0, _division.division)(clampedK, 100);
+
+  // RGBの値を計算
+  var r = (0, _multiplication.multiplication)(255, (0, _subtract.subtract)(1, cPercentage), (0, _subtract.subtract)(1, kPercentage));
+  var g = (0, _multiplication.multiplication)(255, (0, _subtract.subtract)(1, mPercentage), (0, _subtract.subtract)(1, kPercentage));
+  var b = (0, _multiplication.multiplication)(255, (0, _subtract.subtract)(1, yPercentage), (0, _subtract.subtract)(1, kPercentage));
+
+  // RGBの値を0から255の範囲に丸める
+  var roundedR = (0, _roundOf.roundOf)(r);
+  var roundedG = (0, _roundOf.roundOf)(g);
+  var roundedB = (0, _roundOf.roundOf)(b);
+
+  // アルファ値を0から1の範囲に制限
+  var clampedA = (0, _max.max)(0, (0, _min.min)(1, a));
+  return {
+    r: roundedR,
+    g: roundedG,
+    b: roundedB,
+    a: clampedA
+  };
+};

package/module/es5/Color/hexaToRgba.d.ts

@@ -0,0 +1,12 @@
+/**
+ * hexaをrgbaに変換する
+ * @param hex
+ * @returns { r: number; g: number; b: number; a: number; }
+ * @example hexToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
+ */
+export declare const hexaToRgba: (hex: string) => {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};

package/module/es5/Color/hexaToRgba.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hexaToRgba = void 0;
+var _division = require("@/Math/division");
+/**
+ * hexaをrgbaに変換する
+ * @param hex
+ * @returns { r: number; g: number; b: number; a: number; }
+ * @example hexToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
+ */
+var hexaToRgba = exports.hexaToRgba = function hexaToRgba(hex) {
+  // hex形式かどうかのチェック
+  if (/^#([\da-f]{3}|[\da-f]{6}|[\da-f]{8})$/i.test(hex) === false) {
+    throw new Error("Invalid hex code");
+  }
+  var hexCode = hex.replace("#", "");
+  var r = Number.parseInt(hexCode.slice(0, 2), 16);
+  var g = Number.parseInt(hexCode.slice(2, 4), 16);
+  var b = Number.parseInt(hexCode.slice(4, 6), 16);
+  var a = (0, _division.division)(Number.parseInt(hexCode.slice(6, 8), 16), 255);
+  return {
+    r: r,
+    g: g,
+    b: b,
+    a: Number.isNaN(a) ? 1 : a
+  };
+};

package/module/es5/Color/hslaToRgba.d.ts

@@ -0,0 +1,15 @@
+/**
+ * hslaをrgbaに変換する
+ * @param h 色相 (0から360の範囲)
+ * @param s 彩度 (0から100の範囲)
+ * @param l 明度 (0から100の範囲)
+ * @param a アルファ値 (0から1の範囲)
+ * @returns { r: number; g: number; b: number; a: number; }
+ * @example hslaToRgba(120, 50, 50, 1) // { r: 64, g: 191, b: 64, a: 1 }
+ */
+export declare const hslaToRgba: (h: number, s: number, l: number, a?: number) => {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};