From 64c0c97973655ff24377cc599f213705c1fd2a0e Mon Sep 17 00:00:00 2001 From: atsiv sivat Date: Sat, 21 Mar 2026 18:51:36 +0000 Subject: [PATCH] fix: lint --- src/core/Utils.mjs | 2 +- src/core/lib/IEEEBinary.mjs | 18 +++++++++-- src/core/operations/FromIEEEBinary.mjs | 23 ++++++++------ src/core/operations/ToIEEEBinary.mjs | 22 ++++++------- tests/node/tests/lib/BigIntUtils.mjs | 44 +++++++++++++------------- 5 files changed, 62 insertions(+), 47 deletions(-) diff --git a/src/core/Utils.mjs b/src/core/Utils.mjs index 51f35725..d15871e0 100755 --- a/src/core/Utils.mjs +++ b/src/core/Utils.mjs @@ -1272,7 +1272,7 @@ class Utils { * @returns {BigInt} */ static gcdBigInt(a, b) { - return b === 0n ? a : Utils.gcdBigInt(b, a % b); + return b === 0n ? a : Utils.gcdBigInt(b, a % b); } diff --git a/src/core/lib/IEEEBinary.mjs b/src/core/lib/IEEEBinary.mjs index 4f5096ce..59ec3f03 100644 --- a/src/core/lib/IEEEBinary.mjs +++ b/src/core/lib/IEEEBinary.mjs @@ -22,12 +22,18 @@ const MAX_EXP = (1n << EXP_BITS) - 1n; const EXP_BITS_NUM = Number(EXP_BITS); const MANT_BITS_NUM = Number(MANT_BITS); +/** + * + */ function normaliseInput(input) { if (input === null || input === undefined) throw new Error("Invalid decimal number"); return String(input).trim(); } +/** + * + */ function safeBigInt(str, context="number") { try { return BigInt(str); @@ -36,22 +42,28 @@ function safeBigInt(str, context="number") { } } +/** + * + */ function validateDecimal(input) { // validates optional-sign base-10 decimal input: integers, decimals with optional digits before or after the decimal point, and scientific notation if (!/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(input)) throw new Error("Invalid decimal number"); } +/** + * + */ function validateBinary64(input) { input = normaliseInput(input); if (!/^[01\s]+$/.test(input)) throw new Error("Binary64 must contain only 0 and 1"); - if (input.replace(/\s+/g,"").length !== 64) + if (input.replace(/\s+/g, "").length !== 64) throw new Error("Binary64 must be exactly 64 bits"); - return input.replace(/\s+/g,""); + return input.replace(/\s+/g, ""); } @@ -256,7 +268,7 @@ export function ToIEEE754Float64(input) { let D = 1n; if (fracStr.length > 0) { - const pow10 = pow10BigInt(BigInt(fracStr.length)); + const pow10 = pow10BigInt(BigInt(fracStr.length)); N = N * pow10 + safeBigInt(fracStr, "fractional part"); D = pow10; } diff --git a/src/core/operations/FromIEEEBinary.mjs b/src/core/operations/FromIEEEBinary.mjs index 7417108f..141a7392 100644 --- a/src/core/operations/FromIEEEBinary.mjs +++ b/src/core/operations/FromIEEEBinary.mjs @@ -37,21 +37,24 @@ class FromIEEEBinary extends Operation { * @returns {string} */ + /** + * + */ run(input, args) { - if (input === null || input === undefined) - return ""; + if (input === null || input === undefined) + return ""; - input = String(input); + input = String(input); - if (input.trim().length === 0) - return ""; + if (input.trim().length === 0) + return ""; - try { - return FromIEEE754Float64(input); - } catch (err) { - throw new OperationError(err.message); + try { + return FromIEEE754Float64(input); + } catch (err) { + throw new OperationError(err.message); + } } -} } export default FromIEEEBinary; diff --git a/src/core/operations/ToIEEEBinary.mjs b/src/core/operations/ToIEEEBinary.mjs index 3faa7fb8..9d17fe21 100644 --- a/src/core/operations/ToIEEEBinary.mjs +++ b/src/core/operations/ToIEEEBinary.mjs @@ -35,22 +35,22 @@ class ToIEEEBinary extends Operation { * @param {Object[]} args * @returns {string} */ - run(input, args) { - if (input === null || input === undefined) - return ""; + run(input, args) { + if (input === null || input === undefined) + return ""; - input = String(input); + input = String(input); - if (input.trim().length === 0) - return ""; + if (input.trim().length === 0) + return ""; - try { - return ToIEEE754Float64(input); - } catch (err) { - throw new OperationError(err.message); + try { + return ToIEEE754Float64(input); + } catch (err) { + throw new OperationError(err.message); + } } -} } diff --git a/tests/node/tests/lib/BigIntUtils.mjs b/tests/node/tests/lib/BigIntUtils.mjs index d75a4893..2d9f2667 100644 --- a/tests/node/tests/lib/BigIntUtils.mjs +++ b/tests/node/tests/lib/BigIntUtils.mjs @@ -9,46 +9,46 @@ TestRegister.addApiTests([ const value = parseBigInt("1", "test value"); assert.deepStrictEqual(value, BigInt("1")); }), - + it("BigIntUtils: parseBigInt - large decimal", () => { const value = parseBigInt("123456789012345678901234567890", "test value"); assert.deepStrictEqual(value, BigInt("123456789012345678901234567890")); }), - + it("BigIntUtils: parseBigInt - hexadecimal lowercase", () => { const value = parseBigInt("0xff", "test value"); assert.deepStrictEqual(value, BigInt("255")); }), - + it("BigIntUtils: parseBigInt - hexadecimal uppercase", () => { const value = parseBigInt("0xFF", "test value"); assert.deepStrictEqual(value, BigInt("255")); }), - + it("BigIntUtils: parseBigInt - large hexadecimal", () => { const value = parseBigInt("0x123456789ABCDEF", "test value"); assert.deepStrictEqual(value, BigInt("0x123456789ABCDEF")); }), - + it("BigIntUtils: parseBigInt - whitespace trimming", () => { const value = parseBigInt(" 42 ", "test value"); assert.deepStrictEqual(value, BigInt("42")); }), - + it("BigIntUtils: parseBigInt - invalid input (text)", () => { assert.throws(() => parseBigInt("test", "test value"), { name: "Error", message: "test value must be decimal or hex (0x...)" }); }), - + it("BigIntUtils: parseBigInt - invalid input (hex without prefix)", () => { assert.throws(() => parseBigInt("FF", "test value"), { name: "Error", message: "test value must be decimal or hex (0x...)" }); }), - + it("BigIntUtils: parseBigInt - invalid input (mixed)", () => { assert.throws(() => parseBigInt("12abc", "test value"), { name: "Error", @@ -65,40 +65,40 @@ TestRegister.addApiTests([ const bezout2 = BigInt("1"); assert.deepStrictEqual(egcd(a, b), [gcd, bezout1, bezout2]); }), - + it("BigIntUtils: egcd - coprime numbers", () => { const [g, x, y] = egcd(BigInt("3"), BigInt("11")); assert.strictEqual(g, BigInt("1")); - // Verify Bézout identity: a*x + b*y = gcd + // Verify B�zout identity: a*x + b*y = gcd assert.strictEqual(BigInt("3") * x + BigInt("11") * y, g); }), - + it("BigIntUtils: egcd - non-coprime numbers", () => { const [g, x, y] = egcd(BigInt("240"), BigInt("46")); assert.strictEqual(g, BigInt("2")); - // Verify Bézout identity + // Verify B�zout identity assert.strictEqual(BigInt("240") * x + BigInt("46") * y, g); }), - + it("BigIntUtils: egcd - with zero", () => { const [g, x, y] = egcd(BigInt("17"), BigInt("0")); assert.strictEqual(g, BigInt("17")); assert.strictEqual(x, BigInt("1")); assert.strictEqual(y, BigInt("0")); }), - + it("BigIntUtils: egcd - identical numbers", () => { const [g, x, y] = egcd(BigInt("42"), BigInt("42")); assert.strictEqual(g, BigInt("42")); - // Verify Bézout identity + // Verify B�zout identity assert.strictEqual(BigInt("42") * x + BigInt("42") * y, g); }), - + it("BigIntUtils: egcd - large numbers", () => { const a = BigInt("123456789012345678901234567890"); const b = BigInt("987654321098765432109876543210"); const [g, x, y] = egcd(a, b); - // Verify Bézout identity + // Verify B�zout identity assert.strictEqual(a * x + b * y, g); }), @@ -108,7 +108,7 @@ TestRegister.addApiTests([ const result = modPow(BigInt("2"), BigInt("10"), BigInt("1000")); assert.strictEqual(result, BigInt("24")); }), - + it("BigIntUtils: modPow - RSA-like example", () => { // Common RSA public exponent const base = BigInt("123456789"); @@ -119,26 +119,26 @@ TestRegister.addApiTests([ assert(result < mod); assert(result >= BigInt("0")); }), - + it("BigIntUtils: modPow - exponent zero", () => { // Any number^0 = 1 const result = modPow(BigInt("999"), BigInt("0"), BigInt("100")); assert.strictEqual(result, BigInt("1")); }), - + it("BigIntUtils: modPow - base zero", () => { // 0^n = 0 const result = modPow(BigInt("0"), BigInt("5"), BigInt("100")); assert.strictEqual(result, BigInt("0")); }), - + it("BigIntUtils: modPow - large exponent", () => { // Test with very large exponent (efficient algorithm should handle this) const result = modPow(BigInt("3"), BigInt("1000000"), BigInt("1000000007")); assert(result >= BigInt("0")); assert(result < BigInt("1000000007")); }), - + it("BigIntUtils: modPow - modular inverse verification", () => { // If a*x . 1 (mod m), then modPow(a, 1, m) * x . 1 (mod m) const a = BigInt("3");