umt 2.2.1 → 2.4.0

package/module/es5/tests/unit/Math/degToRad.test.js

@@ -1,50 +0,0 @@
-"use strict";
-
-var _degToRad = require("@/Math/degToRad");
-describe("degToRad", function () {
-  // Normal test cases
-  test("degToRad: Normal Cases", function () {
-    expect((0, _degToRad.degToRad)(0)).toBeCloseTo(0);
-    expect((0, _degToRad.degToRad)(90)).toBeCloseTo(Math.PI / 2);
-    expect((0, _degToRad.degToRad)(180)).toBeCloseTo(Math.PI);
-    expect((0, _degToRad.degToRad)(270)).toBeCloseTo(3 * Math.PI / 2);
-    expect((0, _degToRad.degToRad)(360)).toBeCloseTo(2 * Math.PI);
-  });
-
-  // Negative angles
-  test("degToRad: Negative Angles", function () {
-    expect((0, _degToRad.degToRad)(-90)).toBeCloseTo(-Math.PI / 2);
-    expect((0, _degToRad.degToRad)(-180)).toBeCloseTo(-Math.PI);
-    expect((0, _degToRad.degToRad)(-270)).toBeCloseTo(-3 * Math.PI / 2);
-    expect((0, _degToRad.degToRad)(-360)).toBeCloseTo(-2 * Math.PI);
-  });
-
-  // Floating point angles
-  test("degToRad: Floating Point Angles", function () {
-    expect((0, _degToRad.degToRad)(45.5)).toBeCloseTo(Math.PI / 4 + Math.PI / 360);
-    expect((0, _degToRad.degToRad)(60.7)).toBeCloseTo(Math.PI * 60.7 / 180);
-    expect((0, _degToRad.degToRad)(120.2)).toBeCloseTo(Math.PI * 120.2 / 180);
-  });
-
-  // Angles greater than 360 and 1000 degrees
-  test("degToRad: Angles Greater Than 360 and 1000 Degrees", function () {
-    expect((0, _degToRad.degToRad)(450)).toBeCloseTo(5 * Math.PI / 2);
-    expect((0, _degToRad.degToRad)(720)).toBeCloseTo(4 * Math.PI);
-    expect((0, _degToRad.degToRad)(1080)).toBeCloseTo(6 * Math.PI);
-    expect((0, _degToRad.degToRad)(1440)).toBeCloseTo(8 * Math.PI);
-  });
-
-  // NaN and Infinity cases
-  test("degToRad: NaN and Infinity", function () {
-    expect((0, _degToRad.degToRad)(Number.NaN)).toBe(Number.NaN);
-    expect((0, _degToRad.degToRad)(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
-    expect((0, _degToRad.degToRad)(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
-  });
-
-  // Invalid inputs
-  test("degToRad: Invalid Inputs", function () {
-    expect((0, _degToRad.degToRad)("90")).toBeCloseTo(Math.PI / 2);
-    expect((0, _degToRad.degToRad)([90])).toBeCloseTo(Math.PI / 2);
-    expect((0, _degToRad.degToRad)({})).toBe(Number.NaN);
-  });
-});

package/module/es5/tests/unit/Math/deviationValue.test.d.ts

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

package/module/es5/tests/unit/Math/deviationValue.test.js

@@ -1,30 +0,0 @@
-"use strict";
-
-var _deviationValue = require("@/Math/deviationValue");
-// Tests for standard score calculation
-describe("deviationValue", function () {
-  // Test with normal input values
-  test("should handle normal input values", function () {
-    expect((0, _deviationValue.deviationValue)(100, 50, 10)).toBe(100);
-  });
-
-  // Test with value equal to mean
-  test("should handle value equal to mean", function () {
-    expect((0, _deviationValue.deviationValue)(50, 50, 10)).toBe(50);
-  });
-
-  // Test with zero standard deviation
-  test("should handle zero standard deviation", function () {
-    expect((0, _deviationValue.deviationValue)(100, 50, 0)).toBe(Number.POSITIVE_INFINITY);
-  });
-
-  // Test with negative values
-  test("should handle negative values", function () {
-    expect((0, _deviationValue.deviationValue)(-20, 0, 20)).toBe(40);
-  });
-
-  // Test with floating point numbers
-  test("should handle floating point numbers", function () {
-    expect((0, _deviationValue.deviationValue)(55.5, 50, 10)).toBeCloseTo(55.5);
-  });
-});

package/module/es5/tests/unit/Math/division.test.d.ts

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

package/module/es5/tests/unit/Math/division.test.js

@@ -1,81 +0,0 @@
-"use strict";
-
-var _division = require("@/Math/division");
-describe("division function", function () {
-  describe("basic integer division", function () {
-    it("should correctly divide integers", function () {
-      expect((0, _division.division)(10, 2)).toBe(5);
-      expect((0, _division.division)(30, 5)).toBe(6);
-    });
-    it("should handle large number divided by small number", function () {
-      expect((0, _division.division)(1000, 10)).toBe(100);
-      expect((0, _division.division)(10000, 100)).toBe(100);
-    });
-    it("should handle small number divided by large number", function () {
-      expect((0, _division.division)(10, 100)).toBe(0.1);
-      expect((0, _division.division)(1, 1000)).toBe(0.001);
-    });
-  });
-  describe("division with remainder", function () {
-    it("should handle division with remainder when isFloor is true", function () {
-      expect((0, _division.division)(7, 2, true)).toBe(3.5);
-      expect((0, _division.division)(3, 5, true)).toBe(0.6);
-    });
-    it("should return quotient and remainder when isFloor is false", function () {
-      expect((0, _division.division)(10, 3, false)).toEqual([3, 1]);
-      expect((0, _division.division)(7, 2, false)).toEqual([3, 1]);
-      expect((0, _division.division)(3, 5, false)).toEqual([0, 3]);
-    });
-    it("should handle large numbers with remainder", function () {
-      expect((0, _division.division)(1000, 3, false)).toEqual([333, 1]);
-      expect((0, _division.division)(10000, 7, false)).toEqual([1428, 4]);
-    });
-  });
-  describe("decimal numbers", function () {
-    it("should handle decimal numbers with different lengths", function () {
-      expect((0, _division.division)(10.5, 2.1)).toBe(5);
-      expect((0, _division.division)(0.1, 0.2)).toBe(0.5);
-      expect((0, _division.division)(0.001, 0.1)).toBe(0.01);
-      expect((0, _division.division)(0.1, 0.001)).toBe(100);
-      expect((0, _division.division)(0.0001, 0.01)).toBe(0.01);
-    });
-    it("should handle decimal numbers with same length", function () {
-      expect((0, _division.division)(1.1, 2.2)).toBe(0.5);
-      expect((0, _division.division)(0.01, 0.02)).toBe(0.5);
-    });
-    it("should handle complex decimal combinations", function () {
-      expect((0, _division.division)(1.23456, 2.1)).toBeCloseTo(0.587885714);
-      expect((0, _division.division)(0.0001, 0.0003)).toBeCloseTo(0.333333333);
-      expect((0, _division.division)(123.456, 0.789)).toBeCloseTo(156.4715);
-    });
-    it("should handle decimal numbers with remainder", function () {
-      expect((0, _division.division)(1.5, 0.7, false)).toEqual([2, 1]);
-      expect((0, _division.division)(0.123, 0.0456, false)).toEqual([2, 123]);
-    });
-  });
-  describe("edge cases", function () {
-    it("should return NaN for division by zero", function () {
-      expect((0, _division.division)(1, 0)).toBe(Number.NaN);
-      expect((0, _division.division)(-1, 0)).toBe(Number.NaN);
-      expect((0, _division.division)(-1, 0, false)).toEqual([Number.NaN, Number.NaN]);
-      expect((0, _division.division)(0, 0)).toBe(Number.NaN);
-      expect((0, _division.division)(0, 0, false)).toEqual([Number.NaN, Number.NaN]);
-    });
-    it("should handle zero dividend", function () {
-      expect((0, _division.division)(0, 1)).toBe(0);
-      expect((0, _division.division)(0, -1)).toBe(-0);
-      expect((0, _division.division)(0, 2, false)).toEqual([0, 0]);
-      expect((0, _division.division)(0, -2, false)).toEqual([-0, 0]);
-    });
-    it("should handle negative numbers", function () {
-      expect((0, _division.division)(-10, 2)).toBe(-5);
-      expect((0, _division.division)(10, -2)).toBe(-5);
-      expect((0, _division.division)(-10, -2)).toBe(5);
-    });
-    it("should handle negative decimals", function () {
-      expect((0, _division.division)(-0.16, 0.2)).toBe(-0.8);
-      expect((0, _division.division)(0.16, -0.2)).toBe(-0.8);
-      expect((0, _division.division)(-0.16, -0.2)).toBe(0.8);
-    });
-  });
-});

package/module/es5/tests/unit/Math/factorial.test.d.ts

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

package/module/es5/tests/unit/Math/factorial.test.js

@@ -1,26 +0,0 @@
-"use strict";
-
-var _factorial = require("@/Math/factorial");
-describe("factorial", function () {
-  test("should return 1 for factorial of 0", function () {
-    expect((0, _factorial.factorial)(0)).toBe(1);
-  });
-  test("should return 1 for factorial of 1", function () {
-    expect((0, _factorial.factorial)(1)).toBe(1);
-  });
-  test("should correctly calculate factorial of positive integers", function () {
-    expect((0, _factorial.factorial)(2)).toBe(2);
-    expect((0, _factorial.factorial)(3)).toBe(6);
-    expect((0, _factorial.factorial)(4)).toBe(24);
-    expect((0, _factorial.factorial)(5)).toBe(120);
-    expect((0, _factorial.factorial)(6)).toBe(720);
-    expect((0, _factorial.factorial)(7)).toBe(5040);
-    expect((0, _factorial.factorial)(8)).toBe(40320);
-    expect((0, _factorial.factorial)(9)).toBe(362880);
-    expect((0, _factorial.factorial)(10)).toBe(3628800);
-  });
-  test("should return 1 for negative numbers", function () {
-    expect((0, _factorial.factorial)(-1)).toBe(1);
-    expect((0, _factorial.factorial)(-5)).toBe(1);
-  });
-});

package/module/es5/tests/unit/Math/factorize.test.d.ts

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

package/module/es5/tests/unit/Math/factorize.test.js

@@ -1,38 +0,0 @@
-"use strict";
-
-var _factorize = require("@/Math/factorize");
-describe("factorize", function () {
-  describe("basic factorization", function () {
-    test("should correctly factorize composite numbers", function () {
-      expect((0, _factorize.factorize)(12)).toEqual([2, 2, 3]);
-      expect((0, _factorize.factorize)(14)).toEqual([2, 7]);
-      expect((0, _factorize.factorize)(15)).toEqual([3, 5]);
-      expect((0, _factorize.factorize)(18)).toEqual([2, 3, 3]);
-      expect((0, _factorize.factorize)(20)).toEqual([2, 2, 5]);
-    });
-    test("should handle powers of the same prime", function () {
-      expect((0, _factorize.factorize)(16)).toEqual([2, 2, 2, 2]);
-      expect((0, _factorize.factorize)(27)).toEqual([3, 3, 3]);
-      expect((0, _factorize.factorize)(32)).toEqual([2, 2, 2, 2, 2]);
-    });
-    test("should handle prime numbers", function () {
-      expect((0, _factorize.factorize)(17)).toEqual([17]);
-      expect((0, _factorize.factorize)(19)).toEqual([19]);
-      expect((0, _factorize.factorize)(23)).toEqual([23]);
-    });
-  });
-  describe("edge cases", function () {
-    test("should handle negative numbers", function () {
-      expect((0, _factorize.factorize)(-12)).toEqual([2, 2, 3]);
-      expect((0, _factorize.factorize)(-15)).toEqual([3, 5]);
-    });
-    test("should handle zero and one", function () {
-      expect((0, _factorize.factorize)(0)).toEqual([]);
-      expect((0, _factorize.factorize)(1)).toEqual([]);
-    });
-    test("should handle large numbers", function () {
-      expect((0, _factorize.factorize)(997)).toEqual([997]); // Large prime
-      expect((0, _factorize.factorize)(1000)).toEqual([2, 2, 2, 5, 5, 5]);
-    });
-  });
-});

package/module/es5/tests/unit/Math/flexibleNumberConversion.test.d.ts

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

package/module/es5/tests/unit/Math/flexibleNumberConversion.test.js

@@ -1,195 +0,0 @@
-"use strict";
-
-var _flexibleNumberConversion = require("@/Math/flexibleNumberConversion");
-describe("flexibleNumberConversion", function () {
-  // Basic numeric input
-  describe("Basic numeric input", function () {
-    test("should return positive integers as-is", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(123)).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(456)).toBe(456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(789)).toBe(789);
-    });
-    test("should return negative integers as-is", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-123)).toBe(-123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-456)).toBe(-456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-789)).toBe(-789);
-    });
-    test("should return zero as-is", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(0)).toBe(0);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-0)).toBe(-0);
-    });
-  });
-
-  // String numeric input
-  describe("String numeric input", function () {
-    test("should properly convert positive integer strings", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("123")).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("456")).toBe(456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("789")).toBe(789);
-    });
-    test("should properly convert negative integer strings", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-123")).toBe(-123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-456")).toBe(-456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-789")).toBe(-789);
-    });
-    test("should properly convert decimal strings", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14")).toBe(3.14);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-2.718")).toBe(-2.718);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0.001")).toBe(0.001);
-    });
-    test("should correctly interpret exponential notation strings", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e3")).toBe(1000);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-2.5e-3")).toBe(-0.0025);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("6.022e23")).toBe(6.022e23);
-    });
-    test("should correctly interpret special base notation strings", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0x1A")).toBe(26);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0b1011")).toBe(11);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0o77")).toBe(63);
-    });
-    test("should properly convert strings with spaces around numbers", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" 123 ")).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("   -456")).toBe(-456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("789   ")).toBe(789);
-    });
-    test("should handle strings with only plus sign", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+123")).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+0")).toBe(0);
-    });
-    test("should handle strings with invalid exponential notation", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e")).toBe(1);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("e10")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("2e+")).toBe(2);
-    });
-    test("should handle strings with only decimal point", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-.")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".e1")).toBe(Number.NaN);
-    });
-    test("should handle strings that don't start with a number", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("px42")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("meter3.14")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(Number.NaN);
-    });
-  });
-
-  // Special numeric input
-  describe("Special numeric input", function () {
-    test("should properly handle Infinity", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("Infinity")).toBe(Number.POSITIVE_INFINITY);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-Infinity")).toBe(Number.NEGATIVE_INFINITY);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
-    });
-    test("should handle NaN input", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.NaN)).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("NaN")).toBe(Number.NaN);
-    });
-    test("should properly handle very large numbers", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("9007199254740991")).toBe(9007199254740991);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e308")).toBe(1e308);
-    });
-    test("should properly handle very small numbers", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_VALUE)).toBe(Number.MIN_VALUE);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("5e-324")).toBe(5e-324);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-1e-308")).toBe(-1e-308);
-    });
-  });
-
-  // Invalid or special input
-  describe("Invalid or special input", function () {
-    test("should treat empty string, null, undefined as 0", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("")).toBe(0);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(null)).toBe(0);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(undefined)).toBe(0);
-    });
-    test("should return NaN for invalid strings", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("not a number")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(Number.NaN);
-    });
-    test("should return NaN for objects and arrays", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)({})).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)({
-        key: "value"
-      })).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([])).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([1, 2, 3])).toBe(Number.NaN);
-    });
-    test("should return NaN for functions", function () {
-      var func = function func() {};
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(func)).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(Number.NaN);
-    });
-    test("should return NaN for strings with special characters", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("@123")).toBe(Number.NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("!@#$%")).toBe(Number.NaN);
-    });
-  });
-
-  // Complex cases
-  describe("Complex cases", function () {
-    test("should extract leading number from strings with mixed numbers and characters", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("42px")).toBe(42);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-42px")).toBe(-42);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14meters")).toBe(3.14);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-3.14meters")).toBe(-3.14);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e10meters")).toBe(1e10);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-1e10meters")).toBe(-1e10);
-    });
-    test("should properly handle strings with internal spaces", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" 123 456 ")).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" -456px ")).toBe(-456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14 meters")).toBe(3.14);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e2 meters")).toBe(100);
-    });
-    test("should properly handle numbers with leading zeros", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0123")).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-0456")).toBe(-456);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("000789")).toBe(789);
-    });
-    test("should properly handle numbers with leading plus sign", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+123")).toBe(123);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+0")).toBe(0);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+3.14")).toBe(3.14);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+1e10")).toBe(1e10);
-    });
-  });
-
-  // Performance and stress tests
-  describe("Performance and stress tests", function () {
-    test("should handle large sequences of valid inputs", function () {
-      for (var i = 0; i < 1000; i++) {
-        expect((0, _flexibleNumberConversion.flexibleNumberConversion)(i.toString())).toBe(i);
-      }
-    });
-    test("should handle large sequences of invalid inputs", function () {
-      for (var i = 0; i < 1000; i++) {
-        expect((0, _flexibleNumberConversion.flexibleNumberConversion)("invalid".concat(i))).toBe(Number.NaN);
-      }
-    });
-  });
-
-  // Boundary value tests
-  describe("Boundary value tests", function () {
-    test("should handle Number.MAX_VALUE", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_VALUE)).toBe(Number.MAX_VALUE);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1.7976931348623157e+308")).toBe(Number.MAX_VALUE);
-    });
-    test("should handle Number.MIN_VALUE", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_VALUE)).toBe(Number.MIN_VALUE);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("5e-324")).toBe(Number.MIN_VALUE);
-    });
-    test("should handle Number.MAX_SAFE_INTEGER", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("9007199254740991")).toBe(Number.MAX_SAFE_INTEGER);
-    });
-    test("should handle Number.MIN_SAFE_INTEGER", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_SAFE_INTEGER)).toBe(Number.MIN_SAFE_INTEGER);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-9007199254740991")).toBe(Number.MIN_SAFE_INTEGER);
-    });
-  });
-});

package/module/es5/tests/unit/Math/gcd.test.d.ts

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

package/module/es5/tests/unit/Math/gcd.test.js

@@ -1,35 +0,0 @@
-"use strict";
-
-var _gcd = require("@/Math/gcd");
-describe("gcd function", function () {
-  // Test with two positive integers
-  test("two positive integers", function () {
-    expect((0, _gcd.gcd)(56, 48)).toBe(8);
-  });
-
-  // Test with more than two positive integers
-  test("more than two positive integers", function () {
-    expect((0, _gcd.gcd)(56, 48, 32)).toBe(8);
-    expect((0, _gcd.gcd)(56, 48, 32, 24)).toBe(8);
-  });
-
-  // Test with zero
-  test("contains zero", function () {
-    expect((0, _gcd.gcd)(56, 0)).toBe(0);
-    expect((0, _gcd.gcd)(0, 56)).toBe(0);
-  });
-
-  // Test with one
-  test("contains one", function () {
-    expect((0, _gcd.gcd)(56, 1)).toBe(1);
-    expect((0, _gcd.gcd)(1, 56)).toBe(1);
-  });
-
-  // Test with negative numbers
-  test("contains negative numbers", function () {
-    expect((0, _gcd.gcd)(-56, 48)).toBe(8);
-    expect((0, _gcd.gcd)(56, -48)).toBe(8);
-    expect((0, _gcd.gcd)(-56, -48)).toBe(8);
-    expect((0, _gcd.gcd)(-56, 48, -32)).toBe(8);
-  });
-});

package/module/es5/tests/unit/Math/getDecimalLength.test.d.ts

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

package/module/es5/tests/unit/Math/getDecimalLength.test.js

@@ -1,44 +0,0 @@
-"use strict";
-
-var _getDecimalLength = require("@/Math/getDecimalLength");
-describe("getDecimalLength function", function () {
-  describe("integers", function () {
-    it("should return 0 for whole numbers", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(1)).toBe(0);
-      expect((0, _getDecimalLength.getDecimalLength)(100)).toBe(0);
-      expect((0, _getDecimalLength.getDecimalLength)(-42)).toBe(0);
-    });
-    it("should return 0 for whole numbers with .0", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(1.0)).toBe(0);
-      expect((0, _getDecimalLength.getDecimalLength)(42.0)).toBe(0);
-      expect((0, _getDecimalLength.getDecimalLength)(-1.0)).toBe(0);
-    });
-  });
-  describe("decimal numbers", function () {
-    it("should count decimal places correctly", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(1.1)).toBe(1);
-      expect((0, _getDecimalLength.getDecimalLength)(1.11)).toBe(2);
-      expect((0, _getDecimalLength.getDecimalLength)(1.123)).toBe(3);
-    });
-    it("should handle leading zeros in decimals", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(1.01)).toBe(2);
-      expect((0, _getDecimalLength.getDecimalLength)(1.001)).toBe(3);
-      expect((0, _getDecimalLength.getDecimalLength)(1.000001)).toBe(6);
-    });
-    it("should handle negative numbers with decimals", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(-1.1)).toBe(1);
-      expect((0, _getDecimalLength.getDecimalLength)(-0.01)).toBe(2);
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle zero", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(0)).toBe(0);
-      expect((0, _getDecimalLength.getDecimalLength)(0.0)).toBe(0);
-      expect((0, _getDecimalLength.getDecimalLength)(-0)).toBe(0);
-    });
-    it("should handle large decimal numbers", function () {
-      expect((0, _getDecimalLength.getDecimalLength)(123456.789)).toBe(3);
-      expect((0, _getDecimalLength.getDecimalLength)(-987654.321)).toBe(3);
-    });
-  });
-});

package/module/es5/tests/unit/Math/lcm.test.d.ts

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

package/module/es5/tests/unit/Math/lcm.test.js

@@ -1,43 +0,0 @@
-"use strict";
-
-var _lcm = require("@/Math/lcm");
-describe("lcm function", function () {
-  // Test with positive numbers
-  test("should handle positive numbers", function () {
-    expect((0, _lcm.lcm)(4, 5)).toBe(20);
-    expect((0, _lcm.lcm)(6, 8)).toBe(24);
-    expect((0, _lcm.lcm)(10, 15)).toBe(30);
-    expect((0, _lcm.lcm)(7, 11)).toBe(77);
-  });
-
-  // Test with zero
-  test("should handle zero values", function () {
-    expect((0, _lcm.lcm)(0, 5)).toBe(0);
-    expect((0, _lcm.lcm)(4, 0)).toBe(0);
-    expect((0, _lcm.lcm)(0, 0)).toBe(0);
-    expect((0, _lcm.lcm)(0, 10)).toBe(0);
-    expect((0, _lcm.lcm)(7, 0)).toBe(0);
-  });
-
-  // Test with one
-  test("should handle values with one", function () {
-    expect((0, _lcm.lcm)(1, 5)).toBe(5);
-    expect((0, _lcm.lcm)(4, 1)).toBe(4);
-    expect((0, _lcm.lcm)(1, 1)).toBe(1);
-    expect((0, _lcm.lcm)(1, 10)).toBe(10);
-    expect((0, _lcm.lcm)(7, 1)).toBe(7);
-  });
-
-  // Test with large numbers
-  test("should handle large numbers", function () {
-    expect((0, _lcm.lcm)(1000, 2000)).toBe(2000);
-    expect((0, _lcm.lcm)(12345, 67890)).toBe(55873470);
-  });
-
-  // Test with negative numbers
-  test("should handle negative numbers", function () {
-    expect((0, _lcm.lcm)(-4, 6)).toBe(12);
-    expect((0, _lcm.lcm)(4, -6)).toBe(12);
-    expect((0, _lcm.lcm)(-4, -6)).toBe(12);
-  });
-});

package/module/es5/tests/unit/Math/linearCongruentialGenerator.test.d.ts

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

package/module/es5/tests/unit/Math/linearCongruentialGenerator.test.js

@@ -1,25 +0,0 @@
-"use strict";
-
-var _linearCongruentialGenerator = require("@/Math/linearCongruentialGenerator");
-describe("linearCongruentialGenerator", function () {
-  it("should generate random numbers", function () {
-    var result = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(8, 13, 3, 5);
-    expect(result).toBeGreaterThanOrEqual(0);
-    expect(result).toBe(3);
-  });
-  it("should generate the same sequence for the same seed", function () {
-    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
-    var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
-    expect(result1).toBe(result2);
-  });
-  it("should generate different sequences for different seeds", function () {
-    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
-    var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(54321);
-    expect(result1).not.toBe(result2);
-  });
-  it("should generate numbers with custom parameters", function () {
-    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345, Math.pow(2, 31), 1103515245, 12345);
-    expect(result1).toBeGreaterThanOrEqual(0);
-    expect(result1).toBe(1406932606);
-  });
-});

package/module/es5/tests/unit/Math/mathConverter.test.d.ts

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

package/module/es5/tests/unit/Math/mathConverter.test.js

@@ -1,37 +0,0 @@
-"use strict";
-
-var _mathConverter = require("@/Math/mathConverter");
-describe("mathConverter function", function () {
-  // Test multiplication conversion
-  test("should convert multiplication", function () {
-    expect((0, _mathConverter.mathConverter)("1250*1250")).toBe("1500*1000+400*100+200*100+50*50");
-    expect((0, _mathConverter.mathConverter)("1350*1350")).toBe("1700*1000+600*100+400*100+200*100+50*50");
-    expect((0, _mathConverter.mathConverter)("1550*1550")).toBe("2100*1000+1000*100+800*100+600*100+400*100+200*100+50*50");
-  });
-
-  // Test exponentiation conversion
-  test("should convert exponentiation", function () {
-    expect((0, _mathConverter.mathConverter)("1250^2")).toBe("1500*1000+400*100+200*100+50*50");
-    expect((0, _mathConverter.mathConverter)("1350^2")).toBe("1700*1000+600*100+400*100+200*100+50*50");
-  });
-
-  // Test cases where no conversion is needed
-  test("should not convert when unnecessary", function () {
-    expect((0, _mathConverter.mathConverter)("1250")).toBe("1250");
-  });
-
-  // Test cases with multiple operands
-  test("should handle multiple operands", function () {
-    expect((0, _mathConverter.mathConverter)("1250+1250")).toBe("1250+1250");
-  });
-
-  // Test invalid inputs
-  test("should handle invalid input", function () {
-    expect((0, _mathConverter.mathConverter)("abc")).toBe("abc");
-  });
-
-  // Test when primary value is missing
-  test("should handle missing primary value", function () {
-    expect((0, _mathConverter.mathConverter)("0*0")).toBe("0*0");
-  });
-});

package/module/es5/tests/unit/Math/mathSeparator.test.d.ts

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