umt 2.3.0 → 2.5.0

package/module/es5/tests/unit/UA/parseUserAgent.test.d.ts

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

package/module/es5/tests/unit/UA/parseUserAgent.test.js

@@ -1,95 +0,0 @@
-"use strict";
-
-var _parseUserAgent = require("@/UA/parseUserAgent");
-describe("parseUserAgent", function () {
-  it("should detect iOS mobile with Safari", function () {
-    var ua = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "ios",
-      browser: "safari",
-      device: "mobile"
-    });
-  });
-  it("should detect Android mobile with Chrome", function () {
-    var ua = "Mozilla/5.0 (Linux; Android 10; SM-A505FN) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Mobile Safari/537.36";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "android",
-      browser: "chrome",
-      device: "mobile"
-    });
-  });
-  it("should detect macOS desktop with Firefox", function () {
-    var ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:88.0) Gecko/20100101 Firefox/88.0";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "macos",
-      browser: "firefox",
-      device: "desktop"
-    });
-  });
-  it("should detect Windows desktop with Edge", function () {
-    var ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edg/89.0.774.57";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "windows",
-      browser: "edge",
-      device: "desktop"
-    });
-  });
-  it("should detect Linux desktop with Chrome", function () {
-    var ua = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "linux",
-      browser: "chrome",
-      device: "desktop"
-    });
-  });
-  it("should detect iPad as tablet", function () {
-    var ua = "Mozilla/5.0 (iPad; CPU OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "ios",
-      browser: "safari",
-      device: "tablet"
-    });
-  });
-  it("should detect Android tablet", function () {
-    var ua = "Mozilla/5.0 (Linux; Android 11; SM-T870) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "android",
-      browser: "chrome",
-      device: "tablet"
-    });
-  });
-  it("should detect Internet Explorer on Windows", function () {
-    var ua = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "windows",
-      browser: "ie",
-      device: "desktop"
-    });
-  });
-  it("should detect Googlebot", function () {
-    var ua = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "other",
-      browser: "other",
-      device: "bot"
-    });
-  });
-  it("should handle unknown user agent", function () {
-    var ua = "Unknown User Agent String";
-    var result = (0, _parseUserAgent.parseUserAgent)(ua);
-    expect(result).toEqual({
-      os: "other",
-      browser: "other",
-      device: "other"
-    });
-  });
-});

package/module/es5/tests/unit/Unit/unitConverterInitialization.test.d.ts

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

package/module/es5/tests/unit/Unit/unitConverterInitialization.test.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var _unitConverterInitialization = require("@/Unit/unitConverterInitialization");
-// Example unit converter for length measurements
-var convertLength = (0, _unitConverterInitialization.unitConverterInitialization)({
-  meters: 1,
-  // base unit
-  kilometers: 0.001,
-  centimeters: 100,
-  millimeters: 1000
-});
-describe("Unit Converter", function () {
-  it("converts between base unit and larger units", function () {
-    expect(convertLength(1000, "meters", "kilometers")).toBeCloseTo(1);
-    expect(convertLength(1, "kilometers", "meters")).toBeCloseTo(1000);
-  });
-  it("converts between base unit and smaller units", function () {
-    expect(convertLength(1, "meters", "centimeters")).toBeCloseTo(100);
-    expect(convertLength(100, "centimeters", "meters")).toBeCloseTo(1);
-  });
-  it("converts between different small units", function () {
-    expect(convertLength(100, "centimeters", "millimeters")).toBeCloseTo(1000);
-    expect(convertLength(1000, "millimeters", "centimeters")).toBeCloseTo(100);
-  });
-  it("handles zero values correctly", function () {
-    expect(convertLength(0, "meters", "kilometers")).toBe(0);
-    expect(convertLength(0, "millimeters", "centimeters")).toBe(0);
-  });
-  it("returns same value when converting to same unit", function () {
-    expect(convertLength(5, "meters", "meters")).toBe(5);
-    expect(convertLength(100, "centimeters", "centimeters")).toBe(100);
-  });
-  it("maintains precision in round-trip conversions", function () {
-    var original = 5;
-    var roundTrip = convertLength(convertLength(original, "meters", "kilometers"), "kilometers", "meters");
-    expect(roundTrip).toBeCloseTo(original);
-    var smallUnitsRoundTrip = convertLength(convertLength(original, "centimeters", "millimeters"), "millimeters", "centimeters");
-    expect(smallUnitsRoundTrip).toBeCloseTo(original);
-  });
-});

package/module/es5/tests/unit/Validate/array/core.test.d.ts

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

package/module/es5/tests/unit/Validate/array/core.test.js

@@ -1,86 +0,0 @@
-"use strict";
-
-var _Validate = require("@/Validate");
-var _core = require("@/Validate/array/core");
-var _string = require("@/Validate/string");
-describe("Array core validation", function () {
-  // Test for empty array
-  it("should validate an empty array", function () {
-    var validateArray = (0, _core.array)();
-    expect(validateArray([]).validate).toBe(true);
-  });
-
-  // Test for null and undefined
-  it("should fail validation for null and undefined", function () {
-    var validateArray = (0, _core.array)();
-    // @ts-ignore
-    expect(validateArray(null).validate).toBe(false);
-    // @ts-ignore
-    expect(validateArray(undefined).validate).toBe(false);
-  });
-  it("should validate an array of mixed values without type validation", function () {
-    var validateArray = (0, _core.array)();
-    expect(validateArray(["apple", true, 123]).validate).toBe(true);
-  });
-  it("should validate an array of strings with validation", function () {
-    var validateArray = (0, _core.array)({
-      string: (0, _string.string)()
-    });
-    expect(validateArray(["apple", "banana", "cherry"]).validate).toBe(true);
-    // @ts-ignore
-    expect(validateArray(["apple", 1, true]).validate).toBe(false);
-  });
-  it("should validate an array of numbers with range validation", function () {
-    var validateArray = (0, _core.array)({
-      number: (0, _Validate.number)([(0, _Validate.minValue)(0), (0, _Validate.maxValue)(10)])
-    });
-    expect(validateArray([1, 2, 3]).validate).toBe(true);
-    expect(validateArray([1, 2, 3, 11]).validate).toBe(false);
-    // @ts-ignore
-    expect(validateArray([1, "2", 3]).validate).toBe(false);
-  });
-  it("should validate an array of mixed types with specific validations", function () {
-    var validateArray = (0, _core.array)({
-      string: (0, _string.string)([(0, _string.maxLength)(1)]),
-      number: (0, _Validate.number)([(0, _Validate.minValue)(0), (0, _Validate.maxValue)(10)])
-    });
-    expect(validateArray([1, 2, 3]).validate).toBe(true);
-    expect(validateArray([1, 2, 3, 11]).validate).toBe(false);
-    expect(validateArray([1, "2", 3]).validate).toBe(true);
-    expect(validateArray([1, 2, 3, "11"]).validate).toBe(false);
-  });
-  it("should return a custom message on array type validation failure", function () {
-    var customMessage = "Array validation failed";
-    var validateArray = (0, _core.array)({
-      string: (0, _string.string)()
-    }, customMessage);
-    // @ts-ignore
-    var result = validateArray("not an array");
-    expect(result.validate).toBe(false);
-    expect(result.message).toBe(customMessage);
-  });
-  it("should return element validation error message", function () {
-    var elementMessage = "String too long";
-    var validateArray = (0, _core.array)({
-      string: (0, _string.string)([(0, _string.maxLength)(3, elementMessage)])
-    });
-    var result = validateArray(["ok", "good", "toolong"]);
-    expect(result.validate).toBe(false);
-    expect(result.message).toBe(elementMessage);
-  });
-  it("should return an empty message when no custom message is provided", function () {
-    var validateArray = (0, _core.array)({
-      string: (0, _string.string)()
-    });
-    // @ts-ignore
-    var result = validateArray("not an array");
-    expect(result.validate).toBe(false);
-    expect(result.message).toBe("");
-  });
-  it("should preserve the original array in the return type", function () {
-    var testArray = [1, 2, 3];
-    var validateArray = (0, _core.array)();
-    var result = validateArray(testArray);
-    expect(result.type).toBe(testArray);
-  });
-});

package/module/es5/tests/unit/Validate/boolean/core.test.d.ts

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

package/module/es5/tests/unit/Validate/boolean/core.test.js

@@ -1,29 +0,0 @@
-"use strict";
-
-var _core = require("@/Validate/boolean/core");
-describe("boolean core validation", function () {
-  it("should return true for boolean values", function () {
-    var validateBoolean = (0, _core["boolean"])();
-    expect(validateBoolean(true).validate).toBe(true);
-    expect(validateBoolean(false).validate).toBe(true);
-  });
-  it("should return false for non-boolean values", function () {
-    var validateBoolean = (0, _core["boolean"])();
-    // @ts-ignore
-    expect(validateBoolean(0).validate).toBe(false);
-    // @ts-ignore
-    expect(validateBoolean(null).validate).toBe(false);
-    // @ts-ignore
-    expect(validateBoolean(undefined).validate).toBe(false);
-    // @ts-ignore
-    expect(validateBoolean("true").validate).toBe(false);
-  });
-  it("should return the custom message for invalid input", function () {
-    var customMessage = "This is not a boolean";
-    var validateBoolean = (0, _core["boolean"])(customMessage);
-    // @ts-ignore
-    expect(validateBoolean(0).validate).toBe(false);
-    // @ts-ignore
-    expect(validateBoolean(0).message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/core/core.test.d.ts

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

package/module/es5/tests/unit/Validate/core/core.test.js

@@ -1,87 +0,0 @@
-"use strict";
-
-var _core = require("@/Validate/core");
-describe("Core validation", function () {
-  it("should validate type correctly", function () {
-    var validateString = (0, _core.core)("string");
-    expect(validateString("test").validate).toBe(true);
-    // @ts-ignore
-    expect(validateString(123).validate).toBe(false);
-  });
-  it("should respect custom message for type validation", function () {
-    var message = "Not a string";
-    var validateString = (0, _core.core)("string");
-    // @ts-ignore
-    expect(validateString(123, [], message).message).toBe(message);
-  });
-  it("should return empty message when no message provided", function () {
-    var validateString = (0, _core.core)("string");
-    // @ts-ignore
-    expect(validateString(123).message).toBe("");
-  });
-  it("should validate with additional validation rules", function () {
-    var validateString = (0, _core.core)("string");
-    var minLength = {
-      type: "string",
-      validate: function validate(value) {
-        return value.length >= 3;
-      },
-      message: "String too short"
-    };
-    expect(validateString("test", [minLength]).validate).toBe(true);
-    expect(validateString("ab", [minLength]).validate).toBe(false);
-    expect(validateString("ab", [minLength]).message).toBe("String too short");
-
-    // Test validation rule without message
-    var noMessage = {
-      type: "string",
-      validate: function validate(value) {
-        return value.length >= 3;
-      }
-    };
-    expect(validateString("ab", [noMessage]).message).toBe("");
-  });
-  it("should validate numbers", function () {
-    var validateNumber = (0, _core.core)("number");
-    expect(validateNumber(123).validate).toBe(true);
-    // @ts-ignore
-    expect(validateNumber("123").validate).toBe(false);
-  });
-  it("should validate booleans", function () {
-    var validateBoolean = (0, _core.core)("boolean");
-    expect(validateBoolean(true).validate).toBe(true);
-    expect(validateBoolean(false).validate).toBe(true);
-    // @ts-ignore
-    expect(validateBoolean("true").validate).toBe(false);
-  });
-  it("should validate with multiple validation rules", function () {
-    var validateString = (0, _core.core)("string");
-    var minLength = {
-      type: "string",
-      validate: function validate(value) {
-        return value.length >= 3;
-      },
-      message: "String too short"
-    };
-    var maxLength = {
-      type: "string",
-      validate: function validate(value) {
-        return value.length <= 10;
-      },
-      message: "String too long"
-    };
-    expect(validateString("test", [minLength, maxLength]).validate).toBe(true);
-    expect(validateString("ab", [minLength, maxLength]).validate).toBe(false);
-    expect(validateString("ab", [minLength, maxLength]).message).toBe("String too short");
-    expect(validateString("very long string", [minLength, maxLength]).validate).toBe(false);
-    expect(validateString("very long string", [minLength, maxLength]).message).toBe("String too long");
-  });
-  it("should preserve type information in return value", function () {
-    var validateString = (0, _core.core)("string");
-    var validateNumber = (0, _core.core)("number");
-    var validateBoolean = (0, _core.core)("boolean");
-    expect(validateString("test").type).toBe("string");
-    expect(validateNumber(123).type).toBe("number");
-    expect(validateBoolean(true).type).toBe("boolean");
-  });
-});

package/module/es5/tests/unit/Validate/isArray.test.d.ts

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

package/module/es5/tests/unit/Validate/isArray.test.js

@@ -1,36 +0,0 @@
-"use strict";
-
-var _isArray = require("@/Validate/isArray");
-describe("isArray", function () {
-  it("should return true for an array", function () {
-    expect((0, _isArray.isArray)([1, 2, 3])).toBe(true);
-    expect((0, _isArray.isArray)(["a", "b", "c"])).toBe(true);
-    expect((0, _isArray.isArray)([true, false])).toBe(true);
-    expect((0, _isArray.isArray)([{
-      a: 1
-    }, {
-      b: 2
-    }])).toBe(true);
-    expect((0, _isArray.isArray)([])).toBe(true);
-  });
-  it("should work as a type guard", function () {
-    var value = [1, 2, 3];
-    if ((0, _isArray.isArray)(value)) {
-      // TypeScript should recognize value as number[] here
-      var sum = value.reduce(function (a, b) {
-        return a + b;
-      }, 0);
-      expect(sum).toBe(6);
-    }
-  });
-  it("should return false for a non-array value", function () {
-    expect((0, _isArray.isArray)(1)).toBe(false);
-    expect((0, _isArray.isArray)("hello")).toBe(false);
-    expect((0, _isArray.isArray)(true)).toBe(false);
-    expect((0, _isArray.isArray)({
-      a: 1
-    })).toBe(false);
-    expect((0, _isArray.isArray)(null)).toBe(false);
-    expect((0, _isArray.isArray)(undefined)).toBe(false);
-  });
-});

package/module/es5/tests/unit/Validate/isDictionaryObject.test.d.ts

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

package/module/es5/tests/unit/Validate/isDictionaryObject.test.js

@@ -1,62 +0,0 @@
-"use strict";
-
-var _isDictionaryObject = require("@/Validate/isDictionaryObject");
-describe("isDictionaryObject", function () {
-  it("should return true for an empty object", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({})).toBe(true);
-  });
-  it("should return true for an object with string properties", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({
-      foo: "bar",
-      baz: "qux"
-    })).toBe(true);
-  });
-  it("should work as a type guard", function () {
-    var value = {
-      x: 1,
-      y: 2
-    };
-    if ((0, _isDictionaryObject.isDictionaryObject)(value)) {
-      // TypeScript should recognize value as { x: number; y: number }
-      var sum = value.x + value.y;
-      expect(sum).toBe(3);
-    }
-  });
-  it("should return true for an object with number properties", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({
-      foo: 1,
-      bar: 2
-    })).toBe(true);
-  });
-  it("should return true for an object with boolean properties", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({
-      foo: true,
-      bar: false
-    })).toBe(true);
-  });
-  it("should return true for an object with mixed properties", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({
-      foo: "bar",
-      baz: 1,
-      qux: true
-    })).toBe(true);
-  });
-  it("should return false for an array", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)([1, 2, 3])).toBe(false);
-  });
-  it("should return false for a string", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)("foo")).toBe(false);
-  });
-  it("should return false for a number", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(42)).toBe(false);
-  });
-  it("should return false for a boolean", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(true)).toBe(false);
-  });
-  it("should return false for null", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(null)).toBe(false);
-  });
-  it("should return false for undefined", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(undefined)).toBe(false);
-  });
-});

package/module/es5/tests/unit/Validate/isDouble.test.d.ts

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

package/module/es5/tests/unit/Validate/isDouble.test.js

@@ -1,47 +0,0 @@
-"use strict";
-
-var _isDouble = require("@/Validate/isDouble");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-describe("isDouble", function () {
-  it("should return true for valid doubles", function () {
-    expect((0, _isDouble.isDouble)(1.5)).toBe(true);
-    expect((0, _isDouble.isDouble)(-1.5)).toBe(true);
-    expect((0, _isDouble.isDouble)(1.23e-4)).toBe(true);
-    expect((0, _isDouble.isDouble)("1.5")).toBe(true);
-    expect((0, _isDouble.isDouble)("1.5", false)).toBe(false);
-  });
-  it("should work as a type guard", function () {
-    var value = 1.5;
-    if ((0, _isDouble.isDouble)(value)) {
-      // TypeScript should recognize value as number | string
-      expect(typeof value === "number" || typeof value === "string").toBe(true);
-      expect(Number(value)).toBe(1.5);
-    }
-    var strictValue = 1.5;
-    if ((0, _isDouble.isDouble)(strictValue, false)) {
-      // TypeScript should recognize strictValue as number
-      expect(_typeof(strictValue)).toBe("number");
-      expect(strictValue).toBe(1.5);
-    }
-  });
-  it("should return false for invalid doubles", function () {
-    expect((0, _isDouble.isDouble)(1)).toBe(false);
-    expect((0, _isDouble.isDouble)(1, false)).toBe(false);
-    expect((0, _isDouble.isDouble)("1")).toBe(false);
-    expect((0, _isDouble.isDouble)("1", false)).toBe(false);
-    expect((0, _isDouble.isDouble)(Number.NaN)).toBe(false);
-    expect((0, _isDouble.isDouble)(Number.POSITIVE_INFINITY)).toBe(false);
-    expect((0, _isDouble.isDouble)(Number.NEGATIVE_INFINITY)).toBe(false);
-    expect((0, _isDouble.isDouble)(null)).toBe(false);
-    expect((0, _isDouble.isDouble)(undefined)).toBe(false);
-    expect((0, _isDouble.isDouble)(true)).toBe(false);
-    expect((0, _isDouble.isDouble)(false)).toBe(false);
-    expect((0, _isDouble.isDouble)({})).toBe(false);
-    expect((0, _isDouble.isDouble)([])).toBe(false);
-    expect((0, _isDouble.isDouble)(0x12)).toBe(false);
-    expect((0, _isDouble.isDouble)(Number.NEGATIVE_INFINITY, false)).toBe(false);
-    expect((0, _isDouble.isDouble)(null, false)).toBe(false);
-    expect((0, _isDouble.isDouble)(true, false)).toBe(false);
-    expect((0, _isDouble.isDouble)(false, false)).toBe(false);
-  });
-});

package/module/es5/tests/unit/Validate/isEqual.test.d.ts

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

package/module/es5/tests/unit/Validate/isEqual.test.js

@@ -1,74 +0,0 @@
-"use strict";
-
-var _isEqual = require("@/Validate/isEqual");
-var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-describe("isEqual", function () {
-  it("should compare primitive values correctly", function () {
-    expect((0, _isEqual.isEqual)(1, 1)).toBe(true);
-    expect((0, _isEqual.isEqual)("test", "test")).toBe(true);
-    expect((0, _isEqual.isEqual)(true, true)).toBe(true);
-    expect((0, _isEqual.isEqual)(null, null)).toBe(true);
-    expect((0, _isEqual.isEqual)(undefined, undefined)).toBe(true);
-    expect((0, _isEqual.isEqual)(Number.NaN, Number.NaN)).toBe(true);
-  });
-  it("should return false for different primitive values", function () {
-    expect((0, _isEqual.isEqual)(1, 2)).toBe(false);
-    expect((0, _isEqual.isEqual)("test", "other")).toBe(false);
-    expect((0, _isEqual.isEqual)(true, false)).toBe(false);
-    expect((0, _isEqual.isEqual)(null, undefined)).toBe(false);
-  });
-  it("should handle object references correctly", function () {
-    var obj = {
-      a: 1
-    };
-    expect((0, _isEqual.isEqual)(obj, obj)).toBe(true);
-    expect((0, _isEqual.isEqual)(obj, {
-      a: 1
-    })).toBe(false);
-  });
-  it("should handle array references correctly", function () {
-    var arr = [1, 2, 3];
-    expect((0, _isEqual.isEqual)(arr, arr)).toBe(true);
-    expect((0, _isEqual.isEqual)(arr, [1, 2, 3])).toBe(false);
-  });
-  it("should distinguish between -0 and +0", function () {
-    expect((0, _isEqual.isEqual)(-0, +0)).toBe(false);
-  });
-
-  // lodash tests
-  it("should compare primitive values correctly (using lodash)", function () {
-    expect(_lodash["default"].isEqual(1, 1)).toBe(true);
-    expect(_lodash["default"].isEqual("test", "test")).toBe(true);
-    expect(_lodash["default"].isEqual(true, true)).toBe(true);
-    expect(_lodash["default"].isEqual(null, null)).toBe(true);
-    expect(_lodash["default"].isEqual(undefined, undefined)).toBe(true);
-    expect(_lodash["default"].isEqual(Number.NaN, Number.NaN)).toBe(true);
-  });
-  it("should return false for different primitive values (using lodash)", function () {
-    expect(_lodash["default"].isEqual(1, 2)).toBe(false);
-    expect(_lodash["default"].isEqual("test", "other")).toBe(false);
-    expect(_lodash["default"].isEqual(true, false)).toBe(false);
-    expect(_lodash["default"].isEqual(null, undefined)).toBe(false);
-  });
-  it("should handle object references correctly (using lodash)", function () {
-    var obj = {
-      a: 1
-    };
-    expect(_lodash["default"].isEqual(obj, obj)).toBe(true);
-    // This test returns true because the implementation of lodash and isEqual is different.
-    expect(_lodash["default"].isEqual(obj, {
-      a: 1
-    })).toBe(true);
-  });
-  it("should handle array references correctly (using lodash)", function () {
-    var arr = [1, 2, 3];
-    expect(_lodash["default"].isEqual(arr, arr)).toBe(true);
-    // This test returns true because the implementation of lodash and isEqual is different.
-    expect(_lodash["default"].isEqual(arr, [1, 2, 3])).toBe(true);
-  });
-  it("should distinguish between -0 and +0 (using lodash)", function () {
-    // This test returns true because the implementation of lodash and isEqual is different.
-    expect(_lodash["default"].isEqual(-0, +0)).toBe(true);
-  });
-});

package/module/es5/tests/unit/Validate/isNotEmpty.test.d.ts

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

package/module/es5/tests/unit/Validate/isNotEmpty.test.js

@@ -1,43 +0,0 @@
-"use strict";
-
-var _isNotEmpty = require("@/Validate/isNotEmpty");
-describe("isNotEmpty", function () {
-  it("should return true for a non-empty object", function () {
-    expect((0, _isNotEmpty.isNotEmpty)({
-      a: 1
-    })).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)({
-      a: 1,
-      b: 2
-    })).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)({
-      a: {
-        b: 2
-      }
-    })).toBe(true);
-  });
-  it("should return false for an empty object", function () {
-    expect((0, _isNotEmpty.isNotEmpty)({})).toBe(false);
-  });
-  it("should return true for a non-empty array", function () {
-    expect((0, _isNotEmpty.isNotEmpty)([1, 2, 3])).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)(["a", "b", "c"])).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)([true, false])).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)([{
-      a: 1
-    }, {
-      b: 2
-    }])).toBe(true);
-  });
-  it("should return false for an empty array", function () {
-    expect((0, _isNotEmpty.isNotEmpty)([])).toBe(false);
-  });
-
-  // Note: Map and Set are always considered empty by Object.keys()
-  it("should return false for Map and Set (regardless of content)", function () {
-    expect((0, _isNotEmpty.isNotEmpty)(new Map([["a", 1], ["b", 2]]))).toBe(false);
-    expect((0, _isNotEmpty.isNotEmpty)(new Set([1, 2, 3]))).toBe(false);
-    expect((0, _isNotEmpty.isNotEmpty)(new Map())).toBe(false);
-    expect((0, _isNotEmpty.isNotEmpty)(new Set())).toBe(false);
-  });
-});

package/module/es5/tests/unit/Validate/isNumber.test.d.ts

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