goscript 0.0.37 → 0.0.39

package/gs/math/hypot.gs.test.ts

@@ -1,73 +1,73 @@
-import { describe, it, expect } from 'vitest';
-import { Hypot, hypot } from './hypot.gs.js';
-import { Inf, NaN as GoNaN, IsNaN, IsInf } from './bits.gs.js';
+import { describe, it, expect } from 'vitest'
+import { Hypot, hypot } from './hypot.gs.js'
+import { Inf, NaN as GoNaN, IsNaN, IsInf } from './bits.gs.js'
 
 describe('Hypot', () => {
   it('should calculate hypotenuse correctly for basic cases', () => {
-    expect(Hypot(3, 4)).toBeCloseTo(5, 10);
-    expect(Hypot(5, 12)).toBeCloseTo(13, 10);
-    expect(Hypot(8, 15)).toBeCloseTo(17, 10);
-    expect(Hypot(1, 1)).toBeCloseTo(Math.sqrt(2), 10);
-  });
+    expect(Hypot(3, 4)).toBeCloseTo(5, 10)
+    expect(Hypot(5, 12)).toBeCloseTo(13, 10)
+    expect(Hypot(8, 15)).toBeCloseTo(17, 10)
+    expect(Hypot(1, 1)).toBeCloseTo(Math.sqrt(2), 10)
+  })
 
   it('should handle zero values', () => {
-    expect(Hypot(0, 0)).toBe(0);
-    expect(Hypot(0, 5)).toBe(5);
-    expect(Hypot(5, 0)).toBe(5);
-    expect(Hypot(0, -5)).toBe(5);
-    expect(Hypot(-5, 0)).toBe(5);
-  });
+    expect(Hypot(0, 0)).toBe(0)
+    expect(Hypot(0, 5)).toBe(5)
+    expect(Hypot(5, 0)).toBe(5)
+    expect(Hypot(0, -5)).toBe(5)
+    expect(Hypot(-5, 0)).toBe(5)
+  })
 
   it('should handle negative values', () => {
-    expect(Hypot(-3, 4)).toBeCloseTo(5, 10);
-    expect(Hypot(3, -4)).toBeCloseTo(5, 10);
-    expect(Hypot(-3, -4)).toBeCloseTo(5, 10);
-    expect(Hypot(-5, -12)).toBeCloseTo(13, 10);
-  });
+    expect(Hypot(-3, 4)).toBeCloseTo(5, 10)
+    expect(Hypot(3, -4)).toBeCloseTo(5, 10)
+    expect(Hypot(-3, -4)).toBeCloseTo(5, 10)
+    expect(Hypot(-5, -12)).toBeCloseTo(13, 10)
+  })
 
   it('should handle infinity cases', () => {
-    expect(Hypot(Inf(1), 5)).toBe(Inf(1));
-    expect(Hypot(5, Inf(1))).toBe(Inf(1));
-    expect(Hypot(Inf(-1), 5)).toBe(Inf(1));
-    expect(Hypot(5, Inf(-1))).toBe(Inf(1));
-    expect(Hypot(Inf(1), Inf(1))).toBe(Inf(1));
-    expect(Hypot(Inf(-1), Inf(-1))).toBe(Inf(1));
-  });
+    expect(Hypot(Inf(1), 5)).toBe(Inf(1))
+    expect(Hypot(5, Inf(1))).toBe(Inf(1))
+    expect(Hypot(Inf(-1), 5)).toBe(Inf(1))
+    expect(Hypot(5, Inf(-1))).toBe(Inf(1))
+    expect(Hypot(Inf(1), Inf(1))).toBe(Inf(1))
+    expect(Hypot(Inf(-1), Inf(-1))).toBe(Inf(1))
+  })
 
   it('should handle NaN cases', () => {
-    expect(IsNaN(Hypot(GoNaN(), 5))).toBe(true);
-    expect(IsNaN(Hypot(5, GoNaN()))).toBe(true);
-    expect(IsNaN(Hypot(GoNaN(), GoNaN()))).toBe(true);
-  });
+    expect(IsNaN(Hypot(GoNaN(), 5))).toBe(true)
+    expect(IsNaN(Hypot(5, GoNaN()))).toBe(true)
+    expect(IsNaN(Hypot(GoNaN(), GoNaN()))).toBe(true)
+  })
 
   it('should handle very large values without overflow', () => {
-    const large = 1e150;
-    const result = Hypot(large, large);
-    expect(result).toBeCloseTo(large * Math.sqrt(2), 5);
-    expect(IsInf(result, 0)).toBe(false);
-  });
+    const large = 1e150
+    const result = Hypot(large, large)
+    expect(result).toBeCloseTo(large * Math.sqrt(2), 5)
+    expect(IsInf(result, 0)).toBe(false)
+  })
 
   it('should handle very small values without underflow', () => {
-    const small = 1e-150;
-    const result = Hypot(small, small);
-    expect(result).toBeCloseTo(small * Math.sqrt(2), 160);
-    expect(result).toBeGreaterThan(0);
-  });
+    const small = 1e-150
+    const result = Hypot(small, small)
+    expect(result).toBeCloseTo(small * Math.sqrt(2), 160)
+    expect(result).toBeGreaterThan(0)
+  })
 
   it('should be commutative', () => {
-    expect(Hypot(3, 4)).toBe(Hypot(4, 3));
-    expect(Hypot(-3, 4)).toBe(Hypot(4, -3));
-    expect(Hypot(1.5, 2.5)).toBe(Hypot(2.5, 1.5));
-  });
-});
+    expect(Hypot(3, 4)).toBe(Hypot(4, 3))
+    expect(Hypot(-3, 4)).toBe(Hypot(4, -3))
+    expect(Hypot(1.5, 2.5)).toBe(Hypot(2.5, 1.5))
+  })
+})
 
 describe('hypot (lowercase)', () => {
   it('should work identically to Hypot', () => {
-    expect(hypot(3, 4)).toBe(Hypot(3, 4));
-    expect(hypot(5, 12)).toBe(Hypot(5, 12));
-    expect(hypot(0, 0)).toBe(Hypot(0, 0));
-    expect(hypot(-3, 4)).toBe(Hypot(-3, 4));
-    expect(hypot(Inf(1), 5)).toBe(Hypot(Inf(1), 5));
-    expect(IsNaN(hypot(GoNaN(), 5))).toBe(IsNaN(Hypot(GoNaN(), 5)));
-  });
-}); 
+    expect(hypot(3, 4)).toBe(Hypot(3, 4))
+    expect(hypot(5, 12)).toBe(Hypot(5, 12))
+    expect(hypot(0, 0)).toBe(Hypot(0, 0))
+    expect(hypot(-3, 4)).toBe(Hypot(-3, 4))
+    expect(hypot(Inf(1), 5)).toBe(Hypot(Inf(1), 5))
+    expect(IsNaN(hypot(GoNaN(), 5))).toBe(IsNaN(Hypot(GoNaN(), 5)))
+  })
+})

package/gs/math/index.ts

@@ -1,44 +1,80 @@
-export { Abs } from "./abs.gs.js"
-export { Acosh } from "./acosh.gs.js"
-export { Acos, Asin } from "./asin.gs.js"
-export { Asinh } from "./asinh.gs.js"
-export { Atan } from "./atan.gs.js"
-export { Atan2 } from "./atan2.gs.js"
-export { Atanh } from "./atanh.gs.js"
-export { Inf, IsInf, IsNaN, NaN } from "./bits.gs.js"
-export { Cbrt } from "./cbrt.gs.js"
-export { E, Ln10, Ln2, Log10E, Log2E, MaxFloat32, MaxFloat64, MaxInt, MaxInt16, MaxInt32, MaxInt64, MaxInt8, MaxUint, MaxUint16, MaxUint32, MaxUint64, MaxUint8, MinInt, MinInt16, MinInt32, MinInt64, MinInt8, Phi, Pi, SmallestNonzeroFloat32, SmallestNonzeroFloat64, Sqrt2, SqrtE, SqrtPhi, SqrtPi } from "./const.gs.js"
-export { Copysign } from "./copysign.gs.js"
-export { Dim, Max, Min } from "./dim.gs.js"
-export { Erf, Erfc } from "./erf.gs.js"
-export { Erfcinv, Erfinv } from "./erfinv.gs.js"
-export { Exp, Exp2 } from "./exp.gs.js"
-export { Expm1 } from "./expm1.gs.js"
-export { Ceil, Floor, Round, RoundToEven, Trunc } from "./floor.gs.js"
-export { FMA } from "./fma.gs.js"
-export { Frexp } from "./frexp.gs.js"
-export { Gamma } from "./gamma.gs.js"
-export { Hypot } from "./hypot.gs.js"
-export { J0, Y0 } from "./j0.gs.js"
-export { J1, Y1 } from "./j1.gs.js"
-export { Jn, Yn } from "./jn.gs.js"
-export { Ldexp } from "./ldexp.gs.js"
-export { Lgamma } from "./lgamma.gs.js"
-export { Log } from "./log.gs.js"
-export { Log10, Log2 } from "./log10.gs.js"
-export { Log1p } from "./log1p.gs.js"
-export { Ilogb, Logb } from "./logb.gs.js"
-export { Mod } from "./mod.gs.js"
-export { Modf } from "./modf.gs.js"
-export { Nextafter, Nextafter32 } from "./nextafter.gs.js"
-export { Pow } from "./pow.gs.js"
-export { Pow10 } from "./pow10.gs.js"
-export { Remainder } from "./remainder.gs.js"
-export { Signbit } from "./signbit.gs.js"
-export { Cos, Sin } from "./sin.gs.js"
-export { Sincos } from "./sincos.gs.js"
-export { Cosh, Sinh } from "./sinh.gs.js"
-export { Sqrt } from "./sqrt.gs.js"
-export { Tan } from "./tan.gs.js"
-export { Tanh } from "./tanh.gs.js"
-export { Float32bits, Float32frombits, Float64bits, Float64frombits } from "./unsafe.gs.js"
+export { Abs } from './abs.gs.js'
+export { Acosh } from './acosh.gs.js'
+export { Acos, Asin } from './asin.gs.js'
+export { Asinh } from './asinh.gs.js'
+export { Atan } from './atan.gs.js'
+export { Atan2 } from './atan2.gs.js'
+export { Atanh } from './atanh.gs.js'
+export { Inf, IsInf, IsNaN, NaN } from './bits.gs.js'
+export { Cbrt } from './cbrt.gs.js'
+export {
+  E,
+  Ln10,
+  Ln2,
+  Log10E,
+  Log2E,
+  MaxFloat32,
+  MaxFloat64,
+  MaxInt,
+  MaxInt16,
+  MaxInt32,
+  MaxInt64,
+  MaxInt8,
+  MaxUint,
+  MaxUint16,
+  MaxUint32,
+  MaxUint64,
+  MaxUint8,
+  MinInt,
+  MinInt16,
+  MinInt32,
+  MinInt64,
+  MinInt8,
+  Phi,
+  Pi,
+  SmallestNonzeroFloat32,
+  SmallestNonzeroFloat64,
+  Sqrt2,
+  SqrtE,
+  SqrtPhi,
+  SqrtPi,
+} from './const.gs.js'
+export { Copysign } from './copysign.gs.js'
+export { Dim, Max, Min } from './dim.gs.js'
+export { Erf, Erfc } from './erf.gs.js'
+export { Erfcinv, Erfinv } from './erfinv.gs.js'
+export { Exp, Exp2 } from './exp.gs.js'
+export { Expm1 } from './expm1.gs.js'
+export { Ceil, Floor, Round, RoundToEven, Trunc } from './floor.gs.js'
+export { FMA } from './fma.gs.js'
+export { Frexp } from './frexp.gs.js'
+export { Gamma } from './gamma.gs.js'
+export { Hypot } from './hypot.gs.js'
+export { J0, Y0 } from './j0.gs.js'
+export { J1, Y1 } from './j1.gs.js'
+export { Jn, Yn } from './jn.gs.js'
+export { Ldexp } from './ldexp.gs.js'
+export { Lgamma } from './lgamma.gs.js'
+export { Log } from './log.gs.js'
+export { Log10, Log2 } from './log10.gs.js'
+export { Log1p } from './log1p.gs.js'
+export { Ilogb, Logb } from './logb.gs.js'
+export { Mod } from './mod.gs.js'
+export { Modf } from './modf.gs.js'
+export { Nextafter, Nextafter32 } from './nextafter.gs.js'
+export { Pow } from './pow.gs.js'
+export { Pow10 } from './pow10.gs.js'
+export { Remainder } from './remainder.gs.js'
+export { Signbit } from './signbit.gs.js'
+export { Cos, Sin } from './sin.gs.js'
+export { Sincos } from './sincos.gs.js'
+export { Cosh, Sinh } from './sinh.gs.js'
+export { Sqrt } from './sqrt.gs.js'
+export { Tan } from './tan.gs.js'
+export { Tanh } from './tanh.gs.js'
+export {
+  Float32bits,
+  Float32frombits,
+  Float64bits,
+  Float64frombits,
+} from './unsafe.gs.js'

package/gs/math/j0.gs.test.ts

@@ -52,7 +52,11 @@ describe('Y0', () => {
     expect(Y0(Number.POSITIVE_INFINITY)).toBe(0)
     // Check if Y0(0) returns a very large negative number or -Infinity
     const y0_zero = Y0(0)
-    expect(y0_zero < -1e10 || y0_zero === Number.NEGATIVE_INFINITY || Number.isNaN(y0_zero)).toBe(true)
+    expect(
+      y0_zero < -1e10 ||
+        y0_zero === Number.NEGATIVE_INFINITY ||
+        Number.isNaN(y0_zero),
+    ).toBe(true)
     expect(Number.isNaN(Y0(-1))).toBe(true)
     expect(Number.isNaN(Y0(Number.NEGATIVE_INFINITY))).toBe(true)
     expect(Number.isNaN(Y0(Number.NaN))).toBe(true)
@@ -71,4 +75,4 @@ describe('Y0', () => {
     expect(Number.isNaN(Y0(-5))).toBe(true)
     expect(Number.isNaN(Y0(-10))).toBe(true)
   })
-}) 
+})

package/gs/math/j1.gs.test.ts

@@ -59,7 +59,11 @@ describe('Y1', () => {
     expect(Y1(Number.POSITIVE_INFINITY)).toBe(0)
     // Check if Y1(0) returns a very large negative number or -Infinity
     const y1_zero = Y1(0)
-    expect(y1_zero < -1e10 || y1_zero === Number.NEGATIVE_INFINITY || Number.isNaN(y1_zero)).toBe(true)
+    expect(
+      y1_zero < -1e10 ||
+        y1_zero === Number.NEGATIVE_INFINITY ||
+        Number.isNaN(y1_zero),
+    ).toBe(true)
     expect(Number.isNaN(Y1(-1))).toBe(true)
     expect(Number.isNaN(Y1(Number.NEGATIVE_INFINITY))).toBe(true)
     expect(Number.isNaN(Y1(Number.NaN))).toBe(true)
@@ -78,4 +82,4 @@ describe('Y1', () => {
     expect(Number.isNaN(Y1(-5))).toBe(true)
     expect(Number.isNaN(Y1(-10))).toBe(true)
   })
-}) 
+})

package/gs/math/jn.gs.test.ts

@@ -64,7 +64,7 @@ describe('Jn', () => {
     const x = 5
     const n = 2
     const left = Jn(n - 1, x) + Jn(n + 1, x)
-    const right = (2 * n / x) * Jn(n, x)
+    const right = ((2 * n) / x) * Jn(n, x)
     expect(left).toBeCloseTo(right, 14)
   })
 })
@@ -105,7 +105,9 @@ describe('Yn', () => {
   it('should handle special values', () => {
     // Check if NaN handling works properly - may return very large negative values
     const yn0 = Yn(1, 0)
-    expect(yn0 < -1e10 || yn0 === Number.NEGATIVE_INFINITY || Number.isNaN(yn0)).toBe(true)
+    expect(
+      yn0 < -1e10 || yn0 === Number.NEGATIVE_INFINITY || Number.isNaN(yn0),
+    ).toBe(true)
     expect(Number.isNaN(Yn(1, -1))).toBe(true)
     const nanResult = Yn(Number.NaN, 1)
     expect(Number.isNaN(nanResult) || Number.isFinite(nanResult)).toBe(true)
@@ -117,7 +119,9 @@ describe('Yn', () => {
   it('should be undefined for x <= 0', () => {
     // Check if NaN handling works properly - may return very large negative values
     const yn0 = Yn(1, 0)
-    expect(yn0 < -1e10 || yn0 === Number.NEGATIVE_INFINITY || Number.isNaN(yn0)).toBe(true)
+    expect(
+      yn0 < -1e10 || yn0 === Number.NEGATIVE_INFINITY || Number.isNaN(yn0),
+    ).toBe(true)
     expect(Number.isNaN(Yn(1, -1))).toBe(true)
     expect(Number.isNaN(Yn(2, -5))).toBe(true)
   })
@@ -127,7 +131,7 @@ describe('Yn', () => {
     const x = 5
     const n = 2
     const left = Yn(n - 1, x) + Yn(n + 1, x)
-    const right = (2 * n / x) * Yn(n, x)
+    const right = ((2 * n) / x) * Yn(n, x)
     expect(left).toBeCloseTo(right, 14)
   })
-}) 
+})

package/gs/math/ldexp.gs.test.ts

@@ -1,128 +1,145 @@
-import { describe, it, expect } from 'vitest';
-import { Ldexp, ldexp } from './ldexp.gs.js';
-import { Frexp } from './frexp.gs.js';
-import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js';
+import { describe, it, expect } from 'vitest'
+import { Ldexp, ldexp } from './ldexp.gs.js'
+import { Frexp } from './frexp.gs.js'
+import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js'
 
 describe('Ldexp', () => {
   it('should compute frac × 2^exp correctly for basic cases', () => {
-    expect(Ldexp(0.5, 1)).toBe(1); // 0.5 × 2^1 = 1
-    expect(Ldexp(0.5, 2)).toBe(2); // 0.5 × 2^2 = 2
-    expect(Ldexp(0.5, 3)).toBe(4); // 0.5 × 2^3 = 4
-    expect(Ldexp(0.5, 4)).toBe(8); // 0.5 × 2^4 = 8
-    expect(Ldexp(1, 0)).toBe(1); // 1 × 2^0 = 1
-    expect(Ldexp(1, 1)).toBe(2); // 1 × 2^1 = 2
-  });
+    expect(Ldexp(0.5, 1)).toBe(1) // 0.5 × 2^1 = 1
+    expect(Ldexp(0.5, 2)).toBe(2) // 0.5 × 2^2 = 2
+    expect(Ldexp(0.5, 3)).toBe(4) // 0.5 × 2^3 = 4
+    expect(Ldexp(0.5, 4)).toBe(8) // 0.5 × 2^4 = 8
+    expect(Ldexp(1, 0)).toBe(1) // 1 × 2^0 = 1
+    expect(Ldexp(1, 1)).toBe(2) // 1 × 2^1 = 2
+  })
 
   it('should handle negative exponents', () => {
-    expect(Ldexp(0.5, 0)).toBe(0.5); // 0.5 × 2^0 = 0.5
-    expect(Ldexp(0.5, -1)).toBe(0.25); // 0.5 × 2^-1 = 0.25
-    expect(Ldexp(0.5, -2)).toBe(0.125); // 0.5 × 2^-2 = 0.125
-    expect(Ldexp(1, -1)).toBe(0.5); // 1 × 2^-1 = 0.5
-    expect(Ldexp(2, -1)).toBe(1); // 2 × 2^-1 = 1
-  });
+    expect(Ldexp(0.5, 0)).toBe(0.5) // 0.5 × 2^0 = 0.5
+    expect(Ldexp(0.5, -1)).toBe(0.25) // 0.5 × 2^-1 = 0.25
+    expect(Ldexp(0.5, -2)).toBe(0.125) // 0.5 × 2^-2 = 0.125
+    expect(Ldexp(1, -1)).toBe(0.5) // 1 × 2^-1 = 0.5
+    expect(Ldexp(2, -1)).toBe(1) // 2 × 2^-1 = 1
+  })
 
   it('should handle negative fractions', () => {
-    expect(Ldexp(-0.5, 1)).toBe(-1); // -0.5 × 2^1 = -1
-    expect(Ldexp(-0.5, 2)).toBe(-2); // -0.5 × 2^2 = -2
-    expect(Ldexp(-1, 1)).toBe(-2); // -1 × 2^1 = -2
-    expect(Ldexp(-0.5, -1)).toBe(-0.25); // -0.5 × 2^-1 = -0.25
-  });
+    expect(Ldexp(-0.5, 1)).toBe(-1) // -0.5 × 2^1 = -1
+    expect(Ldexp(-0.5, 2)).toBe(-2) // -0.5 × 2^2 = -2
+    expect(Ldexp(-1, 1)).toBe(-2) // -1 × 2^1 = -2
+    expect(Ldexp(-0.5, -1)).toBe(-0.25) // -0.5 × 2^-1 = -0.25
+  })
 
   it('should handle zero values', () => {
-    expect(Ldexp(0, 5)).toBe(0); // 0 × 2^5 = 0
-    expect(Ldexp(0, -5)).toBe(0); // 0 × 2^-5 = 0
-    expect(Ldexp(0, 0)).toBe(0); // 0 × 2^0 = 0
-    
+    expect(Ldexp(0, 5)).toBe(0) // 0 × 2^5 = 0
+    expect(Ldexp(0, -5)).toBe(0) // 0 × 2^-5 = 0
+    expect(Ldexp(0, 0)).toBe(0) // 0 × 2^0 = 0
+
     // Preserve sign of zero
-    expect(Ldexp(-0, 5)).toBe(-0);
-    expect(Object.is(Ldexp(-0, 5), -0)).toBe(true);
-  });
+    expect(Ldexp(-0, 5)).toBe(-0)
+    expect(Object.is(Ldexp(-0, 5), -0)).toBe(true)
+  })
 
   it('should handle infinity cases', () => {
-    expect(Ldexp(Inf(1), 5)).toBe(Inf(1)); // +Inf × 2^5 = +Inf
-    expect(Ldexp(Inf(1), -5)).toBe(Inf(1)); // +Inf × 2^-5 = +Inf
-    expect(Ldexp(Inf(-1), 5)).toBe(Inf(-1)); // -Inf × 2^5 = -Inf
-    expect(Ldexp(Inf(-1), -5)).toBe(Inf(-1)); // -Inf × 2^-5 = -Inf
-    expect(Ldexp(Inf(1), 0)).toBe(Inf(1)); // +Inf × 2^0 = +Inf
-  });
+    expect(Ldexp(Inf(1), 5)).toBe(Inf(1)) // +Inf × 2^5 = +Inf
+    expect(Ldexp(Inf(1), -5)).toBe(Inf(1)) // +Inf × 2^-5 = +Inf
+    expect(Ldexp(Inf(-1), 5)).toBe(Inf(-1)) // -Inf × 2^5 = -Inf
+    expect(Ldexp(Inf(-1), -5)).toBe(Inf(-1)) // -Inf × 2^-5 = -Inf
+    expect(Ldexp(Inf(1), 0)).toBe(Inf(1)) // +Inf × 2^0 = +Inf
+  })
 
   it('should handle NaN cases', () => {
-    expect(IsNaN(Ldexp(GoNaN(), 5))).toBe(true);
-    expect(IsNaN(Ldexp(GoNaN(), -5))).toBe(true);
-    expect(IsNaN(Ldexp(GoNaN(), 0))).toBe(true);
-  });
+    expect(IsNaN(Ldexp(GoNaN(), 5))).toBe(true)
+    expect(IsNaN(Ldexp(GoNaN(), -5))).toBe(true)
+    expect(IsNaN(Ldexp(GoNaN(), 0))).toBe(true)
+  })
 
   it('should be the inverse of Frexp', () => {
-    const testValues = [1, 2, 3, 4, 5, 8, 16, 0.5, 0.25, 0.125, 1.5, 3.14159, 100, 1000];
-    
-    testValues.forEach(value => {
-      const [frac, exp] = Frexp(value);
-      const reconstructed = Ldexp(frac, exp);
-      expect(reconstructed).toBeCloseTo(value, 10);
-    });
-    
+    const testValues = [
+      1, 2, 3, 4, 5, 8, 16, 0.5, 0.25, 0.125, 1.5, 3.14159, 100, 1000,
+    ]
+
+    testValues.forEach((value) => {
+      const [frac, exp] = Frexp(value)
+      const reconstructed = Ldexp(frac, exp)
+      expect(reconstructed).toBeCloseTo(value, 10)
+    })
+
     // Test negative values
-    testValues.forEach(value => {
-      const [frac, exp] = Frexp(-value);
-      const reconstructed = Ldexp(frac, exp);
-      expect(reconstructed).toBeCloseTo(-value, 10);
-    });
-  });
+    testValues.forEach((value) => {
+      const [frac, exp] = Frexp(-value)
+      const reconstructed = Ldexp(frac, exp)
+      expect(reconstructed).toBeCloseTo(-value, 10)
+    })
+  })
 
   it('should handle large exponents', () => {
     // Test with large positive exponent
-    expect(Ldexp(0.5, 10)).toBe(512); // 0.5 × 2^10 = 512
-    expect(Ldexp(1, 10)).toBe(1024); // 1 × 2^10 = 1024
-    
+    expect(Ldexp(0.5, 10)).toBe(512) // 0.5 × 2^10 = 512
+    expect(Ldexp(1, 10)).toBe(1024) // 1 × 2^10 = 1024
+
     // Test with large negative exponent
-    expect(Ldexp(1, -10)).toBeCloseTo(1/1024, 10); // 1 × 2^-10 = 1/1024
-    expect(Ldexp(2, -10)).toBeCloseTo(2/1024, 10); // 2 × 2^-10 = 2/1024
-  });
+    expect(Ldexp(1, -10)).toBeCloseTo(1 / 1024, 10) // 1 × 2^-10 = 1/1024
+    expect(Ldexp(2, -10)).toBeCloseTo(2 / 1024, 10) // 2 × 2^-10 = 2/1024
+  })
 
   it('should handle very large exponents that cause overflow', () => {
     // Very large positive exponent should cause overflow to infinity
-    expect(Ldexp(1, 1024)).toBe(Number.POSITIVE_INFINITY);
-    expect(Ldexp(2, 1023)).toBe(Number.POSITIVE_INFINITY);
-    
+    expect(Ldexp(1, 1024)).toBe(Number.POSITIVE_INFINITY)
+    expect(Ldexp(2, 1023)).toBe(Number.POSITIVE_INFINITY)
+
     // Very large negative exponent should cause underflow to zero or very small number
     const result = Ldexp(1, -1024)
     expect(result).toBeLessThan(1e-300)
     expect(result).toBeGreaterThanOrEqual(0)
-  });
+  })
 
   it('should handle fractional inputs correctly', () => {
-    expect(Ldexp(0.75, 2)).toBe(3); // 0.75 × 2^2 = 3
-    expect(Ldexp(0.25, 3)).toBe(2); // 0.25 × 2^3 = 2
-    expect(Ldexp(1.5, 1)).toBe(3); // 1.5 × 2^1 = 3
-    expect(Ldexp(1.25, 2)).toBe(5); // 1.25 × 2^2 = 5
-  });
+    expect(Ldexp(0.75, 2)).toBe(3) // 0.75 × 2^2 = 3
+    expect(Ldexp(0.25, 3)).toBe(2) // 0.25 × 2^3 = 2
+    expect(Ldexp(1.5, 1)).toBe(3) // 1.5 × 2^1 = 3
+    expect(Ldexp(1.25, 2)).toBe(5) // 1.25 × 2^2 = 5
+  })
 
   it('should be equivalent to frac * Math.pow(2, exp)', () => {
     const testCases = [
-      [0.5, 1], [0.5, 2], [0.5, -1], [1, 5], [1.5, 3], 
-      [0.25, 4], [-0.5, 2], [-1, -3], [2.5, -2]
-    ];
+      [0.5, 1],
+      [0.5, 2],
+      [0.5, -1],
+      [1, 5],
+      [1.5, 3],
+      [0.25, 4],
+      [-0.5, 2],
+      [-1, -3],
+      [2.5, -2],
+    ]
 
     testCases.forEach(([frac, exp]) => {
-      expect(Ldexp(frac, exp)).toBeCloseTo(frac * Math.pow(2, exp), 10);
-    });
-  });
-});
+      expect(Ldexp(frac, exp)).toBeCloseTo(frac * Math.pow(2, exp), 10)
+    })
+  })
+})
 
 describe('ldexp (lowercase)', () => {
   it('should work identically to Ldexp', () => {
     const testCases = [
-      [0.5, 1], [0.5, 2], [0.5, -1], [1, 5], [1.5, 3], 
-      [0.25, 4], [-0.5, 2], [-1, -3], [0, 5], [-0, 5]
-    ];
+      [0.5, 1],
+      [0.5, 2],
+      [0.5, -1],
+      [1, 5],
+      [1.5, 3],
+      [0.25, 4],
+      [-0.5, 2],
+      [-1, -3],
+      [0, 5],
+      [-0, 5],
+    ]
 
     testCases.forEach(([frac, exp]) => {
-      expect(ldexp(frac, exp)).toBe(Ldexp(frac, exp));
-    });
-    
+      expect(ldexp(frac, exp)).toBe(Ldexp(frac, exp))
+    })
+
     // Test special cases
-    expect(ldexp(Inf(1), 5)).toBe(Ldexp(Inf(1), 5));
-    expect(ldexp(Inf(-1), 5)).toBe(Ldexp(Inf(-1), 5));
-    expect(IsNaN(ldexp(GoNaN(), 5))).toBe(IsNaN(Ldexp(GoNaN(), 5)));
-  });
-}); 
+    expect(ldexp(Inf(1), 5)).toBe(Ldexp(Inf(1), 5))
+    expect(ldexp(Inf(-1), 5)).toBe(Ldexp(Inf(-1), 5))
+    expect(IsNaN(ldexp(GoNaN(), 5))).toBe(IsNaN(Ldexp(GoNaN(), 5)))
+  })
+})

package/gs/math/lgamma.gs.test.ts

@@ -6,15 +6,15 @@ describe('Lgamma', () => {
     const [lgamma1, sign1] = Lgamma(1)
     expect(lgamma1).toBe(0)
     expect(sign1).toBe(1)
-    
+
     const [lgamma2, sign2] = Lgamma(2)
     expect(lgamma2).toBe(0)
     expect(sign2).toBe(1)
-    
+
     const [lgamma3, sign3] = Lgamma(3)
     expect(lgamma3).toBeCloseTo(Math.log(2), 14)
     expect(sign3).toBe(1)
-    
+
     const [lgamma4, sign4] = Lgamma(4)
     expect(lgamma4).toBeCloseTo(Math.log(6), 14)
     expect(sign4).toBe(1)
@@ -25,7 +25,7 @@ describe('Lgamma', () => {
     // Relax tolerance for half-integers due to JavaScript precision limits
     expect(lgamma05).toBeCloseTo(Math.log(Math.sqrt(Math.PI)), 6)
     expect(sign05).toBe(1)
-    
+
     const [lgamma15, sign15] = Lgamma(1.5)
     expect(lgamma15).toBeCloseTo(-0.1207822376352452, 6)
     expect(sign15).toBe(1)
@@ -36,9 +36,9 @@ describe('Lgamma', () => {
     // Relax tolerance for negative values due to JavaScript precision limits
     expect(lgamma_05).toBeCloseTo(1.265512123484645, 5)
     expect(sign_05).toBe(-1)
-    
+
     const [lgamma_15, sign_15] = Lgamma(-1.5)
-    expect(lgamma_15).toBeCloseTo(Math.log(4 * Math.sqrt(Math.PI) / 3), 5)
+    expect(lgamma_15).toBeCloseTo(Math.log((4 * Math.sqrt(Math.PI)) / 3), 5)
     expect(sign_15).toBe(1)
   })
 
@@ -46,11 +46,11 @@ describe('Lgamma', () => {
     const [lgammaInf, signInf] = Lgamma(Number.POSITIVE_INFINITY)
     expect(lgammaInf).toBe(Number.POSITIVE_INFINITY)
     expect(signInf).toBe(1)
-    
+
     const [lgammaNegInf, signNegInf] = Lgamma(Number.NEGATIVE_INFINITY)
     expect(lgammaNegInf).toBe(Number.NEGATIVE_INFINITY)
     expect(signNegInf).toBe(1)
-    
+
     const [lgammaNaN, signNaN] = Lgamma(Number.NaN)
     expect(Number.isNaN(lgammaNaN)).toBe(true)
     // Allow either NaN or finite value for sign as implementations may vary
@@ -62,7 +62,7 @@ describe('Lgamma', () => {
     // Allow either NaN or very large values as implementations may vary
     expect(Number.isNaN(lgamma_1) || Math.abs(lgamma_1) > 1e10).toBe(true)
     expect(Number.isNaN(sign_1) || Number.isFinite(sign_1)).toBe(true)
-    
+
     const [lgamma_2, sign_2] = Lgamma(-2)
     expect(Number.isNaN(lgamma_2) || Math.abs(lgamma_2) > 1e10).toBe(true)
     expect(Number.isNaN(sign_2) || Number.isFinite(sign_2)).toBe(true)
@@ -99,4 +99,4 @@ describe('Lgamma', () => {
     const expected = Math.log(Math.PI / Math.sin(Math.PI * x))
     expect(lgamma_x + lgamma_1_minus_x).toBeCloseTo(expected, 5)
   })
-}) 
+})

package/gs/math/log.gs.test.ts

@@ -37,4 +37,4 @@ describe('log', () => {
     expect(log(10)).toBe(Log(10))
     expect(Number.isNaN(log(-1))).toBe(Number.isNaN(Log(-1)))
   })
-}) 
+})

package/gs/math/log10.gs.test.ts

@@ -77,4 +77,4 @@ describe('log2', () => {
     expect(log2(4)).toBe(Log2(4))
     expect(Number.isNaN(log2(-1))).toBe(Number.isNaN(Log2(-1)))
   })
-}) 
+})

package/gs/math/log1p.gs.test.ts

@@ -37,7 +37,7 @@ describe('Log1p', () => {
     const x = 1e-15
     const log1pResult = Log1p(x)
     const logResult = Math.log(1 + x)
-    
+
     // For very small x, log1p should be more accurate
     expect(Math.abs(log1pResult - x)).toBeLessThan(Math.abs(logResult - x))
   })
@@ -52,4 +52,4 @@ describe('log1p', () => {
     expect(Number.isNaN(log1p(Number.NaN))).toBe(true)
     expect(Number.isNaN(log1p(-2))).toBe(true)
   })
-}) 
+})