chore: reformat

Author: missinglink

r1/Interval.ts

@@ -26,7 +26,7 @@ export class Interval {
   /**
    * Returns true iff the interval contains the same points as oi.
    */
-  equal(oi: Interval): boolean {
+  equals(oi: Interval): boolean {
     return (this.lo == oi.lo && this.hi == oi.hi) || (this.isEmpty() && oi.isEmpty())
   }
 

r1/Interval_test.ts

@@ -8,26 +8,26 @@ const NEG_UNIT = new Interval(-1, 0)
 const HALF = new Interval(0.5, 0.5)
 const EMPTY = Interval.empty()
 
-test('isEmpty', t => {
+test('isEmpty', (t) => {
   ok(!UNIT.isEmpty(), 'should not be empty')
   ok(!NEG_UNIT.isEmpty(), 'should not be empty')
   ok(!HALF.isEmpty(), 'should not be empty')
   ok(EMPTY.isEmpty(), 'should not empty')
 })
 
-test('center', t => {
+test('center', (t) => {
   equal(UNIT.center(), 0.5)
   equal(NEG_UNIT.center(), -0.5)
   equal(HALF.center(), 0.5)
 })
 
-test('length', t => {
+test('length', (t) => {
   equal(UNIT.length(), 1)
   equal(NEG_UNIT.length(), 1)
   equal(HALF.length(), 0)
 })
 
-test('contains', t => {
+test('contains', (t) => {
   ok(UNIT.contains(0.5))
   ok(UNIT.interiorContains(0.5))
 
@@ -38,7 +38,7 @@ test('contains', t => {
   ok(!UNIT.interiorContains(1))
 })
 
-test('operations', t => {
+test('operations', (t) => {
   ok(EMPTY.containsInterval(EMPTY))
   ok(EMPTY.interiorContainsInterval(EMPTY))
   ok(!EMPTY.intersects(EMPTY))
@@ -81,46 +81,46 @@ test('operations', t => {
   ok(!HALF.interiorIntersects(i))
 })
 
-test('intersection', t => {
-  ok(UNIT.intersection(HALF).equal(HALF))
-  ok(UNIT.intersection(NEG_UNIT).equal(new Interval(0, 0)))
-  ok(NEG_UNIT.intersection(HALF).equal(EMPTY))
-  ok(UNIT.intersection(EMPTY).equal(EMPTY))
-  ok(EMPTY.intersection(UNIT).equal(EMPTY))
+test('intersection', (t) => {
+  ok(UNIT.intersection(HALF).equals(HALF))
+  ok(UNIT.intersection(NEG_UNIT).equals(new Interval(0, 0)))
+  ok(NEG_UNIT.intersection(HALF).equals(EMPTY))
+  ok(UNIT.intersection(EMPTY).equals(EMPTY))
+  ok(EMPTY.intersection(UNIT).equals(EMPTY))
 })
 
-test('union', t => {
-  ok(new Interval(99, 100).union(EMPTY).equal(new Interval(99, 100)))
-  ok(EMPTY.union(new Interval(99, 100)).equal(new Interval(99, 100)))
-  ok(new Interval(5, 3).union(new Interval(0, -2)).equal(EMPTY))
-  ok(new Interval(0, -2).union(new Interval(5, 3)).equal(EMPTY))
-  ok(UNIT.union(UNIT).equal(UNIT))
-  ok(UNIT.union(NEG_UNIT).equal(new Interval(-1, 1)))
-  ok(NEG_UNIT.union(UNIT).equal(new Interval(-1, 1)))
-  ok(HALF.union(UNIT).equal(UNIT))
+test('union', (t) => {
+  ok(new Interval(99, 100).union(EMPTY).equals(new Interval(99, 100)))
+  ok(EMPTY.union(new Interval(99, 100)).equals(new Interval(99, 100)))
+  ok(new Interval(5, 3).union(new Interval(0, -2)).equals(EMPTY))
+  ok(new Interval(0, -2).union(new Interval(5, 3)).equals(EMPTY))
+  ok(UNIT.union(UNIT).equals(UNIT))
+  ok(UNIT.union(NEG_UNIT).equals(new Interval(-1, 1)))
+  ok(NEG_UNIT.union(UNIT).equals(new Interval(-1, 1)))
+  ok(HALF.union(UNIT).equals(UNIT))
 })
 
-test('addPoint', t => {
-  ok(EMPTY.addPoint(5).equal(new Interval(5, 5)))
-  ok(new Interval(5, 5).addPoint(-1).equal(new Interval(-1, 5)))
-  ok(new Interval(-1, 5).addPoint(0).equal(new Interval(-1, 5)))
-  ok(new Interval(-1, 5).addPoint(6).equal(new Interval(-1, 6)))
+test('addPoint', (t) => {
+  ok(EMPTY.addPoint(5).equals(new Interval(5, 5)))
+  ok(new Interval(5, 5).addPoint(-1).equals(new Interval(-1, 5)))
+  ok(new Interval(-1, 5).addPoint(0).equals(new Interval(-1, 5)))
+  ok(new Interval(-1, 5).addPoint(6).equals(new Interval(-1, 6)))
 })
 
-test('clampPoint', t => {
+test('clampPoint', (t) => {
   equal(new Interval(0.1, 0.4).clampPoint(0.3), 0.3)
   equal(new Interval(0.1, 0.4).clampPoint(-7.0), 0.1)
   equal(new Interval(0.1, 0.4).clampPoint(0.6), 0.4)
 })
 
-test('expanded', t => {
-  ok(EMPTY.expanded(0.45).equal(EMPTY))
-  ok(UNIT.expanded(0.5).equal(new Interval(-0.5, 1.5)))
-  ok(UNIT.expanded(-0.5).equal(new Interval(0.5, 0.5)))
-  ok(UNIT.expanded(-0.51).equal(EMPTY))
+test('expanded', (t) => {
+  ok(EMPTY.expanded(0.45).equals(EMPTY))
+  ok(UNIT.expanded(0.5).equals(new Interval(-0.5, 1.5)))
+  ok(UNIT.expanded(-0.5).equals(new Interval(0.5, 0.5)))
+  ok(UNIT.expanded(-0.51).equals(EMPTY))
 })
 
-test('approxEqual', t => {
+test('approxEqual', (t) => {
   // Choose two values lo and hi such that it's okay to shift an endpoint by
   // kLo (i.e., the resulting interval is equivalent) but not by kHi.
   const lo = 4 * 2.220446049250313e-16 // < max_error default
@@ -154,14 +154,14 @@ test('approxEqual', t => {
   ok(!new Interval(1 + lo, 2 - hi).approxEqual(new Interval(1, 2)))
 })
 
-test('directedHausdorffDistance', t => {
+test('directedHausdorffDistance', (t) => {
   equal(EMPTY.directedHausdorffDistance(EMPTY), 0)
   equal(UNIT.directedHausdorffDistance(EMPTY), Infinity)
   equal(new Interval(1, 1).directedHausdorffDistance(new Interval(1, 1)), 0)
   equal(new Interval(1, 3).directedHausdorffDistance(new Interval(1, 1)), 2)
   equal(new Interval(1, 1).directedHausdorffDistance(new Interval(3, 5)), 2)
 })
 
-test('toString', t => {
+test('toString', (t) => {
   equal(new Interval(2, 4.5).toString(), '[2.0000000, 4.5000000]')
 })

r1/math.ts

@@ -44,4 +44,4 @@ export const findLSBSetNonZero64 = (i: bigint): number => {
   if (lo < 32) return 31 - lo
   const hi = Math.clz32(Number((lsb >> 32n) & 0xffffffffn))
   return 63 - hi
-}
+}

r1/math_test.ts

@@ -2,7 +2,7 @@ import test from 'node:test'
 import { equal, ok } from 'node:assert/strict'
 import { remainder, nextAfter, float64Near, findLSBSetNonZero64 } from './math'
 
-test('remainder', t => {
+test('remainder', (t) => {
   equal(remainder(5.1, 2), -0.9000000000000004)
   equal(remainder(5.5, 2), -0.5)
   equal(remainder(-5.5, 2), 0.5)
@@ -15,7 +15,7 @@ test('remainder', t => {
   equal(remainder(-5, 2), -1)
 })
 
-test('nextAfter', t => {
+test('nextAfter', (t) => {
   equal(nextAfter(0, 1), 5e-324)
   equal(nextAfter(0, -1), -5e-324)
   equal(nextAfter(1, 2), 1.0000000000000002)
@@ -27,14 +27,14 @@ test('nextAfter', t => {
   equal(nextAfter(1, Number.NaN), NaN)
 })
 
-test('float64Near', t => {
+test('float64Near', (t) => {
   ok(float64Near(0, 0, 0))
-  ok(float64Near(1e-10, 1e-10*2, 1e-10))
+  ok(float64Near(1e-10, 1e-10 * 2, 1e-10))
   ok(!float64Near(1e-10, 1e-9, 1e-10))
-  ok(!float64Near(1e-5, 1e-4, 1e-5/10))
+  ok(!float64Near(1e-5, 1e-4, 1e-5 / 10))
 })
 
-test('findLSBSetNonZero64', t => {
+test('findLSBSetNonZero64', (t) => {
   equal(findLSBSetNonZero64(0b0000000000000000000000000000000000000000000000000000000000000001n), 0)
   equal(findLSBSetNonZero64(0b0000000000000000000000000000000000000000000000000000000000000010n), 1)
   equal(findLSBSetNonZero64(0b0000000000000000000000000000000000000000000000000000000000000100n), 2)
@@ -51,4 +51,4 @@ test('findLSBSetNonZero64', t => {
   equal(findLSBSetNonZero64(0b1000000000000000000000000000000000000000000000000000000000000000n), 63)
   equal(findLSBSetNonZero64(0b0000000000000000000000000000000000000000000000000000000000000000n), 64)
   equal(findLSBSetNonZero64(0b1000000000000000000000000000000000000000000000000000000000000000000n), 64)
-})
+})

r2/Point_test.ts

@@ -4,50 +4,50 @@ import { Point } from './Point'
 
 export const MAX_FLOAT32 = Math.pow(2, 127) * (2 - 1 / Math.pow(2, 23))
 
-test('add', t => {
+test('add', (t) => {
   deepEqual(new Point(0, 0).add(new Point(0, 0)), new Point(0, 0))
   deepEqual(new Point(0, 1).add(new Point(0, 0)), new Point(0, 1))
   deepEqual(new Point(1, 1).add(new Point(4, 3)), new Point(5, 4))
   deepEqual(new Point(-4, 7).add(new Point(1, 5)), new Point(-3, 12))
 })
 
-test('sub', t => {
+test('sub', (t) => {
   deepEqual(new Point(0, 0).sub(new Point(0, 0)), new Point(0, 0))
   deepEqual(new Point(0, 1).sub(new Point(0, 0)), new Point(0, 1))
   deepEqual(new Point(1, 1).sub(new Point(4, 3)), new Point(-3, -2))
   deepEqual(new Point(-4, 7).sub(new Point(1, 5)), new Point(-5, 2))
 })
 
-test('mul', t => {
+test('mul', (t) => {
   deepEqual(new Point(0, 0).mul(0), new Point(0, 0))
   deepEqual(new Point(0, 1).mul(1), new Point(0, 1))
   deepEqual(new Point(1, 1).mul(5), new Point(5, 5))
 })
 
-test('ortho', t => {
+test('ortho', (t) => {
   deepEqual(new Point(0, 0).ortho(), new Point(-0, 0))
   deepEqual(new Point(0, 1).ortho(), new Point(-1, 0))
   deepEqual(new Point(1, 1).ortho(), new Point(-1, 1))
   deepEqual(new Point(-4, 7).ortho(), new Point(-7, -4))
   deepEqual(new Point(1, Math.sqrt(3)).ortho(), new Point(-Math.sqrt(3), 1))
 })
 
-test('dot', t => {
+test('dot', (t) => {
   equal(new Point(0, 0).dot(new Point(0, 0)), 0)
   equal(new Point(0, 1).dot(new Point(0, 0)), 0)
   equal(new Point(1, 1).dot(new Point(4, 3)), 7)
   equal(new Point(-4, 7).dot(new Point(1, 5)), 31)
 })
 
-test('cross', t => {
+test('cross', (t) => {
   equal(new Point(0, 0).cross(new Point(0, 0)), 0)
   equal(new Point(0, 1).cross(new Point(0, 0)), 0)
   equal(new Point(1, 1).cross(new Point(-1, -1)), 0)
   equal(new Point(1, 1).cross(new Point(4, 3)), -1)
   equal(new Point(1, 5).cross(new Point(-2, 3)), 13)
 })
 
-test('norm', t => {
+test('norm', (t) => {
   equal(new Point(0, 0).norm(), 0)
   equal(new Point(0, 1).norm(), 1)
   equal(new Point(-1, 0).norm(), 1)
@@ -60,7 +60,7 @@ test('norm', t => {
   equal(new Point(1e14, MAX_FLOAT32 - 1).norm(), MAX_FLOAT32)
 })
 
-test('normalize', t => {
+test('normalize', (t) => {
   deepEqual(new Point().normalize(), new Point(0, 0))
   deepEqual(new Point(0, 0).normalize(), new Point(0, 0))
   deepEqual(new Point(0, 1).normalize(), new Point(0, 1))
@@ -74,13 +74,13 @@ test('normalize', t => {
   deepEqual(new Point(1e4, MAX_FLOAT32 - 1).normalize().trunc(), new Point(0, 1))
 })
 
-test('trunc', t => {
+test('trunc', (t) => {
   deepEqual(new Point().trunc(), new Point(0, 0))
   deepEqual(new Point(0.0000000000000001, 0.0000000000000001).trunc(), new Point(0, 0))
   deepEqual(new Point(0.00000000001, 0.00000000001).trunc(10), new Point(0, 0))
 })
 
-test('toString', t => {
+test('toString', (t) => {
   equal(new Point().toString(), '(0.000000000000, 0.000000000000)')
   equal(new Point(0.0000000000000001, 0.0000000000000001).toString(), '(0.000000000000, 0.000000000000)')
   equal(new Point(-1, 1).toString(), '(-1.000000000000, 1.000000000000)')

r2/Rect.ts

@@ -230,7 +230,7 @@ export class Rect {
   static fromCenterSize(center: Point, size: Point): Rect {
     return new Rect(
       new Interval(center.x - size.x / 2, center.x + size.x / 2),
-      new Interval(center.y - size.y / 2, center.y + size.y / 2)
+      new Interval(center.y - size.y / 2, center.y + size.y / 2),
     )
   }