umt 2.1.1 → 2.2.0

package/module/es5/Validate/string/email.d.ts

@@ -1,2 +1,11 @@
+/**
+ * String validation module for email addresses
+ * Provides validation functionality for checking if a string is a valid email address
+ */
 import type { ValidateReturnType } from "@/Validate/type";
+/**
+ * Creates a validator for checking if a string is a valid email address
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for email addresses
+ */
 export declare const email: (message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/email.js

@@ -4,8 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.email = void 0;
+/**
+ * String validation module for email addresses
+ * Provides validation functionality for checking if a string is a valid email address
+ */
+
+/**
+ * Creates a validator for checking if a string is a valid email address
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for email addresses
+ */
 var email = exports.email = function email(message) {
-  // メールアドレスの正規表現
+  // Regular expression for email address validation
   var emailRegex = /^[\+\x2D0-9A-Z_a-z\u017F\u212A]+(?:\.[\+\x2D0-9A-Z_a-z\u017F\u212A]+)*@[0-9a-z\u017F\u212A]+(?:[\x2D\.][0-9a-z\u017F\u212A]+)*\.[a-z\u017F\u212A]{2,}$/i;
   return {
     type: "string",

package/module/es5/Validate/string/length.d.ts

@@ -1,2 +1,13 @@
+/**
+ * String validation module for exact length check
+ * Provides validation functionality for checking if a string has an exact length
+ */
 import type { ValidateReturnType } from "@/Validate/type";
+/**
+ * Creates a validator for checking if a string has an exact length
+ * Note: The function name has an underscore suffix to avoid conflict with the `length` property
+ * @param {number} length - The exact length that the string should have
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for string length
+ */
 export declare const length_: (length: number, message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/length.js

@@ -4,6 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.length_ = void 0;
+/**
+ * String validation module for exact length check
+ * Provides validation functionality for checking if a string has an exact length
+ */
+
+/**
+ * Creates a validator for checking if a string has an exact length
+ * Note: The function name has an underscore suffix to avoid conflict with the `length` property
+ * @param {number} length - The exact length that the string should have
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for string length
+ */
 var length_ = exports.length_ = function length_(length, message) {
   return {
     type: "string",

package/module/es5/Validate/string/maxLength.d.ts

@@ -1,2 +1,12 @@
+/**
+ * String validation module for maximum length check
+ * Provides validation functionality for checking if a string's length is less than or equal to a maximum value
+ */
 import type { ValidateReturnType } from "@/Validate/type";
+/**
+ * Creates a validator for checking if a string's length is less than or equal to a maximum value
+ * @param {number} maxLength - Maximum allowed length of the string
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for maximum string length
+ */
 export declare const maxLength: (maxLength: number, message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/maxLength.js

@@ -4,6 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.maxLength = void 0;
+/**
+ * String validation module for maximum length check
+ * Provides validation functionality for checking if a string's length is less than or equal to a maximum value
+ */
+
+/**
+ * Creates a validator for checking if a string's length is less than or equal to a maximum value
+ * @param {number} maxLength - Maximum allowed length of the string
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for maximum string length
+ */
 var maxLength = exports.maxLength = function maxLength(_maxLength, message) {
   return {
     type: "string",

package/module/es5/Validate/string/minLength.d.ts

@@ -1,2 +1,12 @@
+/**
+ * String validation module for minimum length check
+ * Provides validation functionality for checking if a string's length is greater than or equal to a minimum value
+ */
 import type { ValidateReturnType } from "@/Validate/type";
+/**
+ * Creates a validator for checking if a string's length is greater than or equal to a minimum value
+ * @param {number} minLength - Minimum allowed length of the string
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for minimum string length
+ */
 export declare const minLength: (minLength: number, message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/minLength.js

@@ -4,6 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.minLength = void 0;
+/**
+ * String validation module for minimum length check
+ * Provides validation functionality for checking if a string's length is greater than or equal to a minimum value
+ */
+
+/**
+ * Creates a validator for checking if a string's length is greater than or equal to a minimum value
+ * @param {number} minLength - Minimum allowed length of the string
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for minimum string length
+ */
 var minLength = exports.minLength = function minLength(_minLength, message) {
   return {
     type: "string",

package/module/es5/Validate/string/numberString.d.ts

@@ -1,2 +1,11 @@
+/**
+ * String validation module for checking if a string represents a number
+ * Provides validation functionality for checking if a string can be converted to a number
+ */
 import type { ValidateReturnType } from "@/Validate/type";
+/**
+ * Creates a validator for checking if a string represents a valid number
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for number strings
+ */
 export declare const numberString: (message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/numberString.js

@@ -5,6 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.numberString = void 0;
 var _isNumber = require("@/Validate/isNumber");
+/**
+ * String validation module for checking if a string represents a number
+ * Provides validation functionality for checking if a string can be converted to a number
+ */
+
+/**
+ * Creates a validator for checking if a string represents a valid number
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for number strings
+ */
 var numberString = exports.numberString = function numberString(message) {
   return {
     type: "string",

package/module/es5/Validate/string/regexMatch.d.ts

@@ -1,2 +1,12 @@
+/**
+ * String validation module for regular expression matching
+ * Provides validation functionality for checking if a string matches a regular expression pattern
+ */
 import type { ValidateReturnType } from "@/Validate/type";
+/**
+ * Creates a validator for checking if a string matches a regular expression pattern
+ * @param {RegExp} pattern - Regular expression pattern to match against
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for regular expression matching
+ */
 export declare const regexMatch: (pattern: RegExp, message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/regexMatch.js

@@ -4,6 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.regexMatch = void 0;
+/**
+ * String validation module for regular expression matching
+ * Provides validation functionality for checking if a string matches a regular expression pattern
+ */
+
+/**
+ * Creates a validator for checking if a string matches a regular expression pattern
+ * @param {RegExp} pattern - Regular expression pattern to match against
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for regular expression matching
+ */
 var regexMatch = exports.regexMatch = function regexMatch(pattern, message) {
   return {
     type: "string",

package/module/es5/Validate/string/uuid.d.ts

@@ -1,7 +1,12 @@
 import type { ValidateReturnType } from "@/Validate/type";
 /**
- * 文字列がUUIDかどうかを検証するValidate関数
- * @param  {number[]} versions バージョン (default: [4])
- * @param  {string} message エラーメッセージ
+ * String validation module for UUID strings
+ * Provides validation functionality for checking if a string is a valid UUID
+ */
+/**
+ * Creates a validator for checking if a string is a valid UUID
+ * @param {number[]} [versions=[4]] - Array of supported UUID versions
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for UUID strings
  */
 export declare const uuid: (versions?: number[], message?: string) => ValidateReturnType<string>;

package/module/es5/Validate/string/uuid.js

@@ -5,9 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.uuid = void 0;
 /**
- * 文字列がUUIDかどうかを検証するValidate関数
- * @param  {number[]} versions バージョン (default: [4])
- * @param  {string} message エラーメッセージ
+ * String validation module for UUID strings
+ * Provides validation functionality for checking if a string is a valid UUID
+ */
+
+/**
+ * Creates a validator for checking if a string is a valid UUID
+ * @param {number[]} [versions=[4]] - Array of supported UUID versions
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {ValidateReturnType<string>} - Validator for UUID strings
  */
 var uuid = exports.uuid = function uuid() {
   var versions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [4];
@@ -17,7 +23,7 @@ var uuid = exports.uuid = function uuid() {
     message: message,
     validate: function validate(value) {
       return versions.some(function (version) {
-        // バージョンごとの正規表現
+        // Regular expression for specific UUID version
         var versionRegex = new RegExp("^[\\da-f]{8}-?[\\da-f]{4}-?".concat(version, "[\\da-f]{3}-?[89ab][\\da-f]{3}-?[\\da-f]{12}$"), "i");
         return versionRegex.test(value);
       });

package/module/es5/Validate/type.d.ts

@@ -1,13 +1,35 @@
+/**
+ * Maps TypeScript types to their string literal representations
+ * @template T - The type to map
+ * @returns "string" for string, "number" for number, "boolean" for boolean, or the original type T otherwise
+ */
 export type Types<T> = T extends string ? "string" : T extends number ? "number" : T extends boolean ? "boolean" : T;
+/**
+ * Core validation result type including validation status, message, and type information
+ * @template T - The type being validated
+ */
 export interface ValidateCoreReturnType<T> {
     validate: boolean;
     message: string;
     type: Types<T>;
 }
+/**
+ * Extended validation result type including type information and validation function
+ * @template T - The type being validated
+ */
 export interface ValidateReturnType<T> {
     type: Types<T>;
     validate: ValidateFunctionType<T>;
     message?: string;
 }
+/**
+ * Type for validation functions that take a value and return a boolean
+ * @template T - The type of value to validate
+ */
 export type ValidateFunctionType<T> = (value: T) => boolean;
+/**
+ * Maps string literal type names back to their TypeScript types
+ * @template T - The string literal type name ("string", "number", "boolean")
+ * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
+ */
 export type ValidateType<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T;

package/module/es5/index.d.ts

@@ -13,4 +13,5 @@ export * from "./Time";
 export * from "./Tool";
 export * from "./types";
 export * from "./UA";
+export * from "./Unit";
 export * from "./Validate";

package/module/es5/index.js

@@ -168,6 +168,17 @@ Object.keys(_UA).forEach(function (key) {
     }
   });
 });
+var _Unit = require("./Unit");
+Object.keys(_Unit).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Unit[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Unit[key];
+    }
+  });
+});
 var _Validate = require("./Validate");
 Object.keys(_Validate).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/tests/integration/Array/drop-and-first.test.js

@@ -2,6 +2,15 @@
 
 var _first = require("@/Array/first");
 var _drop = require("@/Array/drop");
+/**
+ * Integration tests for Array utility functions
+ *
+ * Tests the interaction between `drop` and `first` functions to ensure they work correctly
+ * when used together in various scenarios:
+ * - Dropping elements from the start (left) and getting the first element
+ * - Dropping elements from the end (right) and getting the first element
+ * - Edge cases with different array sizes and drop amounts
+ */
 describe("Integration test for 'drop' and 'first' functions", function () {
   it("should drop n elements from the array and return the first element", function () {
     expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5]))).toBe(2);
@@ -11,4 +20,15 @@ describe("Integration test for 'drop' and 'first' functions", function () {
     expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 2, "right"))).toBe(1);
     expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 3, "left"))).toBe(4);
   });
+  it("should handle edge cases with empty arrays and large drop amounts", function () {
+    expect((0, _first.first)((0, _drop.drop)([]))).toBeUndefined();
+    expect((0, _first.first)((0, _drop.drop)([1], 1))).toBeUndefined();
+    expect((0, _first.first)((0, _drop.drop)([1, 2], 5))).toBeUndefined();
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3], 0))).toBe(1);
+  });
+  it("should handle arrays with different data types", function () {
+    expect((0, _first.first)((0, _drop.drop)(["a", "b", "c"], 1))).toBe("b");
+    expect((0, _first.first)((0, _drop.drop)([true, false], 1))).toBe(false);
+    expect((0, _first.first)((0, _drop.drop)([null, undefined, 1], 2))).toBe(1);
+  });
 });

package/module/es5/tests/integration/Tool/parseJson-and-Validate.test.js

@@ -4,23 +4,77 @@ var _parseJson = require("@/Tool/parseJson");
 var _boolean2 = require("@/Validate/boolean");
 var _number = require("@/Validate/number");
 var _object = require("@/Validate/object");
+/**
+ * Integration tests for JSON parsing and validation
+ *
+ * Tests the interaction between parseJson and Validate functions to ensure:
+ * - JSON strings are correctly parsed into objects
+ * - Parsed objects match the expected schema
+ * - Type validation works for various data types (number, boolean, string)
+ * - Nested object validation works correctly
+ */
 describe("Integration test for 'parseJson' and 'Validate' functions", function () {
-  it("should parse JSON string with number values", function () {
-    var jsonString = '{"key": 123}';
-    var schema = (0, _object.object)({
-      key: (0, _number.number)()
+  describe("Valid JSON parsing and validation", function () {
+    it("should parse JSON string with number values", function () {
+      var jsonString = '{"key": 123}';
+      var schema = (0, _object.object)({
+        key: (0, _number.number)()
+      });
+      var result = (0, _parseJson.parseJson)(jsonString);
+      var isValid = schema(result).validate;
+      expect(isValid).toEqual(true);
+      expect(result.key).toBe(123);
+    });
+    it("should parse JSON string with boolean values", function () {
+      var jsonString = '{"key": true}';
+      var schema = (0, _object.object)({
+        key: (0, _boolean2["boolean"])()
+      });
+      var result = (0, _parseJson.parseJson)(jsonString);
+      var isValid = schema(result).validate;
+      expect(isValid).toEqual(true);
+      expect(result.key).toBe(true);
+    });
+    it("should validate nested objects", function () {
+      var jsonString = '{"user": {"id": 1, "active": true}}';
+      var schema = (0, _object.object)({
+        user: (0, _object.object)({
+          id: (0, _number.number)(),
+          active: (0, _boolean2["boolean"])()
+        })
+      });
+      var result = (0, _parseJson.parseJson)(jsonString);
+      var isValid = schema(result).validate;
+      expect(isValid).toEqual(true);
+      expect(result.user.id).toBe(1);
+      expect(result.user.active).toBe(true);
     });
-    var result = (0, _parseJson.parseJson)(jsonString);
-    var isValid = schema(result).validate;
-    expect(isValid).toEqual(true);
   });
-  it("should parse JSON string with boolean values", function () {
-    var jsonString = '{"key": true}';
-    var schema = (0, _object.object)({
-      key: (0, _boolean2["boolean"])()
+  describe("Invalid cases", function () {
+    it("should handle invalid JSON strings", function () {
+      var invalidJson = "{key: invalid}";
+      expect(function () {
+        return (0, _parseJson.parseJson)(invalidJson);
+      }).toThrow();
+    });
+    it("should fail validation for mismatched types", function () {
+      var jsonString = '{"key": "123"}'; // string instead of number
+      var schema = (0, _object.object)({
+        key: (0, _number.number)()
+      });
+      var result = (0, _parseJson.parseJson)(jsonString);
+      var isValid = schema(result).validate;
+      expect(isValid).toEqual(false);
+    });
+    it("should fail validation for missing required fields", function () {
+      var jsonString = '{"id": 1}'; // missing 'active' field
+      var schema = (0, _object.object)({
+        id: (0, _number.number)(),
+        active: (0, _boolean2["boolean"])()
+      });
+      var result = (0, _parseJson.parseJson)(jsonString);
+      var isValid = schema(result).validate;
+      expect(isValid).toEqual(false);
     });
-    var result = (0, _parseJson.parseJson)(jsonString);
-    var isValid = schema(result).validate;
-    expect(isValid).toEqual(true);
   });
 });

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

@@ -1,7 +1,19 @@
 "use strict";
 
 var _arraysJoin = require("@/Array/arraysJoin");
-test("{arraysJoin}", function () {
-  expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [4, 5, 6])).toEqual([1, 2, 3, 4, 5, 6]);
-  expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [4, 5, 6], [7, 8, 9])).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+describe("arraysJoin", function () {
+  test("should join arrays without duplicates", function () {
+    // Basic array joining
+    expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [4, 5, 6])).toEqual([1, 2, 3, 4, 5, 6]);
+
+    // Multiple arrays joining
+    expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [4, 5, 6], [7, 8, 9])).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+
+    // Arrays with duplicates
+    expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [2, 3, 4], [3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
+
+    // Empty array cases
+    expect((0, _arraysJoin.arraysJoin)([], [1, 2, 3])).toEqual([1, 2, 3]);
+    expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [])).toEqual([1, 2, 3]);
+  });
 });

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

@@ -2,7 +2,7 @@
 
 var _checkFlagAlignment = require("@/Array/checkFlagAlignment");
 describe("checkFlagAlignment", function () {
-  it("横", function () {
+  it("should detect horizontal alignment", function () {
     var matrix = [[{
       value: 10,
       flag: true
@@ -33,7 +33,7 @@ describe("checkFlagAlignment", function () {
     }]];
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("縦", function () {
+  it("should detect vertical alignment", function () {
     var matrix = [[{
       value: 10,
       flag: false
@@ -64,7 +64,7 @@ describe("checkFlagAlignment", function () {
     }]];
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("斜め(左上)", function () {
+  it("should detect diagonal alignment (top-left to bottom-right)", function () {
     var matrix = [[{
       value: 10,
       flag: true
@@ -95,7 +95,7 @@ describe("checkFlagAlignment", function () {
     }]];
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("斜め(右上)", function () {
+  it("should detect diagonal alignment (top-right to bottom-left)", function () {
     var matrix = [[{
       value: 10,
       flag: false
@@ -126,7 +126,7 @@ describe("checkFlagAlignment", function () {
     }]];
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("揃ってない時", function () {
+  it("should return false when no alignment is found", function () {
     var matrix = [[{
       value: 10,
       flag: false
@@ -157,8 +157,8 @@ describe("checkFlagAlignment", function () {
     }]];
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(false);
   });
-  // 以下、大量データのテスト
-  it("横(大量)", function () {
+  // Tests with large datasets
+  it("should detect horizontal alignment with large dataset", function () {
     var row = Array(1000).fill({
       flag: true,
       value: 1
@@ -166,7 +166,7 @@ describe("checkFlagAlignment", function () {
     var matrix = Array(1000).fill(row);
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("縦(大量)", function () {
+  it("should detect vertical alignment with large dataset", function () {
     var row = Array(1000).fill({
       flag: false,
       value: 1
@@ -177,7 +177,7 @@ describe("checkFlagAlignment", function () {
     }
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("斜め(大量)", function () {
+  it("should detect diagonal alignment with large dataset", function () {
     var matrix = Array.from({
       length: 1000
     }, function () {
@@ -195,7 +195,7 @@ describe("checkFlagAlignment", function () {
     }
     expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
   });
-  it("揃ってない時(大量)", function () {
+  it("should return false when no alignment is found in large dataset", function () {
     var row = Array(1000).fill({
       flag: false,
       value: 1

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

@@ -3,44 +3,44 @@
 var _compact = require("@/Array/compact");
 var _lodash = _interopRequireDefault(require("lodash"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-describe("compact関数のテスト", function () {
-  test("真偽値と数値が混在する配列", function () {
+describe("compact function", function () {
+  test("should handle array with mixed booleans and numbers", function () {
     expect((0, _compact.compact)([0, 1, false, 2, "", 3])).toEqual([1, 2, 3]);
     expect(_lodash["default"].compact([0, 1, false, 2, "", 3])).toEqual([1, 2, 3]);
   });
-  test("全て真の値が含まれる配列", function () {
+  test("should handle array with all truthy values", function () {
     expect((0, _compact.compact)([1, 2, 3, "a", true])).toEqual([1, 2, 3, "a", true]);
     expect(_lodash["default"].compact([1, 2, 3, "a", true])).toEqual([1, 2, 3, "a", true]);
   });
-  test("全て偽の値が含まれる配列", function () {
-    expect((0, _compact.compact)([0, false, "", null, undefined, NaN])).toEqual([]);
-    expect(_lodash["default"].compact([0, false, "", null, undefined, NaN])).toEqual([]);
+  test("should handle array with all falsy values", function () {
+    expect((0, _compact.compact)([0, false, "", null, undefined, Number.NaN])).toEqual([]);
+    expect(_lodash["default"].compact([0, false, "", null, undefined, Number.NaN])).toEqual([]);
   });
-  test("空の配列", function () {
+  test("should handle empty array", function () {
     expect((0, _compact.compact)([])).toEqual([]);
     expect(_lodash["default"].compact([])).toEqual([]);
   });
-  test("配列にnullやundefinedが含まれる", function () {
+  test("should handle array with null and undefined", function () {
     expect((0, _compact.compact)([null, undefined, "hello"])).toEqual(["hello"]);
     expect(_lodash["default"].compact([null, undefined, "hello"])).toEqual(["hello"]);
   });
-  test("配列に0や''などの他の偽の値が含まれる", function () {
+  test("should handle array with falsy values like 0 and empty string", function () {
     expect((0, _compact.compact)([0, 1, "", 2, " ", 3])).toEqual([1, 2, " ", 3]);
     expect(_lodash["default"].compact([0, 1, "", 2, " ", 3])).toEqual([1, 2, " ", 3]);
   });
-  test("配列にオブジェクトや配列などの真値が含まれる", function () {
+  test("should handle array with truthy values like objects and arrays", function () {
     expect((0, _compact.compact)([{}, [], 0, false, "text"])).toEqual([{}, [], "text"]);
     expect(_lodash["default"].compact([{}, [], 0, false, "text"])).toEqual([{}, [], "text"]);
   });
-  test("配列にNaNが含まれる", function () {
-    expect((0, _compact.compact)([NaN, 1, 2, NaN])).toEqual([1, 2]);
-    expect(_lodash["default"].compact([NaN, 1, 2, NaN])).toEqual([1, 2]);
+  test("should handle array with NaN values", function () {
+    expect((0, _compact.compact)([Number.NaN, 1, 2, Number.NaN])).toEqual([1, 2]);
+    expect(_lodash["default"].compact([Number.NaN, 1, 2, Number.NaN])).toEqual([1, 2]);
   });
-  test("多種多様なデータ型が含まれる", function () {
-    expect((0, _compact.compact)([0, 1, "a", "", null, undefined, [], {}, false, true, NaN])).toEqual([1, "a", [], {}, true]);
-    expect(_lodash["default"].compact([0, 1, "a", "", null, undefined, [], {}, false, true, NaN])).toEqual([1, "a", [], {}, true]);
+  test("should handle array with various data types", function () {
+    expect((0, _compact.compact)([0, 1, "a", "", null, undefined, [], {}, false, true, Number.NaN])).toEqual([1, "a", [], {}, true]);
+    expect(_lodash["default"].compact([0, 1, "a", "", null, undefined, [], {}, false, true, Number.NaN])).toEqual([1, "a", [], {}, true]);
   });
-  test("配列が変更されずに新しい配列を返すこと", function () {
+  test("should return a new array without modifying the original", function () {
     var original = [0, 1, false, 2];
     var result = (0, _compact.compact)(original);
     expect(result).toEqual([1, 2]);

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+
+var _compareFunctionDefault = require("@/Array/compareFunctionDefault");
+describe("compareFunctionDefault", function () {
+  test("should return 1 when first value is greater", function () {
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(2, 1)).toBe(1);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)("b", "a")).toBe(1);
+  });
+  test("should return -1 when first value is lesser", function () {
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(1, 2)).toBe(-1);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)("a", "b")).toBe(-1);
+  });
+  test("should return 0 when values are equal", function () {
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(1, 1)).toBe(0);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)("a", "a")).toBe(0);
+  });
+  test("should work with different types", function () {
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(true, false)).toBe(1);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(false, true)).toBe(-1);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(true, true)).toBe(0);
+  });
+  test("should work with objects that are comparable", function () {
+    var date1 = new Date(2024, 0, 1);
+    var date2 = new Date(2024, 0, 2);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(date2, date1)).toBe(1);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(date1, date2)).toBe(-1);
+    expect((0, _compareFunctionDefault.compareFunctionDefault)(date1, new Date(2024, 0, 1))).toBe(0);
+  });
+});