@tldraw/editor 3.13.0-canary.c0afd1f5aa1e → 3.13.0-canary.c4135f4903f5

package/src/lib/primitives/geometry/Arc2d.ts

@@ -1,4 +1,4 @@
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { intersectLineSegmentCircle } from '../intersect'
 import { getArcMeasure, getPointInArcT, getPointOnCircle } from '../utils'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
@@ -44,14 +44,14 @@ export class Arc2d extends Geometry2d {
 		this._center = center
 	}
 
-	nearestPoint(point: VecLike): Vec {
+	nearestPoint(point: Vec): Vec {
 		const { _center, measure, radius, angleEnd, angleStart, start: A, end: B } = this
 		const t = getPointInArcT(measure, angleStart, angleEnd, _center.angle(point))
 		if (t <= 0) return A
 		if (t >= 1) return B
 
 		// Get the point (P) on the arc, then pick the nearest of A, B, and P
-		const P = Vec.Sub(point, _center).uni().mul(radius).add(_center)
+		const P = _center.clone().add(point.clone().sub(_center).uni().mul(radius))
 
 		let nearest: Vec | undefined
 		let dist = Infinity
@@ -67,7 +67,7 @@ export class Arc2d extends Geometry2d {
 		return nearest
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike): boolean {
+	hitTestLineSegment(A: Vec, B: Vec): boolean {
 		const { _center, radius, measure, angleStart, angleEnd } = this
 		const intersection = intersectLineSegmentCircle(A, B, _center, radius)
 		if (intersection === null) return false
@@ -95,6 +95,6 @@ export class Arc2d extends Geometry2d {
 	}
 
 	override getLength() {
-		return Math.abs(this.measure * this.radius)
+		return this.measure * this.radius
 	}
 }

package/src/lib/primitives/geometry/Circle2d.ts

@@ -1,5 +1,5 @@
 import { Box } from '../Box'
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { intersectLineSegmentCircle } from '../intersect'
 import { PI2, getPointOnCircle } from '../utils'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
@@ -43,13 +43,13 @@ export class Circle2d extends Geometry2d {
 		return vertices
 	}
 
-	nearestPoint(point: VecLike): Vec {
+	nearestPoint(point: Vec): Vec {
 		const { _center, radius } = this
 		if (_center.equals(point)) return Vec.AddXY(_center, radius, 0)
-		return Vec.Sub(point, _center).uni().mul(radius).add(_center)
+		return _center.clone().add(point.clone().sub(_center).uni().mul(radius))
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike, distance = 0): boolean {
+	hitTestLineSegment(A: Vec, B: Vec, distance = 0): boolean {
 		const { _center, radius } = this
 		return intersectLineSegmentCircle(A, B, _center, radius + distance) !== null
 	}

package/src/lib/primitives/geometry/CubicBezier2d.ts

@@ -1,5 +1,5 @@
-import { Vec, VecLike } from '../Vec'
-import { Geometry2dFilters, Geometry2dOptions } from './Geometry2d'
+import { Vec } from '../Vec'
+import { Geometry2dOptions } from './Geometry2d'
 import { Polyline2d } from './Polyline2d'
 
 /** @public */
@@ -52,7 +52,7 @@ export class CubicBezier2d extends Polyline2d {
 		return CubicBezier2d.GetAtT(this, 0.5)
 	}
 
-	nearestPoint(A: VecLike): Vec {
+	nearestPoint(A: Vec): Vec {
 		let nearest: Vec | undefined
 		let dist = Infinity
 		let d: number
@@ -89,7 +89,7 @@ export class CubicBezier2d extends Polyline2d {
 		)
 	}
 
-	override getLength(filters?: Geometry2dFilters, precision = 32) {
+	override getLength(precision = 32) {
 		let n1: Vec,
 			p1 = this.a,
 			length = 0

package/src/lib/primitives/geometry/CubicSpline2d.ts

@@ -1,4 +1,4 @@
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { CubicBezier2d } from './CubicBezier2d'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
@@ -58,7 +58,7 @@ export class CubicSpline2d extends Geometry2d {
 		return vertices
 	}
 
-	nearestPoint(A: VecLike): Vec {
+	nearestPoint(A: Vec): Vec {
 		let nearest: Vec | undefined
 		let dist = Infinity
 		let d: number
@@ -75,7 +75,7 @@ export class CubicSpline2d extends Geometry2d {
 		return nearest
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike): boolean {
+	hitTestLineSegment(A: Vec, B: Vec): boolean {
 		return this.segments.some((segment) => segment.hitTestLineSegment(A, B))
 	}
 

package/src/lib/primitives/geometry/Edge2d.ts

@@ -1,5 +1,5 @@
+import { Vec } from '../Vec'
 import { linesIntersect } from '../intersect'
-import { Vec, VecLike } from '../Vec'
 import { Geometry2d } from './Geometry2d'
 
 /** @public */
@@ -34,7 +34,7 @@ export class Edge2d extends Geometry2d {
 		return [this.start, this.end]
 	}
 
-	override nearestPoint(point: VecLike): Vec {
+	override nearestPoint(point: Vec): Vec {
 		const { start, end, d, u, ul: l } = this
 		if (d.len() === 0) return start // start and end are the same
 		if (l === 0) return start // no length in the unit vector
@@ -48,7 +48,7 @@ export class Edge2d extends Geometry2d {
 		return new Vec(cx, cy)
 	}
 
-	override hitTestLineSegment(A: VecLike, B: VecLike, distance = 0): boolean {
+	override hitTestLineSegment(A: Vec, B: Vec, distance = 0): boolean {
 		return (
 			linesIntersect(A, B, this.start, this.end) || this.distanceToLineSegment(A, B) <= distance
 		)

package/src/lib/primitives/geometry/Ellipse2d.ts

@@ -1,5 +1,5 @@
 import { Box } from '../Box'
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { PI, PI2, perimeterOfEllipse } from '../utils'
 import { Edge2d } from './Edge2d'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
@@ -73,7 +73,7 @@ export class Ellipse2d extends Geometry2d {
 		return vertices
 	}
 
-	nearestPoint(A: VecLike): Vec {
+	nearestPoint(A: Vec): Vec {
 		let nearest: Vec | undefined
 		let dist = Infinity
 		let d: number
@@ -90,7 +90,7 @@ export class Ellipse2d extends Geometry2d {
 		return nearest
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike): boolean {
+	hitTestLineSegment(A: Vec, B: Vec): boolean {
 		return this.edges.some((edge) => edge.hitTestLineSegment(A, B))
 	}
 

package/src/lib/primitives/geometry/Geometry2d.ts

@@ -1,4 +1,4 @@
-import { assert, invLerp } from '@tldraw/utils'
+import { assert } from '@tldraw/utils'
 import { Box } from '../Box'
 import { Mat, MatModel } from '../Mat'
 import { Vec, VecLike } from '../Vec'
@@ -81,9 +81,9 @@ export abstract class Geometry2d {
 
 	abstract getVertices(filters: Geometry2dFilters): Vec[]
 
-	abstract nearestPoint(point: VecLike, _filters?: Geometry2dFilters): Vec
+	abstract nearestPoint(point: Vec, _filters?: Geometry2dFilters): Vec
 
-	hitTestPoint(point: VecLike, margin = 0, hitInside = false, _filters?: Geometry2dFilters) {
+	hitTestPoint(point: Vec, margin = 0, hitInside = false, _filters?: Geometry2dFilters) {
 		// First check whether the point is inside
 		if (this.isClosed && (this.isFilled || hitInside) && pointInPolygon(point, this.vertices)) {
 			return true
@@ -92,17 +92,17 @@ export abstract class Geometry2d {
 		return Vec.Dist2(point, this.nearestPoint(point)) <= margin * margin
 	}
 
-	distanceToPoint(point: VecLike, hitInside = false, filters?: Geometry2dFilters) {
+	distanceToPoint(point: Vec, hitInside = false, filters?: Geometry2dFilters) {
 		return (
-			Vec.Dist(point, this.nearestPoint(point, filters)) *
+			point.dist(this.nearestPoint(point, filters)) *
 			(this.isClosed && (this.isFilled || hitInside) && pointInPolygon(point, this.vertices)
 				? -1
 				: 1)
 		)
 	}
 
-	distanceToLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters) {
-		if (Vec.Equals(A, B)) return this.distanceToPoint(A, false, filters)
+	distanceToLineSegment(A: Vec, B: Vec, filters?: Geometry2dFilters) {
+		if (A.equals(B)) return this.distanceToPoint(A, false, filters)
 		const { vertices } = this
 		let nearest: Vec | undefined
 		let dist = Infinity
@@ -120,7 +120,7 @@ export abstract class Geometry2d {
 		return this.isClosed && this.isFilled && pointInPolygon(nearest, this.vertices) ? -dist : dist
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike, distance = 0, filters?: Geometry2dFilters): boolean {
+	hitTestLineSegment(A: Vec, B: Vec, distance = 0, filters?: Geometry2dFilters): boolean {
 		return this.distanceToLineSegment(A, B, filters) <= distance
 	}
 
@@ -148,76 +148,8 @@ export abstract class Geometry2d {
 		return intersectPolys(polyline, this.vertices, false, this.isClosed)
 	}
 
-	/**
-	 * Find a point along the edge of the geometry that is a fraction `t` along the entire way round.
-	 */
-	interpolateAlongEdge(t: number, _filters?: Geometry2dFilters): Vec {
-		const { vertices } = this
-
-		if (t <= 0) return vertices[0]
-
-		const distanceToTravel = t * this.length
-		let distanceTraveled = 0
-
-		for (let i = 0; i < (this.isClosed ? vertices.length : vertices.length - 1); i++) {
-			const curr = vertices[i]
-			const next = vertices[(i + 1) % vertices.length]
-			const dist = Vec.Dist(curr, next)
-			const newDistanceTraveled = distanceTraveled + dist
-			if (newDistanceTraveled >= distanceToTravel) {
-				const p = Vec.Lrp(
-					curr,
-					next,
-					invLerp(distanceTraveled, newDistanceTraveled, distanceToTravel)
-				)
-				return p
-			}
-			distanceTraveled = newDistanceTraveled
-		}
-
-		return this.isClosed ? vertices[0] : vertices[vertices.length - 1]
-	}
-
-	/**
-	 * Take `point`, find the closest point to it on the edge of the geometry, and return how far
-	 * along the edge it is as a fraction of the total length.
-	 */
-	uninterpolateAlongEdge(point: VecLike, _filters?: Geometry2dFilters): number {
-		const { vertices, length } = this
-		let closestSegment = null
-		let closestDistance = Infinity
-		let distanceTraveled = 0
-
-		for (let i = 0; i < (this.isClosed ? vertices.length : vertices.length - 1); i++) {
-			const curr = vertices[i]
-			const next = vertices[(i + 1) % vertices.length]
-
-			const nearestPoint = Vec.NearestPointOnLineSegment(curr, next, point, true)
-			const distance = Vec.Dist(nearestPoint, point)
-
-			if (distance < closestDistance) {
-				closestDistance = distance
-				closestSegment = {
-					start: curr,
-					end: next,
-					nearestPoint,
-					distanceToStart: distanceTraveled,
-				}
-			}
-
-			distanceTraveled += Vec.Dist(curr, next)
-		}
-
-		assert(closestSegment)
-
-		const distanceAlongRoute =
-			closestSegment.distanceToStart + Vec.Dist(closestSegment.start, closestSegment.nearestPoint)
-
-		return distanceAlongRoute / length
-	}
-
 	/** @deprecated Iterate the vertices instead. */
-	nearestPointOnLineSegment(A: VecLike, B: VecLike): Vec {
+	nearestPointOnLineSegment(A: Vec, B: Vec): Vec {
 		const { vertices } = this
 		let nearest: Vec | undefined
 		let dist = Infinity
@@ -235,7 +167,7 @@ export abstract class Geometry2d {
 		return nearest
 	}
 
-	isPointInBounds(point: VecLike, margin = 0) {
+	isPointInBounds(point: Vec, margin = 0) {
 		const { bounds } = this
 		return !(
 			point.x < bounds.minX - margin ||
@@ -329,24 +261,21 @@ export abstract class Geometry2d {
 	// eslint-disable-next-line no-restricted-syntax
 	get length() {
 		if (this._length) return this._length
-		this._length = this.getLength(Geometry2dFilters.EXCLUDE_LABELS)
+		this._length = this.getLength()
 		return this._length
 	}
 
-	getLength(_filters?: Geometry2dFilters) {
-		const vertices = this.getVertices(_filters ?? Geometry2dFilters.EXCLUDE_LABELS)
-		if (vertices.length === 0) return 0
-		let prev = vertices[0]
-		let length = 0
+	getLength() {
+		const { vertices } = this
+		let n1: Vec,
+			p1 = vertices[0],
+			length = 0
 		for (let i = 1; i < vertices.length; i++) {
-			const next = vertices[i]
-			length += Vec.Dist(prev, next)
-			prev = next
-		}
-		if (this.isClosed) {
-			length += Vec.Dist(vertices[vertices.length - 1], vertices[0])
+			n1 = vertices[i]
+			length += Vec.Dist2(p1, n1)
+			p1 = n1
 		}
-		return length
+		return Math.sqrt(length)
 	}
 
 	abstract getSvgPathData(first: boolean): string
@@ -388,7 +317,7 @@ export class TransformedGeometry2d extends Geometry2d {
 		return this.geometry.getVertices(filters).map((v) => Mat.applyToPoint(this.matrix, v))
 	}
 
-	nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec {
+	nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec {
 		return Mat.applyToPoint(
 			this.matrix,
 			this.geometry.nearestPoint(Mat.applyToPoint(this.inverse, point), filters)
@@ -396,7 +325,7 @@ export class TransformedGeometry2d extends Geometry2d {
 	}
 
 	override hitTestPoint(
-		point: VecLike,
+		point: Vec,
 		margin = 0,
 		hitInside?: boolean,
 		filters?: Geometry2dFilters
@@ -409,14 +338,14 @@ export class TransformedGeometry2d extends Geometry2d {
 		)
 	}
 
-	override distanceToPoint(point: VecLike, hitInside = false, filters?: Geometry2dFilters) {
+	override distanceToPoint(point: Vec, hitInside = false, filters?: Geometry2dFilters) {
 		return (
 			this.geometry.distanceToPoint(Mat.applyToPoint(this.inverse, point), hitInside, filters) *
 			this.decomposed.scaleX
 		)
 	}
 
-	override distanceToLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters) {
+	override distanceToLineSegment(A: Vec, B: Vec, filters?: Geometry2dFilters) {
 		return (
 			this.geometry.distanceToLineSegment(
 				Mat.applyToPoint(this.inverse, A),
@@ -426,12 +355,7 @@ export class TransformedGeometry2d extends Geometry2d {
 		)
 	}
 
-	override hitTestLineSegment(
-		A: VecLike,
-		B: VecLike,
-		distance = 0,
-		filters?: Geometry2dFilters
-	): boolean {
+	override hitTestLineSegment(A: Vec, B: Vec, distance = 0, filters?: Geometry2dFilters): boolean {
 		return this.geometry.hitTestLineSegment(
 			Mat.applyToPoint(this.inverse, A),
 			Mat.applyToPoint(this.inverse, B),
@@ -441,39 +365,27 @@ export class TransformedGeometry2d extends Geometry2d {
 	}
 
 	override intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters) {
-		return Mat.applyToPoints(
-			this.matrix,
-			this.geometry.intersectLineSegment(
-				Mat.applyToPoint(this.inverse, A),
-				Mat.applyToPoint(this.inverse, B),
-				filters
-			)
+		return this.geometry.intersectLineSegment(
+			Mat.applyToPoint(this.inverse, A),
+			Mat.applyToPoint(this.inverse, B),
+			filters
 		)
 	}
 
 	override intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters) {
-		return Mat.applyToPoints(
-			this.matrix,
-			this.geometry.intersectCircle(
-				Mat.applyToPoint(this.inverse, center),
-				radius / this.decomposed.scaleX,
-				filters
-			)
+		return this.geometry.intersectCircle(
+			Mat.applyToPoint(this.inverse, center),
+			radius / this.decomposed.scaleX,
+			filters
 		)
 	}
 
 	override intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters): VecLike[] {
-		return Mat.applyToPoints(
-			this.matrix,
-			this.geometry.intersectPolygon(Mat.applyToPoints(this.inverse, polygon), filters)
-		)
+		return this.geometry.intersectPolygon(Mat.applyToPoints(this.inverse, polygon), filters)
 	}
 
 	override intersectPolyline(polyline: VecLike[], filters?: Geometry2dFilters): VecLike[] {
-		return Mat.applyToPoints(
-			this.matrix,
-			this.geometry.intersectPolyline(Mat.applyToPoints(this.inverse, polyline), filters)
-		)
+		return this.geometry.intersectPolyline(Mat.applyToPoints(this.inverse, polyline), filters)
 	}
 
 	override transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d {

package/src/lib/primitives/geometry/Group2d.ts

@@ -1,5 +1,4 @@
 import { EMPTY_ARRAY } from '@tldraw/state'
-import { assert, invLerp, lerp } from '@tldraw/utils'
 import { Box } from '../Box'
 import { Mat } from '../Mat'
 import { Vec, VecLike } from '../Vec'
@@ -35,7 +34,7 @@ export class Group2d extends Geometry2d {
 			.flatMap((c) => c.getVertices(filters))
 	}
 
-	override nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec {
+	override nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec {
 		let dist = Infinity
 		let nearest: Vec | undefined
 
@@ -60,7 +59,7 @@ export class Group2d extends Geometry2d {
 		return nearest
 	}
 
-	override distanceToPoint(point: VecLike, hitInside = false, filters?: Geometry2dFilters) {
+	override distanceToPoint(point: Vec, hitInside = false, filters?: Geometry2dFilters) {
 		let smallestDistance = Infinity
 		for (const child of this.children) {
 			if (child.isExcludedByFilter(filters)) continue
@@ -73,7 +72,7 @@ export class Group2d extends Geometry2d {
 	}
 
 	override hitTestPoint(
-		point: VecLike,
+		point: Vec,
 		margin: number,
 		hitInside: boolean,
 		filters = Geometry2dFilters.EXCLUDE_LABELS
@@ -84,8 +83,8 @@ export class Group2d extends Geometry2d {
 	}
 
 	override hitTestLineSegment(
-		A: VecLike,
-		B: VecLike,
+		A: Vec,
+		B: Vec,
 		zoom: number,
 		filters = Geometry2dFilters.EXCLUDE_LABELS
 	): boolean {
@@ -122,63 +121,6 @@ export class Group2d extends Geometry2d {
 		})
 	}
 
-	override interpolateAlongEdge(t: number, filters?: Geometry2dFilters): Vec {
-		const totalLength = this.getLength(filters)
-
-		const distanceToTravel = t * totalLength
-		let distanceTraveled = 0
-		for (const child of this.children) {
-			if (child.isExcludedByFilter(filters)) continue
-			const childLength = child.length
-			const newDistanceTraveled = distanceTraveled + childLength
-			if (newDistanceTraveled >= distanceToTravel) {
-				return child.interpolateAlongEdge(
-					invLerp(distanceTraveled, newDistanceTraveled, distanceToTravel),
-					filters
-				)
-			}
-			distanceTraveled = newDistanceTraveled
-		}
-
-		return this.children[this.children.length - 1].interpolateAlongEdge(1, filters)
-	}
-
-	override uninterpolateAlongEdge(point: VecLike, filters?: Geometry2dFilters): number {
-		const totalLength = this.getLength(filters)
-
-		let closestChild = null
-		let closestDistance = Infinity
-		let distanceTraveled = 0
-
-		for (const child of this.children) {
-			if (child.isExcludedByFilter(filters)) continue
-			const childLength = child.getLength(filters)
-			const newDistanceTraveled = distanceTraveled + childLength
-
-			const distance = child.distanceToPoint(point, false, filters)
-			if (distance < closestDistance) {
-				closestDistance = distance
-				closestChild = {
-					startLength: distanceTraveled,
-					endLength: newDistanceTraveled,
-					child,
-				}
-			}
-
-			distanceTraveled = newDistanceTraveled
-		}
-
-		assert(closestChild)
-
-		const normalizedDistanceInChild = closestChild.child.uninterpolateAlongEdge(point, filters)
-		const childTLength = lerp(
-			closestChild.startLength,
-			closestChild.endLength,
-			normalizedDistanceInChild
-		)
-		return childTLength / totalLength
-	}
-
 	override transform(transform: Mat): Geometry2d {
 		return new Group2d({
 			children: this.children.map((c) => c.transform(transform)),
@@ -218,13 +160,8 @@ export class Group2d extends Geometry2d {
 		return path
 	}
 
-	getLength(filters?: Geometry2dFilters): number {
-		let length = 0
-		for (const child of this.children) {
-			if (child.isExcludedByFilter(filters)) continue
-			length += child.length
-		}
-		return length
+	getLength(): number {
+		return this.children.reduce((a, c) => (c.isLabel ? a : a + c.length), 0)
 	}
 
 	getSvgPathData(): string {

package/src/lib/primitives/geometry/Point2d.ts

@@ -1,4 +1,4 @@
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
 /** @public */
@@ -22,7 +22,7 @@ export class Point2d extends Geometry2d {
 		return this.point
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike, margin: number): boolean {
+	hitTestLineSegment(A: Vec, B: Vec, margin: number): boolean {
 		return Vec.DistanceToLineSegment(A, B, this.point) < margin
 	}
 

package/src/lib/primitives/geometry/Polyline2d.ts

@@ -1,4 +1,4 @@
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { Edge2d } from './Edge2d'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
@@ -41,7 +41,7 @@ export class Polyline2d extends Geometry2d {
 		return this.points
 	}
 
-	nearestPoint(A: VecLike): Vec {
+	nearestPoint(A: Vec): Vec {
 		const { segments } = this
 		let nearest = this.points[0]
 		let dist = Infinity
@@ -59,7 +59,7 @@ export class Polyline2d extends Geometry2d {
 		return nearest
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike, distance = 0): boolean {
+	hitTestLineSegment(A: Vec, B: Vec, distance = 0): boolean {
 		const { segments } = this
 		for (let i = 0, n = segments.length; i < n; i++) {
 			if (segments[i].hitTestLineSegment(A, B, distance)) {

package/src/lib/primitives/geometry/Stadium2d.ts

@@ -1,5 +1,5 @@
 import { Box } from '../Box'
-import { Vec, VecLike } from '../Vec'
+import { Vec } from '../Vec'
 import { PI } from '../utils'
 import { Arc2d } from './Arc2d'
 import { Edge2d } from './Edge2d'
@@ -65,7 +65,7 @@ export class Stadium2d extends Geometry2d {
 		}
 	}
 
-	nearestPoint(A: VecLike): Vec {
+	nearestPoint(A: Vec): Vec {
 		let nearest: Vec | undefined
 		let dist = Infinity
 		let _d: number
@@ -84,7 +84,7 @@ export class Stadium2d extends Geometry2d {
 		return nearest
 	}
 
-	hitTestLineSegment(A: VecLike, B: VecLike): boolean {
+	hitTestLineSegment(A: Vec, B: Vec): boolean {
 		const { a, b, c, d } = this
 		return [a, b, c, d].some((edge) => edge.hitTestLineSegment(A, B))
 	}

package/src/lib/test/currentToolIdMask.test.ts

@@ -27,7 +27,7 @@ beforeEach(() => {
 		shapeUtils: [],
 		bindingUtils: [],
 		tools: [A, B, C],
-		store: createTLStore({ shapeUtils: [], bindingUtils: [] }),
+		store: createTLStore({ shapeUtils: [] }),
 		getContainer: () => document.body,
 	})
 })

package/src/lib/test/user.test.ts

@@ -8,7 +8,7 @@ beforeEach(() => {
 		shapeUtils: [],
 		bindingUtils: [],
 		tools: [],
-		store: createTLStore({ shapeUtils: [], bindingUtils: [] }),
+		store: createTLStore({ shapeUtils: [] }),
 		getContainer: () => document.body,
 	})
 })

package/src/lib/utils/debug-flags.ts

@@ -54,7 +54,6 @@ export const debugFlags = {
 	hideShapes: createDebugValue('hideShapes', { defaults: { all: false } }),
 	editOnType: createDebugValue('editOnType', { defaults: { all: false } }),
 	a11y: createDebugValue('a11y', { defaults: { all: false } }),
-	debugElbowArrows: createDebugValue('debugElbowArrows', { defaults: { all: false } }),
 } as const
 
 declare global {
@@ -150,9 +149,7 @@ function createDebugValueBase<T>(def: DebugFlagDef<T>): DebugFlag<T> {
 		})
 	}
 
-	return Object.assign(valueAtom, def, {
-		reset: () => valueAtom.set(defaultValue),
-	})
+	return Object.assign(valueAtom, def)
 }
 
 function getStoredInitialValue(name: string) {
@@ -209,6 +206,4 @@ export interface DebugFlagDef<T> {
 }
 
 /** @internal */
-export interface DebugFlag<T> extends DebugFlagDef<T>, Atom<T> {
-	reset(): void
-}
+export type DebugFlag<T> = DebugFlagDef<T> & Atom<T>

package/src/lib/utils/sync/LocalIndexedDb.test.ts

@@ -3,7 +3,7 @@ import { openDB } from 'idb'
 import { hardReset } from './hardReset'
 import { getAllIndexDbNames, LocalIndexedDb } from './LocalIndexedDb'
 
-const schema = createTLSchema({ shapes: {}, bindings: {} })
+const schema = createTLSchema({ shapes: {} })
 describe('LocalIndexedDb', () => {
 	beforeEach(() => {
 		jest.useRealTimers()