@tldraw/editor 3.15.0-next.f1dfcef63951 → 3.16.0-next.c30b1b5e551a

package/src/lib/primitives/intersect.test.ts

@@ -0,0 +1,946 @@
+import {
+	intersectCircleCircle,
+	intersectCirclePolygon,
+	intersectCirclePolyline,
+	intersectLineSegmentCircle,
+	intersectLineSegmentLineSegment,
+	intersectLineSegmentPolygon,
+	intersectLineSegmentPolyline,
+	intersectPolygonPolygon,
+} from './intersect'
+import { Vec, VecLike } from './Vec'
+
+describe('intersectLineSegmentLineSegment', () => {
+	describe('intersecting segments', () => {
+		it('should find intersection when segments cross', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(10, 10)
+			const b1 = new Vec(0, 10)
+			const b2 = new Vec(10, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 5)
+			expect(result!.y).toBeCloseTo(5, 5)
+		})
+
+		it('should find intersection when segments cross at an angle', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(8, 6)
+			const b1 = new Vec(0, 6)
+			const b2 = new Vec(8, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(4, 5)
+			expect(result!.y).toBeCloseTo(3, 5)
+		})
+
+		it('should find intersection when one segment is vertical', () => {
+			const a1 = new Vec(5, 0)
+			const a2 = new Vec(5, 10)
+			const b1 = new Vec(0, 5)
+			const b2 = new Vec(10, 5)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 5)
+			expect(result!.y).toBeCloseTo(5, 5)
+		})
+
+		it('should find intersection when one segment is horizontal', () => {
+			const a1 = new Vec(0, 5)
+			const a2 = new Vec(10, 5)
+			const b1 = new Vec(5, 0)
+			const b2 = new Vec(5, 10)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 5)
+			expect(result!.y).toBeCloseTo(5, 5)
+		})
+	})
+
+	describe('non-intersecting segments', () => {
+		it('should return null when segments are parallel', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(10, 0)
+			const b1 = new Vec(0, 5)
+			const b2 = new Vec(10, 5)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+
+		it('should return null when segments are parallel and vertical', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(0, 10)
+			const b1 = new Vec(5, 0)
+			const b2 = new Vec(5, 10)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+
+		it('should return null when segments do not intersect', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(5, 5)
+			const b1 = new Vec(10, 0)
+			const b2 = new Vec(15, 5)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+
+		it('should return null when segments are collinear but do not overlap', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(5, 0)
+			const b1 = new Vec(10, 0)
+			const b2 = new Vec(15, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+	})
+
+	describe('coincident segments', () => {
+		it('should return null when segments are identical', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(10, 0)
+			const b1 = new Vec(0, 0)
+			const b2 = new Vec(10, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+
+		it('should return null when segments overlap', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(10, 0)
+			const b1 = new Vec(5, 0)
+			const b2 = new Vec(15, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+
+		it('should return null when one segment is contained within another', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(10, 0)
+			const b1 = new Vec(3, 0)
+			const b2 = new Vec(7, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull()
+		})
+	})
+
+	describe('touching endpoints', () => {
+		it('should return null when segments touch at endpoints (coincident case)', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(5, 5)
+			const b1 = new Vec(5, 5)
+			const b2 = new Vec(10, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull() // coincident case
+		})
+
+		it('should return null when segments touch at one endpoint (coincident case)', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(5, 5)
+			const b1 = new Vec(5, 5)
+			const b2 = new Vec(10, 10)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull() // coincident case
+		})
+
+		it('should find intersection when segments cross near endpoints', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(5, 5)
+			const b1 = new Vec(4.9, 5.1)
+			const b2 = new Vec(5.1, 4.9)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 1)
+			expect(result!.y).toBeCloseTo(5, 1)
+		})
+
+		it('should find intersection when segments cross at endpoints (floating point error case)', () => {
+			const result = intersectLineSegmentLineSegment(
+				{ x: 100, y: 100 },
+				{ x: 20, y: 20 },
+				{ x: 36.141160159025375, y: 31.811740238538057 },
+				{ x: 34.14213562373095, y: 34.14213562373095 }
+			)
+
+			expect(result).not.toBeNull()
+		})
+	})
+
+	describe('edge cases', () => {
+		it('should handle very small segments', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(0.0001, 0.0001)
+			const b1 = new Vec(0, 0.0001)
+			const b2 = new Vec(0.0001, 0)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+		})
+
+		it('should handle segments with very large coordinates', () => {
+			const a1 = new Vec(1e10, 1e10)
+			const a2 = new Vec(1e11, 1e11)
+			const b1 = new Vec(1e10, 1e11)
+			const b2 = new Vec(1e11, 1e10)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+		})
+
+		it('should return null for zero-length segments (parallel case)', () => {
+			const a1 = new Vec(5, 5)
+			const a2 = new Vec(5, 5)
+			const b1 = new Vec(0, 0)
+			const b2 = new Vec(10, 10)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull() // parallel case (zero-length segment)
+		})
+
+		it('should handle very short segments that still intersect', () => {
+			const a1 = new Vec(5.05, 4.95)
+			const a2 = new Vec(4.95, 5.05)
+			const b1 = new Vec(0, 0)
+			const b2 = new Vec(10, 10)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 1)
+			expect(result!.y).toBeCloseTo(5, 1)
+		})
+
+		it('should handle both segments being zero-length at same point', () => {
+			const a1 = new Vec(5, 5)
+			const a2 = new Vec(5, 5)
+			const b1 = new Vec(5, 5)
+			const b2 = new Vec(5, 5)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull() // coincident case
+		})
+	})
+
+	describe('precision and floating point', () => {
+		it('should handle floating point precision issues', () => {
+			const a1 = new Vec(0.1, 0.1)
+			const a2 = new Vec(0.2, 0.2)
+			const b1 = new Vec(0.1, 0.2)
+			const b2 = new Vec(0.2, 0.1)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(0.15, 5)
+			expect(result!.y).toBeCloseTo(0.15, 5)
+		})
+
+		it('should handle segments that are very close but not intersecting', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(1, 0)
+			const b1 = new Vec(0, 0.000001)
+			const b2 = new Vec(1, 0.000001)
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).toBeNull() // parallel
+		})
+	})
+
+	describe('VecLike interface compatibility', () => {
+		it('should work with VecModel objects', () => {
+			const a1 = { x: 0, y: 0 }
+			const a2 = { x: 10, y: 10 }
+			const b1 = { x: 0, y: 10 }
+			const b2 = { x: 10, y: 0 }
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 5)
+			expect(result!.y).toBeCloseTo(5, 5)
+		})
+
+		it('should work with mixed Vec and VecModel objects', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = { x: 10, y: 10 }
+			const b1 = new Vec(0, 10)
+			const b2 = { x: 10, y: 0 }
+
+			const result = intersectLineSegmentLineSegment(a1, a2, b1, b2)
+
+			expect(result).not.toBeNull()
+			expect(result!.x).toBeCloseTo(5, 5)
+			expect(result!.y).toBeCloseTo(5, 5)
+		})
+	})
+})
+
+describe('intersectLineSegmentCircle', () => {
+	it('should return null when segment is completely outside the circle', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 0)
+		const c = new Vec(5, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).toBeNull()
+	})
+
+	it('should return null when segment is tangent to the circle', () => {
+		const a1 = new Vec(0, 1)
+		const a2 = new Vec(2, 1)
+		const c = new Vec(1, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).toBeNull() // tangent returns null per implementation
+	})
+
+	it('should return two points when segment passes through the circle', () => {
+		const a1 = new Vec(-2, 0)
+		const a2 = new Vec(2, 0)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+		const sorted = result!.slice().sort((a, b) => a.x - b.x)
+		expect(sorted[0].x).toBeCloseTo(-1, 5)
+		expect(sorted[1].x).toBeCloseTo(1, 5)
+		sorted.forEach((pt) => expect(Math.abs(pt.y)).toBeCloseTo(0, 5))
+	})
+
+	it('should return one point when segment starts inside and exits the circle', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(2, 0)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(1, 5)
+		expect(result![0].y).toBeCloseTo(0, 5)
+	})
+
+	it('should return one point when segment ends inside and enters the circle', () => {
+		const a1 = new Vec(2, 0)
+		const a2 = new Vec(0, 0)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(1, 5)
+		expect(result![0].y).toBeCloseTo(0, 5)
+	})
+
+	it('should return null when segment is entirely inside the circle', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(0.5, 0)
+		const c = new Vec(0, 0)
+		const r = 2
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).toBeNull()
+	})
+
+	it('should return one point when segment endpoint is exactly on the circle', () => {
+		const a1 = new Vec(-1, 0)
+		const a2 = new Vec(0, 0)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(-1, 5)
+		expect(result![0].y).toBeCloseTo(0, 5)
+	})
+
+	it('should return null for zero-length segment outside the circle', () => {
+		const a1 = new Vec(2, 2)
+		const a2 = new Vec(2, 2)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).toBeNull()
+	})
+
+	it('should return null for zero-length segment inside the circle', () => {
+		const a1 = new Vec(0.5, 0)
+		const a2 = new Vec(0.5, 0)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).toBeNull()
+	})
+
+	it('should return one point for zero-length segment on the circle', () => {
+		const a1 = new Vec(1, 0)
+		const a2 = new Vec(1, 0)
+		const c = new Vec(0, 0)
+		const r = 1
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).toBeNull() // tangent returns null per implementation
+	})
+
+	it('should handle floating point precision', () => {
+		const a1 = new Vec(-1e-8, 1)
+		const a2 = new Vec(1 + 1e-8, 1)
+		const c = new Vec(0.5, 1)
+		const r = 0.5
+		const result = intersectLineSegmentCircle(a1, a2, c, r)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+		const sorted = result!.slice().sort((a, b) => a.x - b.x)
+		expect(sorted[0].x).toBeCloseTo(0, 5)
+		expect(sorted[1].x).toBeCloseTo(1, 5)
+	})
+})
+
+describe('intersectLineSegmentPolyline', () => {
+	it('should return null when no intersection with polyline', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 0)
+		const points = [new Vec(5, 5), new Vec(6, 5), new Vec(6, 6), new Vec(5, 6)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return single intersection point', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(10, 10)
+		const points = [new Vec(0, 10), new Vec(10, 0)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(5, 5)
+		expect(result![0].y).toBeCloseTo(5, 5)
+	})
+
+	it('should return multiple intersection points', () => {
+		const a1 = new Vec(0, 5)
+		const a2 = new Vec(10, 5)
+		const points = [new Vec(2, 0), new Vec(2, 10), new Vec(8, 10), new Vec(8, 0)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+		// Should intersect at x=2 and x=8
+		const sorted = result!.slice().sort((a, b) => a.x - b.x)
+		expect(sorted[0].x).toBeCloseTo(2, 5)
+		expect(sorted[1].x).toBeCloseTo(8, 5)
+		sorted.forEach((pt) => expect(pt.y).toBeCloseTo(5, 5))
+	})
+
+	it('should return null for empty polyline', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 1)
+		const points: VecLike[] = []
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null for single point polyline', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 1)
+		const points = [new Vec(5, 5)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should handle polyline with duplicate points', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(10, 10)
+		const points = [new Vec(0, 10), new Vec(5, 5), new Vec(5, 5), new Vec(10, 0)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(5, 5)
+		expect(result![0].y).toBeCloseTo(5, 5)
+	})
+
+	it('should handle polyline with zero-length segments', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(10, 10)
+		const points = [new Vec(0, 10), new Vec(5, 5), new Vec(5, 5), new Vec(10, 0)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(5, 5)
+		expect(result![0].y).toBeCloseTo(5, 5)
+	})
+
+	it('should handle polyline that touches segment endpoint', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(5, 5)
+		const points = [new Vec(5, 5), new Vec(10, 0)]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).toBeNull() // coincident case
+	})
+
+	it('should handle complex polyline with multiple intersections', () => {
+		const a1 = new Vec(0, 5)
+		const a2 = new Vec(20, 5)
+		const points = [
+			new Vec(2, 0),
+			new Vec(2, 10),
+			new Vec(8, 10),
+			new Vec(8, 0),
+			new Vec(12, 0),
+			new Vec(12, 10),
+			new Vec(18, 10),
+			new Vec(18, 0),
+		]
+		const result = intersectLineSegmentPolyline(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(4)
+		// Should intersect at x=2, x=8, x=12, x=18
+		const sorted = result!.slice().sort((a, b) => a.x - b.x)
+		expect(sorted[0].x).toBeCloseTo(2, 5)
+		expect(sorted[1].x).toBeCloseTo(8, 5)
+		expect(sorted[2].x).toBeCloseTo(12, 5)
+		expect(sorted[3].x).toBeCloseTo(18, 5)
+		sorted.forEach((pt) => expect(pt.y).toBeCloseTo(5, 5))
+	})
+
+	// Test cases for vertex intersection issues
+	describe('vertex intersection edge cases', () => {
+		it('should detect intersection when line segment passes through polyline vertex', () => {
+			const a1 = new Vec(0, 5)
+			const a2 = new Vec(10, 5)
+			const points = [new Vec(5, 0), new Vec(5, 10)] // vertical line at x=5
+			const result = intersectLineSegmentPolyline(a1, a2, points)
+			expect(result).not.toBeNull()
+			expect(result!.length).toBe(1)
+			expect(result![0].x).toBeCloseTo(5, 5)
+			expect(result![0].y).toBeCloseTo(5, 5)
+		})
+
+		it('should detect intersection when line segment passes through polyline vertex at angle', () => {
+			const a1 = new Vec(0, 0)
+			const a2 = new Vec(10, 10)
+			const points = [new Vec(5, 0), new Vec(5, 10)] // vertical line at x=5
+			const result = intersectLineSegmentPolyline(a1, a2, points)
+			expect(result).not.toBeNull()
+			expect(result!.length).toBe(1)
+			expect(result![0].x).toBeCloseTo(5, 5)
+			expect(result![0].y).toBeCloseTo(5, 5)
+		})
+
+		it('should detect intersection when line segment passes through polyline vertex at middle', () => {
+			const a1 = new Vec(0, 5)
+			const a2 = new Vec(10, 5)
+			const points = [new Vec(0, 0), new Vec(5, 5), new Vec(10, 0)] // vertex at (5,5)
+			const result = intersectLineSegmentPolyline(a1, a2, points)
+			expect(result).not.toBeNull()
+			expect(result!.length).toBe(1)
+			expect(result![0].x).toBeCloseTo(5, 5)
+			expect(result![0].y).toBeCloseTo(5, 5)
+		})
+
+		it('should detect intersection when line segment passes through a polyline vertext (floating point error case)', () => {
+			const result = intersectLineSegmentPolyline({ x: 100, y: 100 }, { x: 20, y: 20 }, [
+				{ x: 36.141160159025375, y: 31.811740238538057 },
+				{ x: 34.14213562373095, y: 34.14213562373095 },
+				{ x: 31.811740238538057, y: 36.141160159025375 },
+			])
+
+			expect(result).not.toBeNull()
+		})
+	})
+})
+
+describe('intersectLineSegmentPolygon', () => {
+	it('should return null when no intersection with polygon', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 0)
+		const points = [new Vec(5, 5), new Vec(6, 5), new Vec(6, 6), new Vec(5, 6)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return multiple intersection points', () => {
+		const a1 = new Vec(0, 5)
+		const a2 = new Vec(10, 5)
+		const points = [new Vec(2, 0), new Vec(2, 10), new Vec(8, 10), new Vec(8, 0)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+		const sorted = result!.slice().sort((a, b) => a.x - b.x)
+		expect(sorted[0].x).toBeCloseTo(2, 5)
+		expect(sorted[1].x).toBeCloseTo(8, 5)
+		sorted.forEach((pt) => expect(pt.y).toBeCloseTo(5, 5))
+	})
+
+	it('should return null when segment is entirely inside the polygon', () => {
+		const a1 = new Vec(3, 3)
+		const a2 = new Vec(4, 4)
+		const points = [new Vec(2, 2), new Vec(6, 2), new Vec(6, 6), new Vec(2, 6)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null when segment is entirely outside the polygon', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 1)
+		const points = [new Vec(2, 2), new Vec(6, 2), new Vec(6, 6), new Vec(2, 6)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return intersection points when segment crosses polygon boundary', () => {
+		const a1 = new Vec(0, 5)
+		const a2 = new Vec(10, 5)
+		const points = [new Vec(2, 0), new Vec(2, 10), new Vec(8, 10), new Vec(8, 0)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+	})
+
+	it('should return null for empty polygon', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 1)
+		const points: VecLike[] = []
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null for single point polygon', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(1, 1)
+		const points = [new Vec(5, 5)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return single intersection at exit corner', () => {
+		const a1 = new Vec(0, 0)
+		const a2 = new Vec(10, 10)
+		const points = [new Vec(0, 10), new Vec(10, 10), new Vec(10, 0), new Vec(0, 0)]
+		const result = intersectLineSegmentPolygon(a1, a2, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(10, 5)
+		expect(result![0].y).toBeCloseTo(10, 5)
+	})
+})
+
+describe('intersectCircleCircle', () => {
+	it('should return two points when circles intersect', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(8, 0)
+		const r2 = 5
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		expect(result.length).toBe(2)
+		// Both points should be at x=4, y=+/-3
+		const sorted = result.slice().sort((a, b) => a.y - b.y)
+		expect(sorted[0].x).toBeCloseTo(4, 5)
+		expect(sorted[0].y).toBeCloseTo(-3, 5)
+		expect(sorted[1].x).toBeCloseTo(4, 5)
+		expect(sorted[1].y).toBeCloseTo(3, 5)
+	})
+
+	it('should return two identical points when circles are tangent', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(10, 0)
+		const r2 = 5
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		expect(result.length).toBe(2)
+		// Both points should be at (5, 0)
+		expect(result[0].x).toBeCloseTo(5, 5)
+		expect(result[0].y).toBeCloseTo(0, 5)
+		expect(result[1].x).toBeCloseTo(5, 5)
+		expect(result[1].y).toBeCloseTo(0, 5)
+	})
+
+	it('should return two points when circles intersect at an angle', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(5, 5)
+		const r2 = 5
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		expect(result.length).toBe(2)
+	})
+
+	it('should return NaN points for concentric circles', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(0, 0)
+		const r2 = 3
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		result.forEach((pt) => {
+			expect(Number.isNaN(pt.x)).toBe(true)
+			expect(Number.isNaN(pt.y)).toBe(true)
+		})
+	})
+
+	it('should return two points for identical circles', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(0, 0)
+		const r2 = 5
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		result.forEach((pt) => {
+			expect(Number.isNaN(pt.x)).toBe(true)
+			expect(Number.isNaN(pt.y)).toBe(true)
+		})
+	})
+
+	it('should return two NaN points when one circle is inside another', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(1, 0)
+		const r2 = 1
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		result.forEach((pt) => {
+			expect(Number.isNaN(pt.x)).toBe(true)
+			expect(Number.isNaN(pt.y)).toBe(true)
+		})
+	})
+
+	it('should return two NaN points when circles are too far apart', () => {
+		const c1 = new Vec(0, 0)
+		const r1 = 5
+		const c2 = new Vec(20, 0)
+		const r2 = 5
+		const result = intersectCircleCircle(c1, r1, c2, r2)
+		expect(result).not.toBeNull()
+		result.forEach((pt) => {
+			expect(Number.isNaN(pt.x)).toBe(true)
+			expect(Number.isNaN(pt.y)).toBe(true)
+		})
+	})
+})
+
+describe('intersectCirclePolygon', () => {
+	it('should return null when circle does not intersect polygon', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points = [new Vec(5, 5), new Vec(6, 5), new Vec(6, 6), new Vec(5, 6)]
+		const result = intersectCirclePolygon(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return single intersection point (tangent)', () => {
+		const c = new Vec(0, 0)
+		const r = 5
+		const points = [new Vec(5, 0), new Vec(10, 0), new Vec(10, 10), new Vec(5, 10)]
+		const result = intersectCirclePolygon(c, r, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(5, 5)
+		expect(result![0].y).toBeCloseTo(0, 5)
+	})
+
+	it('should return null when circle is entirely inside polygon', () => {
+		const c = new Vec(5, 5)
+		const r = 1
+		const points = [new Vec(2, 2), new Vec(8, 2), new Vec(8, 8), new Vec(2, 8)]
+		const result = intersectCirclePolygon(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null when circle is entirely outside polygon', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points = [new Vec(5, 5), new Vec(8, 5), new Vec(8, 8), new Vec(5, 8)]
+		const result = intersectCirclePolygon(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null for empty polygon', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points: VecLike[] = []
+		const result = intersectCirclePolygon(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null for complex polygon when circle is inside', () => {
+		const c = new Vec(5, 5)
+		const r = 3
+		const points = [new Vec(2, 2), new Vec(8, 2), new Vec(8, 8), new Vec(2, 8)]
+		const result = intersectCirclePolygon(c, r, points)
+		expect(result).toBeNull()
+	})
+})
+
+describe('intersectCirclePolyline', () => {
+	it('should return null when circle does not intersect polyline', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points = [new Vec(5, 5), new Vec(6, 5), new Vec(6, 6), new Vec(5, 6)]
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return single intersection point (tangent)', () => {
+		const c = new Vec(0, 0)
+		const r = 5
+		const points = [new Vec(5, 0), new Vec(10, 0)]
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(5, 5)
+		expect(result![0].y).toBeCloseTo(0, 5)
+	})
+
+	it('should return two intersection points', () => {
+		const c = new Vec(0, 0)
+		const r = 5
+		const points = [new Vec(-10, 0), new Vec(10, 0)]
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+		const sorted = result!.slice().sort((a, b) => a.x - b.x)
+		expect(sorted[0].x).toBeCloseTo(-5, 5)
+		expect(sorted[1].x).toBeCloseTo(5, 5)
+		sorted.forEach((pt) => expect(pt.y).toBeCloseTo(0, 5))
+	})
+
+	it('should return null for empty polyline', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points: VecLike[] = []
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null for single point polyline', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points = [new Vec(5, 5)]
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null when circle is entirely inside polyline area', () => {
+		const c = new Vec(5, 5)
+		const r = 1
+		const points = [new Vec(2, 2), new Vec(8, 2), new Vec(8, 8), new Vec(2, 8)]
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).toBeNull()
+	})
+
+	it('should return null when circle is entirely outside polyline area', () => {
+		const c = new Vec(0, 0)
+		const r = 1
+		const points = [new Vec(5, 5), new Vec(8, 5), new Vec(8, 8), new Vec(5, 8)]
+		const result = intersectCirclePolyline(c, r, points)
+		expect(result).toBeNull()
+	})
+})
+
+describe('intersectPolygonPolygon', () => {
+	it('should return null for disjoint polygons', () => {
+		const polyA = [new Vec(0, 0), new Vec(2, 0), new Vec(2, 2), new Vec(0, 2)]
+		const polyB = [new Vec(5, 5), new Vec(7, 5), new Vec(7, 7), new Vec(5, 7)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).toBeNull()
+	})
+
+	it('should return intersection polygon for overlapping squares', () => {
+		const polyA = [new Vec(0, 0), new Vec(4, 0), new Vec(4, 4), new Vec(0, 4)]
+		const polyB = [new Vec(2, 2), new Vec(6, 2), new Vec(6, 6), new Vec(2, 6)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(4)
+		// Should be the square from (2,2) to (4,4)
+		const xs = result!.map((pt) => pt.x).sort((a, b) => a - b)
+		const ys = result!.map((pt) => pt.y).sort((a, b) => a - b)
+		expect(xs[0]).toBeCloseTo(2, 5)
+		expect(xs[3]).toBeCloseTo(4, 5)
+		expect(ys[0]).toBeCloseTo(2, 5)
+		expect(ys[3]).toBeCloseTo(4, 5)
+	})
+
+	it('should return contained polygon when one is inside another', () => {
+		const polyA = [new Vec(0, 0), new Vec(10, 0), new Vec(10, 10), new Vec(0, 10)]
+		const polyB = [new Vec(2, 2), new Vec(8, 2), new Vec(8, 8), new Vec(2, 8)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(4)
+		const xs = result!.map((pt) => pt.x).sort((a, b) => a - b)
+		const ys = result!.map((pt) => pt.y).sort((a, b) => a - b)
+		expect(xs[0]).toBeCloseTo(2, 5)
+		expect(xs[3]).toBeCloseTo(8, 5)
+		expect(ys[0]).toBeCloseTo(2, 5)
+		expect(ys[3]).toBeCloseTo(8, 5)
+	})
+
+	it('should return single point when polygons touch at a point', () => {
+		const polyA = [new Vec(0, 0), new Vec(2, 0), new Vec(2, 2), new Vec(0, 2)]
+		const polyB = [new Vec(2, 2), new Vec(4, 2), new Vec(4, 4), new Vec(2, 4)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(1)
+		expect(result![0].x).toBeCloseTo(2, 5)
+		expect(result![0].y).toBeCloseTo(2, 5)
+	})
+
+	it('should return shared edge when polygons share an edge', () => {
+		const polyA = [new Vec(0, 0), new Vec(2, 0), new Vec(2, 2), new Vec(0, 2)]
+		const polyB = [new Vec(2, 0), new Vec(4, 0), new Vec(4, 2), new Vec(2, 2)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(2)
+		const xs = result!.map((pt) => pt.x).sort((a, b) => a - b)
+		const ys = result!.map((pt) => pt.y).sort((a, b) => a - b)
+		expect(xs[0]).toBeCloseTo(2, 5)
+		expect(xs[1]).toBeCloseTo(2, 5)
+		expect(ys[0]).toBeCloseTo(0, 5)
+		expect(ys[1]).toBeCloseTo(2, 5)
+	})
+
+	it('should return all points for identical polygons', () => {
+		const polyA = [new Vec(0, 0), new Vec(2, 0), new Vec(2, 2), new Vec(0, 2)]
+		const polyB = [new Vec(0, 0), new Vec(2, 0), new Vec(2, 2), new Vec(0, 2)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).not.toBeNull()
+		expect(result!.length).toBe(4)
+	})
+
+	it('should return null for degenerate polygons (single point)', () => {
+		const polyA = [new Vec(0, 0)]
+		const polyB = [new Vec(1, 1), new Vec(2, 2), new Vec(3, 3)]
+		const result = intersectPolygonPolygon(polyA, polyB)
+		expect(result).toBeNull()
+	})
+})