umt 2.3.0 → 2.4.0

package/module/es5/tests/unit/IP/ipToBinaryString.test.js

@@ -1,46 +0,0 @@
-"use strict";
-
-var _ipToBinaryString = require("@/IP/ipToBinaryString");
-describe("ipToBinaryString", function () {
-  describe("valid IP addresses", function () {
-    test.each([
-    // [IP address, expected binary string]
-    ["192.168.0.1", "11000000101010000000000000000001"],
-    // Common private network
-    ["0.0.0.0", "00000000000000000000000000000000"],
-    // All zeros
-    ["255.255.255.255", "11111111111111111111111111111111"],
-    // All ones
-    ["1.2.3.4", "00000001000000100000001100000100"],
-    // Single digit octets
-    ["10.0.0.1", "00001010000000000000000000000001"],
-    // Class A private
-    ["172.16.0.1", "10101100000100000000000000000001"],
-    // Class B private
-    ["127.0.0.1", "01111111000000000000000000000001"],
-    // Localhost
-    ["169.254.0.1", "10101001111111100000000000000001"] // Link-local
-    ])("should convert %s to binary", function (ip, expected) {
-      expect((0, _ipToBinaryString.ipToBinaryString)(ip)).toBe(expected);
-    });
-  });
-  describe("invalid IP addresses", function () {
-    test.each([[undefined, "IP address is required"], ["", "IP address is required"], ["192.168", "Invalid IP address format"], ["a.b.c.d", "Invalid IP address format"], ["256.1.2.3", "Invalid IP address format"], ["-1.1.1.1", "Invalid IP address format"], ["1.2.3.4.5", "Invalid IP address format"], ["192.168.1", "Invalid IP address format"], ["192.168.1.1.1", "Invalid IP address format"], ["192.168.1.", "Invalid IP address format"], ["192.168..1", "Invalid IP address format"], [".192.168.1", "Invalid IP address format"], ["192,168,1,1", "Invalid IP address format"], ["192.168.1.1.", "Invalid IP address format"], ["192.168.1.+1", "Invalid IP address format"], ["256.256.256.256", "Invalid IP address format"], ["999.999.999.999", "Invalid IP address format"]])("should throw error for %s: %s", function (ip, expectedError) {
-      expect(function () {
-        return (0, _ipToBinaryString.ipToBinaryString)(ip);
-      }).toThrow(expectedError);
-    });
-  });
-  describe("edge cases", function () {
-    test.each([
-    // [IP address, expected binary string]
-    ["0.0.0.0", "00000000000000000000000000000000"], ["1.1.1.1", "00000001000000010000000100000001"], ["255.255.255.255", "11111111111111111111111111111111"], ["128.0.0.0", "10000000000000000000000000000000"], ["0.255.0.255", "00000000111111110000000011111111"]])("should handle boundary values: %s", function (ip, expected) {
-      expect((0, _ipToBinaryString.ipToBinaryString)(ip)).toBe(expected);
-    });
-    test.each(["0000", "00.00", "0.0.0", "192.168.01.1", "192.168.1.01", "010.020.030.040"])("should reject IP with invalid format: %s", function (ip) {
-      expect(function () {
-        return (0, _ipToBinaryString.ipToBinaryString)(ip);
-      }).toThrow("Invalid IP address format");
-    });
-  });
-});

package/module/es5/tests/unit/IP/ipToLong.test.d.ts

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

package/module/es5/tests/unit/IP/ipToLong.test.js

@@ -1,34 +0,0 @@
-"use strict";
-
-var _ipToLong = require("@/IP/ipToLong");
-describe("ipToLong", function () {
-  describe("valid IP addresses", function () {
-    test.each([
-    // [IP address, expected long value]
-    ["192.168.0.1", 0xc0a80001],
-    // Common private network
-    ["128.0.0.1", 0x80000001],
-    // Class B start
-    ["10.0.0.1", 0x0a000001],
-    // Class A private
-    ["172.16.0.1", 0xac100001],
-    // Class B private
-    ["255.255.255.255", 0xffffffff],
-    // Maximum value
-    ["0.0.0.0", 0x00000000],
-    // Minimum value
-    ["127.0.0.1", 0x7f000001],
-    // Localhost
-    ["1.2.3.4", 0x01020304] // Simple incremental
-    ])("should convert %s to %i", function (ip, expected) {
-      expect((0, _ipToLong.ipToLong)(ip)).toBe(expected);
-    });
-  });
-  describe("invalid IP addresses", function () {
-    test.each([[undefined, "IP address is required"], ["", "IP address is required"], ["192.168", "Invalid IP address format"], ["256.1.2.3", "Invalid IP address format"], ["a.b.c.d", "Invalid IP address format"], ["-1.0.0.0", "Invalid IP address format"], ["192.168.1.1.1", "Invalid IP address format"], ["192.168..1", "Invalid IP address format"]])("should throw error for %s: %s", function (ip, expectedError) {
-      expect(function () {
-        return (0, _ipToLong.ipToLong)(ip);
-      }).toThrow(expectedError);
-    });
-  });
-});

package/module/es5/tests/unit/IP/isInRange.test.d.ts

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

package/module/es5/tests/unit/IP/isInRange.test.js

@@ -1,82 +0,0 @@
-"use strict";
-
-var _isInRange = require("@/IP/isInRange");
-describe("isInRange", function () {
-  describe("valid IP ranges", function () {
-    test.each([
-    // [remoteIp, networkIp, cidr, expected]
-    ["192.168.1.2", "192.168.1.0", 24, true],
-    // Common class C network
-    ["192.168.2.2", "192.168.1.0", 24, false],
-    // Outside class C network
-    ["10.0.0.5", "10.0.0.0", 8, true],
-    // Class A network
-    ["11.0.0.5", "10.0.0.0", 8, false],
-    // Outside class A network
-    ["172.16.1.1", "172.16.0.0", 16, true],
-    // Class B network
-    ["172.17.1.1", "172.16.0.0", 16, false],
-    // Outside class B network
-    ["192.168.1.0", "192.168.1.0", 32, true],
-    // Single host network - exact match
-    ["192.168.1.1", "192.168.1.1", 32, true],
-    // Single host network - exact match
-    ["192.168.1.1", "192.168.1.0", 32, false],
-    // Single host network - different IP
-    ["192.168.1.1", "192.168.1.0", 30, true],
-    // Small subnet
-    ["192.168.1.4", "192.168.1.0", 30, false],
-    // Outside small subnet
-    ["0.0.0.1", "0.0.0.0", 0, true],
-    // All IPs in range (CIDR 0)
-    ["255.255.255.255", "0.0.0.0", 0, true] // All IPs in range (CIDR 0)
-    ])("should evaluate if %s is in network %s/%i => %s", function (remoteIp, networkIp, cidr, expected) {
-      expect((0, _isInRange.isInRange)(remoteIp, networkIp, cidr)).toBe(expected);
-    });
-    test.each([
-    // [remoteIp, networkIp, cidr, description]
-    ["192.168.1.1", "0.0.0.0", 0, "CIDR 0: all IPs in range"], ["192.168.1.0", "192.168.1.0", 32, "CIDR 32: exact match only"], ["192.168.1.1", "192.168.1.0", 31, "CIDR 31: two IPs"], ["192.168.1.1", "192.168.1.0", 1, "CIDR 1: half of all IPs"]])("should handle %s (%s)", function (ip, network, cidr) {
-      expect((0, _isInRange.isInRange)(ip, network, cidr)).toBe(true);
-    });
-    test("should correctly handle edge cases with specific CIDR masks", function () {
-      expect((0, _isInRange.isInRange)("192.168.1.5", "192.168.1.0", 24)).toBe(true);
-      expect((0, _isInRange.isInRange)("192.168.2.0", "192.168.1.0", 24)).toBe(false);
-      expect((0, _isInRange.isInRange)("192.168.1.0", "192.168.1.0", 31)).toBe(true);
-      expect((0, _isInRange.isInRange)("192.168.1.1", "192.168.1.0", 31)).toBe(true);
-      expect((0, _isInRange.isInRange)("192.168.1.2", "192.168.1.0", 31)).toBe(false);
-      expect((0, _isInRange.isInRange)("192.168.1.3", "192.168.1.0", 30)).toBe(true);
-      expect((0, _isInRange.isInRange)("192.168.1.4", "192.168.1.4", 30)).toBe(true);
-    });
-  });
-  describe("invalid inputs", function () {
-    test.each([[undefined, "192.168.1.0", 24, "Remote IP address is required"], ["192.168.1.1", undefined, 24, "Network IP address is required"], ["", "192.168.1.0", 24, "Remote IP address is required"], ["192.168.1.1", "", 24, "Network IP address is required"], ["192.168.1.1", "192.168.1.0", undefined, "CIDR must be an integer between 0 and 32"], ["192.168.1.1", "192.168.1.0", -1, "CIDR must be an integer between 0 and 32"], ["192.168.1.1", "192.168.1.0", 33, "CIDR must be an integer between 0 and 32"], ["192.168.1.1", "192.168.1.0", 1.5, "CIDR must be an integer between 0 and 32"]])("should throw error for remoteIp=%s, networkIp=%s, cidr=%s", function (remoteIp, networkIp, cidr, expectedError) {
-      expect(function () {
-        return (0, _isInRange.isInRange)(remoteIp, networkIp, cidr);
-      }).toThrow(expectedError);
-    });
-  });
-  describe("invalid IP formats", function () {
-    test.each([["invalid", "192.168.1.0", 24], ["192.168.1.1", "invalid", 24], ["256.256.256.256", "192.168.1.0", 24], ["192.168.1.1", "256.256.256.256", 24], ["192.168.1.1.1", "192.168.1.0", 24], ["192.168.-1.1", "192.168.1.0", 24], ["192.168.1", "192.168.1.0", 24]])("should throw for invalid IP format: %s", function (remoteIp, networkIp, cidr) {
-      expect(function () {
-        return (0, _isInRange.isInRange)(remoteIp, networkIp, cidr);
-      }).toThrow("Invalid IP address format");
-    });
-  });
-  describe("error message formatting", function () {
-    test("should format error messages correctly with String(error) for invalid IP", function () {
-      expect(function () {
-        return (0, _isInRange.isInRange)("invalid-ip", "192.168.1.0", 24);
-      }).toThrow("Invalid IP address format: Error: Invalid IP address format");
-    });
-    test("should format error messages correctly for invalid network IP", function () {
-      expect(function () {
-        return (0, _isInRange.isInRange)("192.168.1.1", "invalid-network", 24);
-      }).toThrow("Invalid IP address format: Error: Invalid IP address format");
-    });
-    test("should format error messages for out-of-range IP values", function () {
-      expect(function () {
-        return (0, _isInRange.isInRange)("999.999.999.999", "192.168.1.0", 24);
-      }).toThrow("Invalid IP address format: Error: Invalid IP address format");
-    });
-  });
-});

package/module/es5/tests/unit/IP/isPrivateIp.test.d.ts

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

package/module/es5/tests/unit/IP/isPrivateIp.test.js

@@ -1,26 +0,0 @@
-"use strict";
-
-var _isPrivateIp = require("@/IP/isPrivateIp");
-describe("isPrivateIp", function () {
-  describe("private IP addresses", function () {
-    test.each([
-    // [IP address, description]
-    ["10.0.0.1", "Class A private - start range"], ["10.255.255.255", "Class A private - end range"], ["172.16.0.1", "Class B private - start range"], ["172.31.255.255", "Class B private - end range"], ["192.168.0.1", "Class C private - start range"], ["192.168.255.255", "Class C private - end range"]])("should identify %s as private IP (%s)", function (ip) {
-      expect((0, _isPrivateIp.isPrivateIp)(ip)).toBe(true);
-    });
-  });
-  describe("non-private IP addresses", function () {
-    test.each([
-    // [IP address, description]
-    ["9.255.255.255", "Just before Class A private"], ["11.0.0.0", "Just after Class A private"], ["172.15.255.255", "Just before Class B private"], ["172.32.0.0", "Just after Class B private"], ["192.167.255.255", "Just before Class C private"], ["192.169.0.0", "Just after Class C private"], ["8.8.8.8", "Google DNS"], ["1.1.1.1", "Cloudflare DNS"], ["169.254.0.1", "Link-local address"], ["127.0.0.1", "Localhost"]])("should identify %s as non-private IP (%s)", function (ip) {
-      expect((0, _isPrivateIp.isPrivateIp)(ip)).toBe(false);
-    });
-  });
-  describe("invalid inputs", function () {
-    test.each([[undefined, "IP address is required"], ["", "IP address is required"], ["256.256.256.256", "Invalid IP address"], ["192.168", "Invalid IP address"], ["a.b.c.d", "Invalid IP address"], ["192.168.1.1.1", "Invalid IP address"], ["-1.0.0.0", "Invalid IP address"]])("should throw error for %s: %s", function (ip, expectedError) {
-      expect(function () {
-        return (0, _isPrivateIp.isPrivateIp)(ip);
-      }).toThrow(expectedError);
-    });
-  });
-});

package/module/es5/tests/unit/IP/longToIp.test.d.ts

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

package/module/es5/tests/unit/IP/longToIp.test.js

@@ -1,39 +0,0 @@
-"use strict";
-
-var _longToIp = require("@/IP/longToIp");
-describe("longToIp", function () {
-  describe("valid 32-bit integers", function () {
-    test.each([
-    // [long value, expected IP]
-    [0xc0a80001, "192.168.0.1"],
-    // Common private network
-    [0x80000001, "128.0.0.1"],
-    // Class B start
-    [0x0a000001, "10.0.0.1"],
-    // Class A private
-    [0xac100001, "172.16.0.1"],
-    // Class B private
-    [0xffffffff, "255.255.255.255"],
-    // Maximum value
-    [0x00000000, "0.0.0.0"],
-    // Minimum value
-    [0x7f000001, "127.0.0.1"],
-    // Localhost
-    [0x01020304, "1.2.3.4"] // Simple incremental
-    ])("should convert %i to %s", function (_long, expected) {
-      expect((0, _longToIp.longToIp)(_long)).toBe(expected);
-    });
-  });
-  describe("invalid inputs", function () {
-    test.each([[undefined, "Input must be a valid 32-bit unsigned integer"], [null, "Input must be a valid 32-bit unsigned integer"], [Number.NaN, "Input must be a valid 32-bit unsigned integer"], [Number.POSITIVE_INFINITY, "Input must be a valid 32-bit unsigned integer"], [-1, "Input must be a valid 32-bit unsigned integer"], [0x100000000, "Input must be a valid 32-bit unsigned integer"],
-    // Too large
-    [1.5, "Input must be a valid 32-bit unsigned integer"],
-    // Not an integer
-    ["123", "Input must be a valid 32-bit unsigned integer"] // Wrong type
-    ])("should throw error for %p: %s", function (input, expectedError) {
-      expect(function () {
-        return (0, _longToIp.longToIp)(input);
-      }).toThrow(expectedError);
-    });
-  });
-});

package/module/es5/tests/unit/IP/subnetMaskToCidr.test.d.ts

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

package/module/es5/tests/unit/IP/subnetMaskToCidr.test.js

@@ -1,41 +0,0 @@
-"use strict";
-
-var _subnetMaskToCidr = require("@/IP/subnetMaskToCidr");
-describe("subnetMaskToCidr", function () {
-  describe("valid subnet masks", function () {
-    test.each([
-    // [subnet mask, expected CIDR]
-    ["255.255.255.255", 32],
-    // All bits set
-    ["255.255.255.0", 24],
-    // Common /24 network
-    ["255.255.0.0", 16],
-    // Common /16 network
-    ["255.0.0.0", 8],
-    // Common /8 network
-    ["255.255.254.0", 23],
-    // Less common /23 network
-    ["255.255.255.252", 30],
-    // Small /30 network
-    ["255.255.255.248", 29],
-    // Small /29 network
-    ["255.255.240.0", 20],
-    // Medium /20 network
-    ["0.0.0.0", 0] // No bits set
-    ])("should convert %s to /%i", function (mask, expected) {
-      expect((0, _subnetMaskToCidr.subnetMaskToCidr)(mask)).toBe(expected);
-    });
-  });
-  describe("invalid subnet masks", function () {
-    test.each([[undefined, "Subnet mask is required"], ["", "Subnet mask is required"], ["192.168", "Invalid subnet mask format"], ["256.255.255.0", "Invalid subnet mask format"], ["255.255.255.256", "Invalid subnet mask format"], ["255.-1.255.0", "Invalid subnet mask format"], ["255.255.255.abc", "Invalid subnet mask format"], ["a.b.c.d", "Invalid subnet mask format"], ["255.255.255.1", "Invalid subnet mask: must be consecutive 1s followed by 0s"],
-    // Non-continuous mask
-    ["255.0.255.0", "Invalid subnet mask: must be consecutive 1s followed by 0s"],
-    // Non-continuous mask
-    ["254.255.255.0", "Invalid subnet mask: must be consecutive 1s followed by 0s"] // Invalid bit pattern
-    ])("should throw error for %s: %s", function (mask, expectedError) {
-      expect(function () {
-        return (0, _subnetMaskToCidr.subnetMaskToCidr)(mask);
-      }).toThrow(expectedError);
-    });
-  });
-});

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

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

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

@@ -1,79 +0,0 @@
-"use strict";
-
-var _addition = require("@/Math/addition");
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-describe("addition", function () {
-  var testCases = [{
-    args: [2, 3],
-    expected: 5
-  }, {
-    args: [-2, -3],
-    expected: -5
-  }, {
-    args: [2, -3],
-    expected: -1
-  }, {
-    args: [0.1, 0.2],
-    expected: 0.3,
-    closeTo: true
-  }, {
-    args: [-0.1, -0.2],
-    expected: -0.3,
-    closeTo: true
-  }, {
-    args: [0.1, -0.2],
-    expected: -0.1,
-    closeTo: true
-  }, {
-    args: [2, 0.3],
-    expected: 2.3,
-    closeTo: true
-  }, {
-    args: [-2, -0.3],
-    expected: -2.3,
-    closeTo: true
-  }, {
-    args: [2, -0.3],
-    expected: 1.7,
-    closeTo: true
-  }, {
-    args: [-2, 0.3],
-    expected: -1.7,
-    closeTo: true
-  }, {
-    args: [1, 2, 3],
-    expected: 6
-  }, {
-    args: [-1, -2, -3],
-    expected: -6
-  }, {
-    args: [0.1, 0.2, 0.3],
-    expected: 0.6,
-    closeTo: true
-  }, {
-    args: [2, -3, 1],
-    expected: 0
-  }, {
-    args: [-2, 0.5, 1.5],
-    expected: 0,
-    closeTo: true
-  }];
-  testCases.forEach(function (_ref) {
-    var args = _ref.args,
-      expected = _ref.expected,
-      closeTo = _ref.closeTo;
-    it("should add ".concat(args.length, " numbers: ").concat(args.join(", ")), function () {
-      var result = _addition.addition.apply(void 0, _toConsumableArray(args));
-      if (closeTo) {
-        expect(result).toBeCloseTo(expected);
-      } else {
-        expect(result).toBe(expected);
-      }
-    });
-  });
-});

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

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

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

@@ -1,48 +0,0 @@
-"use strict";
-
-var _average = require("@/Math/average");
-describe("average function", function () {
-  describe("basic scenarios", function () {
-    it("should calculate average of integer numbers", function () {
-      expect((0, _average.average)([1, 2])).toBe(1.5);
-      expect((0, _average.average)([1, 2, 3, 4, 5])).toBe(3);
-    });
-    it("should calculate average of decimal numbers", function () {
-      expect((0, _average.average)([1.1, 2.2])).toBeCloseTo(1.65);
-      expect((0, _average.average)([1.1, 2.2, 3.3, 4.4, 5.5])).toBeCloseTo(3.3);
-    });
-    it("should handle single element arrays", function () {
-      expect((0, _average.average)([5])).toBe(5);
-      expect((0, _average.average)([3.14])).toBe(3.14);
-    });
-  });
-  describe("special cases", function () {
-    it("should handle arrays with zeros", function () {
-      expect((0, _average.average)([0, 0, 0])).toBe(0);
-      expect((0, _average.average)([1, 0, 2, 0, 3])).toBe(1.2);
-    });
-    it("should handle negative numbers", function () {
-      expect((0, _average.average)([-1, -2])).toBe(-1.5);
-      expect((0, _average.average)([-10, -20, -30])).toBe(-20);
-    });
-    it("should handle mixed positive and negative numbers", function () {
-      expect((0, _average.average)([-1, 1])).toBe(0);
-      expect((0, _average.average)([-10, 10, -5, 5])).toBe(0);
-    });
-    it("should return 0 for empty arrays", function () {
-      expect((0, _average.average)([])).toBe(0);
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle large numbers", function () {
-      expect((0, _average.average)([Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER])).toBe(Number.MAX_SAFE_INTEGER);
-    });
-    it("should handle small numbers", function () {
-      expect((0, _average.average)([Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER])).toBe(Number.MIN_SAFE_INTEGER);
-    });
-    it("should handle large arrays", function () {
-      var largeArray = new Array(10000).fill(1);
-      expect((0, _average.average)(largeArray)).toBe(1);
-    });
-  });
-});

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

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

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

@@ -1,62 +0,0 @@
-"use strict";
-
-var _bitwise = require("@/Math/bitwise");
-describe("bitwise", function () {
-  it("should rotate 8 bits to the left", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 8);
-    expect(result.toString(16)).toBe("34567812");
-  });
-  it("should rotate 16 bits to the left", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 16);
-    expect(result.toString(16)).toBe("56781234");
-  });
-  it("should rotate 24 bits to the left", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 24);
-    expect(result.toString(16)).toBe("78123456");
-  });
-  it("should rotate 32 bits to the left (same as original value)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 32);
-    expect(result.toString(16)).toBe("12345678");
-  });
-  it("should rotate 0 bits to the left (same as original value)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 0);
-    expect(result.toString(16)).toBe("12345678");
-  });
-  it("should handle negative bit count (same as right rotation)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, -8);
-    expect(result.toString(16)).toBe("78123456");
-  });
-  it("should handle bit count over 32 (rotate by remainder when divided by 32)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 40); // 40 % 32 = 8
-    expect(result.toString(16)).toBe("34567812");
-  });
-  it("should rotate 8 bits to the right", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 8, "right");
-    expect(result.toString(16)).toBe("78123456");
-  });
-  it("should rotate 16 bits to the right", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 16, "right");
-    expect(result.toString(16)).toBe("56781234");
-  });
-  it("should rotate 24 bits to the right", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 24, "right");
-    expect(result.toString(16)).toBe("34567812");
-  });
-  it("should rotate 32 bits to the right (same as original value)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 32, "right");
-    expect(result.toString(16)).toBe("12345678");
-  });
-  it("should rotate 0 bits to the right (same as original value)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 0, "right");
-    expect(result.toString(16)).toBe("12345678");
-  });
-  it("should handle bit count over 32 (rotate by remainder when divided by 32)", function () {
-    var result = (0, _bitwise.bitwise)(0x12345678, 40, "right"); // 40 % 32 = 8
-    expect(result.toString(16)).toBe("78123456");
-  });
-  it("should throw error for invalid direction", function () {
-    expect(function () {
-      return (0, _bitwise.bitwise)(0x12345678, 8, "invalid");
-    }).toThrowError("Invalid direction");
-  });
-});

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

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

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

@@ -1,76 +0,0 @@
-"use strict";
-
-var _calculator = require("@/Math/calculator");
-describe("calculator function", function () {
-  // Addition
-  test("should handle addition", function () {
-    expect((0, _calculator.calculator)("1+")).toBe("1+");
-    expect((0, _calculator.calculator)("1+1")).toBe("2");
-    expect((0, _calculator.calculator)("1+1+1")).toBe("3");
-    expect((0, _calculator.calculator)("1+1+1+1")).toBe("4");
-    expect((0, _calculator.calculator)("1+1+1+1+1")).toBe("5");
-  });
-
-  // Subtraction
-  test("should handle subtraction", function () {
-    expect((0, _calculator.calculator)("1-")).toBe("1-");
-    expect((0, _calculator.calculator)("1-1")).toBe("0");
-    expect((0, _calculator.calculator)("1-1-1")).toBe("-1");
-    expect((0, _calculator.calculator)("1-1-1-1")).toBe("-2");
-    expect((0, _calculator.calculator)("1-1-1-1-1")).toBe("-3");
-  });
-
-  // Multiplication
-  test("should handle multiplication", function () {
-    expect((0, _calculator.calculator)("2*")).toBe("2*");
-    expect((0, _calculator.calculator)("2*2")).toBe("4");
-    expect((0, _calculator.calculator)("2*2*2")).toBe("8");
-    expect((0, _calculator.calculator)("2*2*2*2")).toBe("16");
-    expect((0, _calculator.calculator)("2*2*2*2*2")).toBe("32");
-  });
-
-  // Division
-  test("should handle division", function () {
-    expect((0, _calculator.calculator)("2/")).toBe("2/");
-    expect((0, _calculator.calculator)("2/2")).toBe("1");
-    expect((0, _calculator.calculator)("2/2/2")).toBe("0.5");
-    expect((0, _calculator.calculator)("2/2/2/2")).toBe("0.25");
-    expect((0, _calculator.calculator)("2/2/2/2/2")).toBe("0.125");
-  });
-
-  // Exponentiation
-  test("should handle exponentiation", function () {
-    expect((0, _calculator.calculator)("2^")).toBe("2^");
-    expect((0, _calculator.calculator)("2^2")).toBe("4");
-    expect((0, _calculator.calculator)("2^2^2")).toBe("16");
-    expect((0, _calculator.calculator)("2^2^2^2")).toBe("65536");
-    expect((0, _calculator.calculator)("2^2^2^2^2")).toBe("Infinity");
-    expect((0, _calculator.calculator)("3^4")).toBe("81");
-    expect((0, _calculator.calculator)("3^4^2")).toBe("43046721");
-  });
-
-  // Parentheses
-  test("should handle parentheses", function () {
-    expect((0, _calculator.calculator)("(1+1)")).toBe("2");
-    expect((0, _calculator.calculator)("(1")).toBe("(1");
-    expect((0, _calculator.calculator)("(1+")).toBe("(1+");
-    expect((0, _calculator.calculator)("1)")).toBe("1)");
-    expect((0, _calculator.calculator)("(1)")).toBe("(1)");
-    expect((0, _calculator.calculator)("(1+1)+(1+1)")).toBe("4");
-  });
-
-  // Equations
-  test("should handle equations", function () {
-    expect((0, _calculator.calculator)("2x=(1+1)+(1+1)+(1+1)")).toBe("3");
-  });
-
-  // Variables and currency conversion
-  test("should handle variables", function () {
-    expect((0, _calculator.calculator)("$10*2", {
-      $: 100
-    })).toBe("2000");
-    expect((0, _calculator.calculator)("2*$10", {
-      $: 100
-    })).toBe("2000");
-  });
-});

package/module/es5/tests/unit/Math/calculator/calculatorInitialization.test.d.ts

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

package/module/es5/tests/unit/Math/calculator/calculatorInitialization.test.js

@@ -1,21 +0,0 @@
-"use strict";
-
-var _calculatorInitialization = require("@/Math/calculator/calculatorInitialization");
-describe("calculatorInitialization function", function () {
-  it("should initialize a calculator with exchange rates", function () {
-    var calculator = (0, _calculatorInitialization.calculatorInitialization)({
-      $: 100
-    });
-    expect(calculator("$1")).toBe("100");
-    expect(calculator("100 + $1")).toBe("200");
-  });
-  it("should handle multiple exchange rates", function () {
-    var calculator = (0, _calculatorInitialization.calculatorInitialization)({
-      $: 100,
-      EUR: 120
-    });
-    expect(calculator("$1")).toBe("100");
-    expect(calculator("EUR1")).toBe("120");
-    expect(calculator("$1 + EUR1")).toBe("220");
-  });
-});

package/module/es5/tests/unit/Math/calculator/convertCurrency.test.d.ts

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

package/module/es5/tests/unit/Math/calculator/convertCurrency.test.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var _convertCurrency = require("@/Math/calculator/convertCurrency");
-/**
- * Tests for the convertCurrency function
- */
-describe("convertCurrency function", function () {
-  // Case 1: No conversion rates provided
-  test("should return original string when conversionRates is undefined", function () {
-    expect((0, _convertCurrency.convertCurrency)("¥1000")).toBe("¥1000");
-  });
-
-  // Case 2: Currency symbol doesn't match
-  test("should return original string when currency symbol doesn't match", function () {
-    expect((0, _convertCurrency.convertCurrency)("¥1000", {
-      $: 1.1
-    })).toBe("¥1000");
-  });
-
-  // Case 3: Currency symbol matches and conversion rate is a number
-  test("should convert currency when symbol matches and rate is a number", function () {
-    expect((0, _convertCurrency.convertCurrency)("¥1000", {
-      "¥": 1.1
-    })).toBe("1100");
-  });
-
-  // Case 4: Currency symbol matches but conversion rate is not a number
-  test("should return original string when rate is not a number", function () {
-    expect((0, _convertCurrency.convertCurrency)("¥1000", {
-      "¥": "invalid"
-    })).toBe("¥1000");
-  });
-
-  // Case 5: Conversion result is NaN
-  test("should return original string when conversion result is NaN", function () {
-    expect((0, _convertCurrency.convertCurrency)("¥NaN", {
-      "¥": 1.1
-    })).toBe("¥NaN");
-  });
-});

package/module/es5/tests/unit/Math/calculator/literalExpression.test.d.ts

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