umt 2.1.1 → 2.2.0

package/module/es5/Array/quickSort.js

@@ -5,6 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.quickSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+/**
+ * Finds the median value among three elements in the array
+ * @param array The array containing the elements
+ * @param a Index of first element
+ * @param b Index of second element
+ * @param c Index of third element
+ * @param compareFunction Function to compare elements
+ * @returns The median value among the three elements
+ */
 var medianOfThree = function medianOfThree(array, a, b, c, compareFunction) {
   var ab = compareFunction(array[a], array[b]);
   if (ab < 0) {
@@ -26,6 +35,15 @@ var medianOfThree = function medianOfThree(array, a, b, c, compareFunction) {
   }
   return array[b];
 };
+
+/**
+ * Partitions the array around a pivot element using median-of-three strategy
+ * @param array Array to partition
+ * @param low Starting index of the partition range
+ * @param high Ending index of the partition range
+ * @param compareFunction Function to compare elements
+ * @returns Index of the partition point
+ */
 var partition = function partition(array, low, high, compareFunction) {
   var pivot = medianOfThree(array, low, Math.floor((low + high) / 2), high, compareFunction);
   var left = low - 1;
@@ -45,6 +63,14 @@ var partition = function partition(array, low, high, compareFunction) {
     array[right] = _ref[1];
   }
 };
+
+/**
+ * Sorts a portion of the array using insertion sort algorithm
+ * @param array Array to sort
+ * @param low Starting index of the range to sort
+ * @param high Ending index of the range to sort
+ * @param compareFunction Function to compare elements
+ */
 var insertionSort = function insertionSort(array, low, high, compareFunction) {
   for (var index = low + 1; index <= high; index++) {
     var key = array[index];
@@ -56,6 +82,15 @@ var insertionSort = function insertionSort(array, low, high, compareFunction) {
     array[currentIndex + 1] = key;
   }
 };
+
+/**
+ * Internal implementation of the quicksort algorithm with tail-call optimization
+ * @param array Array to sort
+ * @param lowInit Initial low index of the range to sort
+ * @param highInit Initial high index of the range to sort
+ * @param compareFunction Function to compare elements
+ * @param insertionSortThreshold Size threshold for switching to insertion sort
+ */
 var _sortImpl = function sortImpl(array, lowInit, highInit, compareFunction, insertionSortThreshold) {
   var low = lowInit;
   var high = highInit;
@@ -76,22 +111,24 @@ var _sortImpl = function sortImpl(array, lowInit, highInit, compareFunction, ins
 };
 
 /**
- * 配列を高速にソート
- * 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]
+ * Sorts an array using a hybrid algorithm combining QuickSort and InsertionSort
+ * @param {T[]} array Array to sort
+ * @param {CompareFunction<T>} compareFunction Comparison function that returns negative if a < b, zero if a = b, positive if a > b
+ * @param {number} startIndex Starting index for the sort range (default: 0)
+ * @param {number} endIndex Ending index for the sort range (default: array.length - 1)
+ * @param {number} insertionSortThreshold Threshold for switching to insertion sort (default: 10)
+ * @returns {T[]} Sorted array
+ * @example
+ * quickSort([1, 3, 2, 4, 5]); // [1, 2, 3, 4, 5]
+ * quickSort([1, 3, 2], (a, b) => b - a); // [3, 2, 1]
+ * quickSort(['b', 'a', 'c']); // ['a', 'b', 'c']
  */
 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;
-  // 有効な範囲内でのみソートを行う
+  // Only sort within valid range
   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);

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

@@ -1,9 +1,9 @@
 /**
- * 配列から指定された数の要素をランダムに選択する
- * @param array 元の配列
- * @param count 選択する要素の数
- * @param allowDuplicates 重複を許すかどうか (デフォルトは false)
- * @returns ランダムに選択された要素の配列
+ * Randomly selects a specified number of elements from an array
+ * @param array Source array
+ * @param count Number of elements to select
+ * @param allowDuplicates Whether to allow duplicate selections (default: false)
+ * @returns Array of randomly selected elements
  * @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

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.randomSelect = void 0;
 /**
- * 配列から指定された数の要素をランダムに選択する
- * @param array 元の配列
- * @param count 選択する要素の数
- * @param allowDuplicates 重複を許すかどうか (デフォルトは false)
- * @returns ランダムに選択された要素の配列
+ * Randomly selects a specified number of elements from an array
+ * @param array Source array
+ * @param count Number of elements to select
+ * @param allowDuplicates Whether to allow duplicate selections (default: false)
+ * @returns Array of randomly selected elements
  * @example randomSelect([1, 2, 3, 4, 5], 2); // [3, 1]
  */
 var randomSelect = exports.randomSelect = function randomSelect(array, count) {

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

@@ -1,9 +1,9 @@
 /**
- * 連続した数値の配列を生成する
- * @param start 開始数値
- * @param end 終了数値 (省略した場合は0からstartまでの配列を生成)
- * @param step ステップ数 (省略した場合は1)
- * @returns 連続した数値の配列
+ * Generates an array of sequential numbers
+ * @param start Starting number
+ * @param end Ending number (if omitted, generates array from 0 to start)
+ * @param step Step value (defaults to 1)
+ * @returns Array of sequential numbers
  * @example range(5); // [0, 1, 2, 3, 4]
  * @example range(2, 10, 2); // [2, 4, 6, 8]
  */

package/module/es5/Array/range.js

@@ -5,24 +5,42 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.range = void 0;
 /**
- * 連続した数値の配列を生成する
- * @param start 開始数値
- * @param end 終了数値 (省略した場合は0からstartまでの配列を生成)
- * @param step ステップ数 (省略した場合は1)
- * @returns 連続した数値の配列
+ * Generates an array of sequential numbers
+ * @param start Starting number
+ * @param end Ending number (if omitted, generates array from 0 to start)
+ * @param step Step value (defaults to 1)
+ * @returns Array of sequential numbers
  * @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);
+
+  // Handle invalid step
+  if (step === 0) {
+    return array;
+  }
+  var actualStart = end === undefined ? 0 : start;
+  var actualEnd = end === undefined ? start : end;
+
+  // Return empty array if invalid range
+  if (step > 0 && actualStart >= actualEnd || step < 0 && actualStart <= actualEnd) {
+    return array;
+  }
+
+  // Handle both positive and negative steps
+  if (step > 0) {
+    for (var index = actualStart; index < actualEnd; index += step) {
+      // Handle floating point precision
+      var roundedValue = Number((Math.round(index * 1e10) / 1e10).toFixed(10));
+      array.push(roundedValue);
     }
   } else {
-    for (var _index = 0; _index < start; _index += step) {
-      array.push(_index);
+    for (var _index = actualStart; _index > actualEnd; _index += step) {
+      // Handle floating point precision
+      var _roundedValue = Number((Math.round(_index * 1e10) / 1e10).toFixed(10));
+      array.push(_roundedValue);
     }
   }
   return array;

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

@@ -1,7 +1,7 @@
 /**
- * 配列の要素をランダムにシャッフルする
- * @param array シャッフルする配列
- * @returns シャッフルされた配列
+ * Randomly shuffles the elements of an array
+ * @param array Array to shuffle
+ * @returns New array with shuffled elements
  * @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

@@ -11,9 +11,9 @@ function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Sym
 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 シャッフルされた配列
+ * Randomly shuffles the elements of an array
+ * @param array Array to shuffle
+ * @returns New array with shuffled elements
  * @example shuffle([1, 2, 3, 4, 5]); // [3, 5, 2, 4, 1]
  */
 var shuffle = exports.shuffle = function shuffle(array) {

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

@@ -1,9 +1,9 @@
 /**
- * 2次元配列全体の配列をシャッフルします。
- * @param array シャッフルする2次元配列
- * @returns シャッフルされた2次元配列
+ * Shuffles all elements in a 2D array while maintaining the row lengths
+ * @param array The 2D array to shuffle
+ * @returns A new 2D array with shuffled elements
  * @example
  * shuffle2DArray([[1, 2], [3, 4], [5, 6]]);
- * // 例: [[1, 3], [6, 4], [2, 5]]
+ * // Result: [[1, 3], [6, 4], [2, 5]]
  */
 export declare const shuffle2DArray: <T>(array: T[][]) => T[][];

package/module/es5/Array/shuffle2DArray.js

@@ -12,15 +12,15 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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次元配列
+ * Shuffles all elements in a 2D array while maintaining the row lengths
+ * @param array The 2D array to shuffle
+ * @returns A new 2D array with shuffled elements
  * @example
  * shuffle2DArray([[1, 2], [3, 4], [5, 6]]);
- * // 例: [[1, 3], [6, 4], [2, 5]]
+ * // Result: [[1, 3], [6, 4], [2, 5]]
  */
 var shuffle2DArray = exports.shuffle2DArray = function shuffle2DArray(array) {
-  // 2次元配列の要素を1次元配列に平坦化し、シャッフルする
+  // Flatten the 2D array into 1D and shuffle it
   var flatArray = [];
   var _iterator = _createForOfIteratorHelper(array),
     _step;
@@ -41,7 +41,7 @@ var shuffle2DArray = exports.shuffle2DArray = function shuffle2DArray(array) {
     flatArray[index_] = _ref[1];
   }
 
-  // シャッフルされた1次元配列を2次元配列に再構成する
+  // Reconstruct the 2D array from the shuffled flat array
   var rowIndex = 0;
   return array.map(function (subArray) {
     var newRow = flatArray.slice(rowIndex, rowIndex + subArray.length);

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

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

package/module/es5/Array/sum.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.sum = void 0;
 var _addition = require("@/Math/addition");
 /**
- * 配列の合計を返す
- * @param {number[]} x 数値型の配列
- * @returns 配列の合計
+ * Returns the sum of an array of numbers
+ * @param {number[]} x Array of numbers
+ * @returns Sum of the array elements
  * @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);
-  });
+  }, 0);
 };

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

@@ -1,15 +1,17 @@
-type CompareFunction<T> = (a: T, b: T) => number;
+import type { CompareFunction } from "$/array/compareFunction";
 /**
- * TimSortアルゴリズムを実装した関数です。
- * 挿入ソートとマージソートの良い特性を組み合わせたソートアルゴリズムで、
- * 安定なソートを提供し、最悪のケースでもO(n log n)の時間複雑度を持ちます。
+ * Implementation of the TimSort algorithm, which combines the best features of
+ * insertion sort and merge sort. It provides a stable sort with O(n log n)
+ * worst-case time complexity.
  *
- * @param {T[]} array - ソートする配列
- * @param {CompareFunction<T>} [compareFunction=compareFunctionDefault<T>] -
- *        要素比較のための関数
- * @param {number} [start=0] - ソートを開始する配列のインデックス
- * @param {number} [end=array.length - 1] - ソートを終了する配列のインデックス
- * @returns {T[]} - ソートされた配列
+ * @param {T[]} array Array to sort
+ * @param {CompareFunction<T>} [compareFunction=compareFunctionDefault<T>]
+ *        Function to compare elements
+ * @param {number} [start=0] Starting index for the sort range
+ * @param {number} [end=array.length - 1] Ending index for the sort range
+ * @returns {T[]} Sorted array
+ * @example
+ * timSort([3, 1, 4, 1, 5]); // [1, 1, 3, 4, 5]
+ * timSort(['b', 'a', 'c']); // ['a', 'b', 'c']
  */
 export declare const timSort: <T>(array: T[], compareFunction?: CompareFunction<T>, start?: number, end?: number) => T[];
-export {};

package/module/es5/Array/timSort.js

@@ -6,6 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.timSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
 var MIN_RUN = 32;
+
+/**
+ * Sorts a portion of the array using insertion sort algorithm
+ * @param array Array to sort
+ * @param start Starting index of the range to sort
+ * @param end Ending index of the range to sort
+ * @param compareFunction Function to compare elements
+ */
 var insertionSort = function insertionSort(array, start, end, compareFunction) {
   for (var index = start + 1; index <= end; index++) {
     var temporary = array[index];
@@ -17,6 +25,15 @@ var insertionSort = function insertionSort(array, start, end, compareFunction) {
     array[currentIndex + 1] = temporary;
   }
 };
+
+/**
+ * Merges two sorted portions of the array
+ * @param array Array containing the portions to merge
+ * @param start Starting index of the first portion
+ * @param mid Middle index separating the two portions
+ * @param end Ending index of the second portion
+ * @param compareFunction Function to compare elements
+ */
 var merge = function merge(array, start, mid, end, compareFunction) {
   var left = array.slice(start, mid + 1);
   var right = array.slice(mid + 1, end + 1);
@@ -44,6 +61,13 @@ var merge = function merge(array, start, mid, end, compareFunction) {
     arrayIndex++;
   }
 };
+
+/**
+ * Calculates the minimum length of a run for the given input size
+ * This is used to determine the size of runs for the initial insertion sort phase
+ * @param input Size of the array to be sorted
+ * @returns Minimum length of a run
+ */
 var getMinRunLength = function getMinRunLength(input) {
   var n = input;
   var r = 0;
@@ -55,16 +79,19 @@ var getMinRunLength = function getMinRunLength(input) {
 };
 
 /**
- * TimSortアルゴリズムを実装した関数です。
- * 挿入ソートとマージソートの良い特性を組み合わせたソートアルゴリズムで、
- * 安定なソートを提供し、最悪のケースでもO(n log n)の時間複雑度を持ちます。
+ * Implementation of the TimSort algorithm, which combines the best features of
+ * insertion sort and merge sort. It provides a stable sort with O(n log n)
+ * worst-case time complexity.
  *
- * @param {T[]} array - ソートする配列
- * @param {CompareFunction<T>} [compareFunction=compareFunctionDefault<T>] -
- *        要素比較のための関数
- * @param {number} [start=0] - ソートを開始する配列のインデックス
- * @param {number} [end=array.length - 1] - ソートを終了する配列のインデックス
- * @returns {T[]} - ソートされた配列
+ * @param {T[]} array Array to sort
+ * @param {CompareFunction<T>} [compareFunction=compareFunctionDefault<T>]
+ *        Function to compare elements
+ * @param {number} [start=0] Starting index for the sort range
+ * @param {number} [end=array.length - 1] Ending index for the sort range
+ * @returns {T[]} Sorted array
+ * @example
+ * timSort([3, 1, 4, 1, 5]); // [1, 1, 3, 4, 5]
+ * timSort(['b', 'a', 'c']); // ['a', 'b', 'c']
  */
 var timSort = exports.timSort = function timSort(array) {
   var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;

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

@@ -1,7 +1,10 @@
 import type { ZipArrayType } from "$/array/zip";
 /**
- * 複数の配列を受け取り、それらの配列の要素を組み合わせて新しい配列を作成します。
- * @param {T} arrays - 組み合わせる配列のリスト
- * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列
+ * Creates a new array by combining elements from multiple arrays at corresponding positions
+ * @param {T} arrays List of arrays to combine
+ * @returns {ZipArrayType<T>} New array with combined elements from each input array
+ * @example
+ * zip([1, 2], ['a', 'b']); // [[1, 'a'], [2, 'b']]
+ * zip([1, 2, 3], ['a', 'b']); // [[1, 'a'], [2, 'b']]
  */
 export declare const zip: <T extends unknown[][]>(...arrays: T) => ZipArrayType<T>;

package/module/es5/Array/zip.js

@@ -11,9 +11,12 @@ function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Sym
 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>} - 各配列の要素が組み合わされた新しい配列
+ * Creates a new array by combining elements from multiple arrays at corresponding positions
+ * @param {T} arrays List of arrays to combine
+ * @returns {ZipArrayType<T>} New array with combined elements from each input array
+ * @example
+ * zip([1, 2], ['a', 'b']); // [[1, 'a'], [2, 'b']]
+ * zip([1, 2, 3], ['a', 'b']); // [[1, 'a'], [2, 'b']]
  */
 var zip = exports.zip = function zip() {
   for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {

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

@@ -1,10 +1,13 @@
 import type { ZipArrayType } from "$/array/zip";
 /**
- * 異なる長さの配列を組み合わせて、最も長い配列の長さに合わせた配列を生成します。
- * 短い配列の不足分は`undefined`で埋められます。
+ * Combines arrays of different lengths by padding shorter arrays with undefined values
+ * to match the length of the longest array
  *
- * @param {T} arrays - 組み合わせる配列のリスト。
- * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列。
- *                             最も長い配列の長さに合わせて、短い配列の不足分は`undefined`で埋められます。
+ * @param {T} arrays List of arrays to combine
+ * @returns {ZipArrayType<T>} New array with combined elements from each input array,
+ *                            padded with undefined values where necessary
+ * @example
+ * zipLongest([1, 2], ['a']); // [[1, 'a'], [2, undefined]]
+ * zipLongest([1], ['a', 'b']); // [[1, 'a'], [undefined, 'b']]
  */
 export declare const zipLongest: <T extends unknown[][]>(...arrays: T) => ZipArrayType<T>;

package/module/es5/Array/zipLongest.js

@@ -11,12 +11,15 @@ function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Sym
 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`で埋められます。
+ * Combines arrays of different lengths by padding shorter arrays with undefined values
+ * to match the length of the longest array
  *
- * @param {T} arrays - 組み合わせる配列のリスト。
- * @returns {ZipArrayType<T>} - 各配列の要素が組み合わされた新しい配列。
- *                             最も長い配列の長さに合わせて、短い配列の不足分は`undefined`で埋められます。
+ * @param {T} arrays List of arrays to combine
+ * @returns {ZipArrayType<T>} New array with combined elements from each input array,
+ *                            padded with undefined values where necessary
+ * @example
+ * zipLongest([1, 2], ['a']); // [[1, 'a'], [2, undefined]]
+ * zipLongest([1], ['a', 'b']); // [[1, 'a'], [undefined, 'b']]
  */
 var zipLongest = exports.zipLongest = function zipLongest() {
   for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {

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

@@ -1,11 +1,11 @@
 /**
- * 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; }
+ * Convert CMYK color values to RGBA color space
+ * @param {number} c Cyan percentage (0-100)
+ * @param {number} m Magenta percentage (0-100)
+ * @param {number} y Yellow percentage (0-100)
+ * @param {number} k Key/Black percentage (0-100)
+ * @param {number} a Alpha value (0-1)
+ * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
  * @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) => {

package/module/es5/Color/cmykToRgba.js

@@ -11,40 +11,40 @@ 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; }
+ * Convert CMYK color values to RGBA color space
+ * @param {number} c Cyan percentage (0-100)
+ * @param {number} m Magenta percentage (0-100)
+ * @param {number} y Yellow percentage (0-100)
+ * @param {number} k Key/Black percentage (0-100)
+ * @param {number} a Alpha value (0-1)
+ * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
  * @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の範囲に制限
+  // Clamp CMYK values to 0-100 range
   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の範囲に変換
+  // Convert CMYK values to 0-1 range
   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の値を計算
+  // Calculate RGB values
   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の範囲に丸める
+  // Round RGB values to 0-255 range
   var roundedR = (0, _roundOf.roundOf)(r);
   var roundedG = (0, _roundOf.roundOf)(g);
   var roundedB = (0, _roundOf.roundOf)(b);
 
-  // アルファ値を0から1の範囲に制限
+  // Clamp alpha value to 0-1 range
   var clampedA = (0, _max.max)(0, (0, _min.min)(1, a));
   return {
     r: roundedR,

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

@@ -1,8 +1,9 @@
 /**
- * hexaをrgbaに変換する
- * @param hex
- * @returns { r: number; g: number; b: number; a: number; }
+ * Convert hexadecimal color code to RGBA color values
+ * @param hex Hexadecimal color code (3, 6, or 8 digits with #)
+ * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
  * @example hexToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
+ * @throws {Error} If the hex code format is invalid
  */
 export declare const hexaToRgba: (hex: string) => {
     r: number;

package/module/es5/Color/hexaToRgba.js

@@ -5,26 +5,38 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.hexaToRgba = void 0;
 var _division = require("@/Math/division");
+var _roundOf = require("@/Math/roundOf");
 /**
- * hexaをrgbaに変換する
- * @param hex
- * @returns { r: number; g: number; b: number; a: number; }
+ * Convert hexadecimal color code to RGBA color values
+ * @param hex Hexadecimal color code (3, 6, or 8 digits with #)
+ * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
  * @example hexToRgba("#00000000") // { r: 0, g: 0, b: 0, a: 0 }
+ * @throws {Error} If the hex code format is invalid
  */
 var hexaToRgba = exports.hexaToRgba = function hexaToRgba(hex) {
-  // hex形式かどうかのチェック
+  // Validate hex code format
   if (/^#([\da-f]{3}|[\da-f]{6}|[\da-f]{8})$/i.test(hex) === false) {
     throw new Error("Invalid hex code");
   }
   var hexCode = hex.replace("#", "");
+
+  // Convert 3-digit hex to 6-digit format
+  if (hexCode.length === 3) {
+    hexCode = hexCode.split("").map(function (_char) {
+      return _char + _char;
+    }).join("");
+  }
   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);
+  var alphaValue = hexCode.length === 8 ? Number.parseInt(hexCode.slice(6, 8), 16) : 255;
+  var a = (0, _roundOf.roundOf)((0, _division.division)(alphaValue, 255), 2);
+
+  // NaN check is not necessary since validation ensures valid hex values
   return {
     r: r,
     g: g,
     b: b,
-    a: Number.isNaN(a) ? 1 : a
+    a: a
   };
 };

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

@@ -1,11 +1,12 @@
 /**
- * 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; }
+ * Convert HSLA color values to RGBA color space
+ * @param h Hue angle in degrees (0-360)
+ * @param s Saturation percentage (0-100)
+ * @param l Lightness percentage (0-100)
+ * @param a Alpha value (0-1)
+ * @returns {Object} RGBA values (r, g, b as 0-255, a as 0-1)
  * @example hslaToRgba(120, 50, 50, 1) // { r: 64, g: 191, b: 64, a: 1 }
+ * @throws {Error} If any input values are out of their valid ranges
  */
 export declare const hslaToRgba: (h: number, s: number, l: number, a?: number) => {
     r: number;