js-draw 0.18.2 → 0.20.0

package/src/math/Rect2.test.ts

@@ -1,204 +0,0 @@
-
-import Rect2 from './Rect2';
-import { Vec2 } from './Vec2';
-import Mat33 from './Mat33';
-
-describe('Rect2', () => {
-	it('width, height should always be positive', () => {
-		expect(new Rect2(-1, -2, -3, 4)).objEq(new Rect2(-4, -2, 3, 4));
-		expect(new Rect2(0, 0, 0, 0).size).objEq(Vec2.zero);
-		expect(Rect2.fromCorners(
-			Vec2.of(-3, -3),
-			Vec2.of(-1, -1)
-		)).objEq(new Rect2(
-			-3, -3,
-			2, 2
-		));
-	});
-
-	it('bounding boxes should be correctly computed', () => {
-		expect(Rect2.bboxOf([
-			Vec2.zero,
-		])).objEq(Rect2.empty);
-
-		expect(Rect2.bboxOf([
-			Vec2.of(-1, -1),
-			Vec2.of(1, 2),
-			Vec2.of(3, 4),
-			Vec2.of(1, -4),
-		])).objEq(new Rect2(
-			-1, -4,
-			4, 8
-		));
-
-		expect(Rect2.bboxOf([
-			Vec2.zero,
-		], 10)).objEq(new Rect2(
-			-10, -10,
-			20, 20
-		));
-	});
-
-	it('"union"s should contain both composite rectangles.', () => {
-		expect(new Rect2(0, 0, 1, 1).union(new Rect2(1, 1, 2, 2))).objEq(
-			new Rect2(0, 0, 3, 3)
-		);
-		expect(Rect2.empty.union(Rect2.empty)).objEq(Rect2.empty);
-	});
-
-	it('should handle empty unions', () => {
-		expect(Rect2.union()).toStrictEqual(Rect2.empty);
-	});
-
-	it('should correctly union multiple rectangles', () => {
-		expect(Rect2.union(new Rect2(0, 0, 1, 1), new Rect2(1, 1, 2, 2))).objEq(
-			new Rect2(0, 0, 3, 3)
-		);
-
-		expect(
-			Rect2.union(new Rect2(-1, 0, 1, 1), new Rect2(1, 1, 2, 2), new Rect2(1, 10, 1, 0.1))
-		).objEq(
-			new Rect2(-1, 0, 4, 10.1)
-		);
-
-		expect(
-			Rect2.union(new Rect2(-1, 0, 1, 1), new Rect2(1, -11.1, 2, 2), new Rect2(1, 10, 1, 0.1))
-		).objEq(
-			new Rect2(-1, -11.1, 4, 21.2)
-		);
-	});
-
-	it('should contain points that are within a rectangle', () => {
-		expect(new Rect2(-1, -1, 2, 2).containsPoint(Vec2.zero)).toBe(true);
-		expect(new Rect2(-1, -1, 0, 0).containsPoint(Vec2.zero)).toBe(false);
-		expect(new Rect2(1, 2, 3, 4).containsRect(Rect2.empty)).toBe(false);
-		expect(new Rect2(1, 2, 3, 4).containsRect(new Rect2(1, 2, 1, 2))).toBe(true);
-		expect(new Rect2(-2, -2, 4, 4).containsRect(new Rect2(-1, 0, 1, 1))).toBe(true);
-		expect(new Rect2(-2, -2, 4, 4).containsRect(new Rect2(-1, 0, 10, 1))).toBe(false);
-	});
-
-	describe('containsRect', () => {
-		it('a rectangle should contain itself', () => {
-			const rect = new Rect2(1 / 3, 1 / 4, 1 / 5, 1 / 6);
-			expect(rect.containsRect(rect)).toBe(true);
-		});
-
-		it('empty rect should not contain a larger rect', () => {
-			expect(Rect2.empty.containsRect(new Rect2(-1, -1, 3, 3))).toBe(false);
-		});
-
-		it('should correctly contain rectangles', () => {
-			const testRect = new Rect2(4, -10, 50, 100);
-			expect(testRect.containsRect(new Rect2(4.1, 0, 1, 1))).toBe(true);
-			expect(testRect.containsRect(new Rect2(48, 0, 1, 1))).toBe(true);
-			expect(testRect.containsRect(new Rect2(48, -9, 1, 1))).toBe(true);
-			expect(testRect.containsRect(new Rect2(48, -9, 1, 91))).toBe(true);
-		});
-	});
-
-	it('intersecting rectangles should be identified as intersecting', () => {
-		expect(new Rect2(-1, -1, 2, 2).intersects(Rect2.empty)).toBe(true);
-		expect(new Rect2(-1, -1, 2, 2).intersects(new Rect2(0, 0, 1, 1))).toBe(true);
-		expect(new Rect2(-1, -1, 2, 2).intersects(new Rect2(0, 0, 10, 10))).toBe(true);
-		expect(new Rect2(-1, -1, 2, 2).intersects(new Rect2(3, 3, 10, 10))).toBe(false);
-		expect(new Rect2(-1, -1, 2, 2).intersects(new Rect2(0.2, 0.1, 0, 0))).toBe(true);
-		expect(new Rect2(-100, -1, 200, 2).intersects(new Rect2(-5, -5, 10, 30))).toBe(true);
-		expect(new Rect2(-100, -1, 200, 2).intersects(new Rect2(-5, 50, 10, 30))).toBe(false);
-	});
-
-	it('intersecting rectangles should have their intersections correctly computed', () => {
-		expect(new Rect2(-1, -1, 2, 2).intersection(Rect2.empty)).objEq(Rect2.empty);
-		expect(new Rect2(-1, -1, 2, 2).intersection(new Rect2(0, 0, 3, 3))).objEq(
-			new Rect2(0, 0, 1, 1)
-		);
-		expect(new Rect2(-2, 0, 1, 2).intersection(new Rect2(-3, 0, 2, 2))).objEq(
-			new Rect2(-2, 0, 1, 2)
-		);
-		expect(new Rect2(-1, -1, 2, 2).intersection(new Rect2(3, 3, 10, 10))).toBe(null);
-	});
-
-	it('A transformed bounding box', () => {
-		const rotationMat = Mat33.zRotation(Math.PI / 4);
-		const rect = Rect2.unitSquare.translatedBy(Vec2.of(-0.5, -0.5));
-		const transformedBBox = rect.transformedBoundingBox(rotationMat);
-		expect(transformedBBox.containsPoint(Vec2.of(0.5, 0.5)));
-		expect(transformedBBox.containsRect(rect)).toBe(true);
-	});
-
-	describe('should correctly expand to include a given point', () => {
-		it('Growing an empty rectange to include (1, 0)', () => {
-			const originalRect = Rect2.empty;
-			const grownRect = originalRect.grownToPoint(Vec2.unitX);
-			expect(grownRect).objEq(new Rect2(0, 0, 1, 0));
-		});
-
-		it('Growing the unit rectangle to include (-5, 1), with a margin', () => {
-			const originalRect = Rect2.unitSquare;
-			const grownRect = originalRect.grownToPoint(Vec2.of(-5, 1), 4);
-			expect(grownRect).objEq(new Rect2(-9, -3, 10, 8));
-		});
-
-		it('Growing to include a point just above', () => {
-			const original = Rect2.unitSquare;
-			const grown = original.grownToPoint(Vec2.of(-1, -1));
-			expect(grown).objEq(new Rect2(-1, -1, 2, 2));
-		});
-
-		it('Growing to include a point just below', () => {
-			const original = Rect2.unitSquare;
-			const grown = original.grownToPoint(Vec2.of(2, 2));
-			expect(grown).objEq(new Rect2(0, 0, 2, 2));
-		});
-	});
-
-	describe('divideIntoGrid', () => {
-		it('division of unit square', () => {
-			expect(Rect2.unitSquare.divideIntoGrid(2, 2)).toMatchObject(
-				[
-					new Rect2(0, 0, 0.5, 0.5), new Rect2(0.5, 0, 0.5, 0.5),
-					new Rect2(0, 0.5, 0.5, 0.5), new Rect2(0.5, 0.5, 0.5, 0.5),
-				]
-			);
-			expect(Rect2.unitSquare.divideIntoGrid(0, 0).length).toBe(0);
-			expect(Rect2.unitSquare.divideIntoGrid(100, 0).length).toBe(0);
-			expect(Rect2.unitSquare.divideIntoGrid(4, 1)).toMatchObject(
-				[
-					new Rect2(0, 0, 0.25, 1), new Rect2(0.25, 0, 0.25, 1),
-					new Rect2(0.5, 0, 0.25, 1), new Rect2(0.75, 0, 0.25, 1),
-				]
-			);
-		});
-		it('division of translated square', () => {
-			expect(new Rect2(3, -3, 4, 4).divideIntoGrid(2, 1)).toMatchObject(
-				[
-					new Rect2(3, -3, 2, 4), new Rect2(5, -3, 2, 4),
-				]
-			);
-		});
-		it('division of empty square', () => {
-			expect(Rect2.empty.divideIntoGrid(1000, 10000).length).toBe(1);
-		});
-
-		it('division of rectangle', () => {
-			expect(new Rect2(0, 0, 2, 1).divideIntoGrid(2, 2)).toMatchObject(
-				[
-					new Rect2(0, 0, 1, 0.5), new Rect2(1, 0, 1, 0.5),
-					new Rect2(0, 0.5, 1, 0.5), new Rect2(1, 0.5, 1, 0.5),
-				]
-			);
-		});
-	});
-
-	describe('should correctly return the closest point on the edge of a rectangle', () => {
-		it('with the unit square', () => {
-			const rect = Rect2.unitSquare;
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.zero)).objEq(Vec2.zero);
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.of(-1, -1))).objEq(Vec2.zero);
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.of(-1, 0.5))).objEq(Vec2.of(0, 0.5));
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.of(1, 0.5))).objEq(Vec2.of(1, 0.5));
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.of(0.6, 0.6))).objEq(Vec2.of(1, 0.6));
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.of(2, 0.5))).objEq(Vec2.of(1, 0.5));
-			expect(rect.getClosestPointOnBoundaryTo(Vec2.of(0.6, 0.6))).objEq(Vec2.of(1, 0.6));
-		});
-	});
-});

package/src/math/Rect2.ts

@@ -1,315 +0,0 @@
-import LineSegment2 from './LineSegment2';
-import Mat33 from './Mat33';
-import { Point2, Vec2 } from './Vec2';
-
-/** An object that can be converted to a Rect2. */
-export interface RectTemplate {
-	x: number;
-	y: number;
-	w?: number;
-	h?: number;
-	width?: number;
-	height?: number;
-}
-
-// invariant: w ≥ 0, h ≥ 0.
-export default class Rect2 {
-	// Derived state:
-
-	// topLeft assumes up is -y
-	public readonly topLeft: Point2;
-	public readonly size: Vec2;
-	public readonly bottomRight: Point2;
-	public readonly center: Point2;
-	public readonly area: number;
-
-	public constructor(
-		public readonly x: number,
-		public readonly y: number,
-		public readonly w: number,
-		public readonly h: number
-	) {
-		if (w < 0) {
-			this.x += w;
-			this.w = Math.abs(w);
-		}
-
-		if (h < 0) {
-			this.y += h;
-			this.h = Math.abs(h);
-		}
-
-		// Precompute/store vector forms.
-		this.topLeft = Vec2.of(this.x, this.y);
-		this.size = Vec2.of(this.w, this.h);
-		this.bottomRight = this.topLeft.plus(this.size);
-		this.center = this.topLeft.plus(this.size.times(0.5));
-		this.area = this.w * this.h;
-	}
-
-	public translatedBy(vec: Vec2): Rect2 {
-		return new Rect2(vec.x + this.x, vec.y + this.y, this.w, this.h);
-	}
-
-	// Returns a copy of this with the given size (but same top-left).
-	public resizedTo(size: Vec2): Rect2 {
-		return new Rect2(this.x, this.y, size.x, size.y);
-	}
-
-	public containsPoint(other: Point2): boolean {
-		return this.x <= other.x && this.y <= other.y
-			&& this.x + this.w >= other.x && this.y + this.h >= other.y;
-	}
-
-	public containsRect(other: Rect2): boolean {
-		return this.x <= other.x && this.y <= other.y
-				&& this.bottomRight.x >= other.bottomRight.x
-				&& this.bottomRight.y >= other.bottomRight.y;
-	}
-
-	public intersects(other: Rect2): boolean {
-		// Project along x/y axes.
-		const thisMinX = this.x;
-		const thisMaxX = thisMinX + this.w;
-		const otherMinX = other.x;
-		const otherMaxX = other.x + other.w;
-
-		if (thisMaxX < otherMinX || thisMinX > otherMaxX) {
-			return false;
-		}
-
-
-		const thisMinY = this.y;
-		const thisMaxY = thisMinY + this.h;
-		const otherMinY = other.y;
-		const otherMaxY = other.y + other.h;
-
-		if (thisMaxY < otherMinY || thisMinY > otherMaxY) {
-			return false;
-		}
-
-		return true;
-	}
-
-	// Returns the overlap of this and [other], or null, if no such
-	//          overlap exists
-	public intersection(other: Rect2): Rect2|null {
-		if (!this.intersects(other)) {
-			return null;
-		}
-
-		const topLeft = this.topLeft.zip(other.topLeft, Math.max);
-		const bottomRight = this.bottomRight.zip(other.bottomRight, Math.min);
-
-		return Rect2.fromCorners(topLeft, bottomRight);
-	}
-
-	// Returns a new rectangle containing both [this] and [other].
-	public union(other: Rect2): Rect2 {
-		const topLeft = this.topLeft.zip(other.topLeft, Math.min);
-		const bottomRight = this.bottomRight.zip(other.bottomRight, Math.max);
-
-		return Rect2.fromCorners(
-			topLeft,
-			bottomRight
-		);
-	}
-
-	// Returns a the subdivision of this into [columns] columns
-	// and [rows] rows. For example,
-	//	 Rect2.unitSquare.divideIntoGrid(2, 2)
-	//		-> [ Rect2(0, 0, 0.5, 0.5), Rect2(0.5, 0, 0.5, 0.5), Rect2(0, 0.5, 0.5, 0.5), Rect2(0.5, 0.5, 0.5, 0.5) ]
-	// The rectangles are ordered in row-major order.
-	public divideIntoGrid(columns: number, rows: number): Rect2[] {
-		const result: Rect2[] = [];
-		if (columns <= 0 || rows <= 0) {
-			return result;
-		}
-
-		const eachRectWidth = this.w / columns;
-		const eachRectHeight = this.h / rows;
-
-		if (eachRectWidth === 0) {
-			columns = 1;
-		}
-		if (eachRectHeight === 0) {
-			rows = 1;
-		}
-
-		for (let j = 0; j < rows; j++) {
-			for (let i = 0; i < columns; i++) {
-				const x = eachRectWidth * i + this.x;
-				const y = eachRectHeight * j + this.y;
-				result.push(new Rect2(x, y, eachRectWidth, eachRectHeight));
-			}
-		}
-		return result;
-	}
-
-	// Returns a rectangle containing this and [point].
-	// [margin] is the minimum distance between the new point and the edge
-	// of the resultant rectangle.
-	public grownToPoint(point: Point2, margin: number = 0): Rect2 {
-		const otherRect = new Rect2(
-			point.x - margin, point.y - margin,
-			margin * 2, margin * 2
-		);
-		return this.union(otherRect);
-	}
-
-	// Returns this grown by [margin] in both the x and y directions.
-	public grownBy(margin: number): Rect2 {
-		return new Rect2(
-			this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2
-		);
-	}
-
-	public getClosestPointOnBoundaryTo(target: Point2) {
-		const closestEdgePoints = this.getEdges().map(edge => {
-			return edge.closestPointTo(target);
-		});
-
-		let closest: Point2|null = null;
-		let closestDist: number|null = null;
-		for (const point of closestEdgePoints) {
-			const dist = point.minus(target).length();
-			if (closestDist === null || dist < closestDist) {
-				closest = point;
-				closestDist = dist;
-			}
-		}
-		return closest!;
-	}
-
-	public get corners(): Point2[] {
-		return [
-			this.bottomRight,
-			this.topRight,
-			this.topLeft,
-			this.bottomLeft,
-		];
-	}
-
-	public get maxDimension() {
-		return Math.max(this.w, this.h);
-	}
-
-	public get topRight() {
-		return this.bottomRight.plus(Vec2.of(0, -this.h));
-	}
-
-	public get bottomLeft() {
-		return this.topLeft.plus(Vec2.of(0, this.h));
-	}
-
-	public get width() {
-		return this.w;
-	}
-
-	public get height() {
-		return this.h;
-	}
-
-	// Returns edges in the order
-	// [ rightEdge, topEdge, leftEdge, bottomEdge ]
-	public getEdges(): LineSegment2[] {
-		const corners = this.corners;
-		return [
-			new LineSegment2(corners[0], corners[1]),
-			new LineSegment2(corners[1], corners[2]),
-			new LineSegment2(corners[2], corners[3]),
-			new LineSegment2(corners[3], corners[0]),
-		];
-	}
-
-	// [affineTransform] is a transformation matrix that both scales and **translates**.
-	// the bounding box of this' four corners after transformed by the given affine transformation.
-	public transformedBoundingBox(affineTransform: Mat33): Rect2 {
-		return Rect2.bboxOf(this.corners.map(corner => affineTransform.transformVec2(corner)));
-	}
-
-	/** @return true iff this is equal to [other] ± fuzz */
-	public eq(other: Rect2, fuzz: number = 0): boolean {
-		return this.topLeft.eq(other.topLeft, fuzz) && this.size.eq(other.size, fuzz);
-	}
-
-	public toString(): string {
-		return `Rect(point(${this.x}, ${this.y}), size(${this.w}, ${this.h}))`;
-	}
-
-
-	public static fromCorners(corner1: Point2, corner2: Point2) {
-		return new Rect2(
-			Math.min(corner1.x, corner2.x),
-			Math.min(corner1.y, corner2.y),
-			Math.abs(corner1.x - corner2.x),
-			Math.abs(corner1.y - corner2.y)
-		);
-	}
-
-	// Returns a box that contains all points in [points] with at least [margin]
-	// between each point and the edge of the box.
-	public static bboxOf(points: Point2[], margin: number = 0) {
-		let minX = 0;
-		let minY = 0;
-		let maxX = 0;
-		let maxY = 0;
-		let isFirst = true;
-
-		for (const point of points) {
-			if (isFirst) {
-				minX = point.x;
-				minY = point.y;
-				maxX = point.x;
-				maxY = point.y;
-
-				isFirst = false;
-			}
-
-			minX = Math.min(minX, point.x);
-			minY = Math.min(minY, point.y);
-			maxX = Math.max(maxX, point.x);
-			maxY = Math.max(maxY, point.y);
-		}
-
-		return Rect2.fromCorners(
-			Vec2.of(minX - margin, minY - margin),
-			Vec2.of(maxX + margin, maxY + margin)
-		);
-	}
-
-	// @returns a rectangle that contains all of the given rectangles, the bounding box
-	//     of the given rectangles.
-	public static union(...rects: Rect2[]): Rect2 {
-		if (rects.length === 0) {
-			return Rect2.empty;
-		}
-
-		const firstRect = rects[0];
-		let minX: number = firstRect.topLeft.x;
-		let minY: number = firstRect.topLeft.y;
-		let maxX: number = firstRect.bottomRight.x;
-		let maxY: number = firstRect.bottomRight.y;
-
-		for (let i = 1; i < rects.length; i++) {
-			const rect = rects[i];
-			minX = Math.min(minX, rect.topLeft.x);
-			minY = Math.min(minY, rect.topLeft.y);
-			maxX = Math.max(maxX, rect.bottomRight.x);
-			maxY = Math.max(maxY, rect.bottomRight.y);
-		}
-
-		return new Rect2(
-			minX, minY, maxX - minX, maxY - minY,
-		);
-	}
-
-	public static of(template: RectTemplate) {
-		const width = template.width ?? template.w ?? 0;
-		const height = template.height ?? template.h ?? 0;
-		return new Rect2(template.x, template.y, width, height);
-	}
-
-	public static empty = new Rect2(0, 0, 0, 0);
-	public static unitSquare = new Rect2(0, 0, 1, 1);
-}

package/src/math/Triangle.ts

@@ -1,29 +0,0 @@
-import Mat33 from './Mat33';
-import Vec3 from './Vec3';
-
-export default class Triangle {
-	public constructor(
-        public readonly vertex1: Vec3,
-        public readonly vertex2: Vec3,
-        public readonly vertex3: Vec3,
-	) {}
-
-	public map(mapping: (vertex: Vec3)=>Vec3): Triangle {
-		return new Triangle(
-			mapping(this.vertex1),
-			mapping(this.vertex2),
-			mapping(this.vertex3),
-		);
-	}
-
-	// Transform, treating this as composed of 2D points.
-	public transformed2DBy(affineTransform: Mat33) {
-		return this.map(affineTransform.transformVec2);
-	}
-
-	// Transforms this by a linear transform --- verticies are treated as
-	// 3D points.
-	public transformedBy(linearTransform: Mat33) {
-		return this.map(linearTransform.transformVec3);
-	}
-}

package/src/math/Vec2.test.ts

@@ -1,30 +0,0 @@
-import { Vec2 } from './Vec2';
-import Vec3 from './Vec3';
-
-describe('Vec2', () => {
-	it('Magnitude', () => {
-		expect(Vec2.of(3, 4).magnitude()).toBe(5);
-	});
-
-	it('Addition', () => {
-		expect(Vec2.of(1, 2).plus(Vec2.of(3, 4))).objEq(Vec2.of(4, 6));
-	});
-
-	it('Multiplication', () => {
-		expect(Vec2.of(1, -1).times(22)).objEq(Vec2.of(22, -22));
-	});
-
-	it('More complicated expressions', () => {
-		expect((Vec2.of(1, 2).plus(Vec2.of(3, 4))).times(2)).objEq(Vec2.of(8, 12));
-	});
-
-	it('Angle', () => {
-		expect(Vec2.of(-1, 1).angle()).toBeCloseTo(3 * Math.PI / 4);
-	});
-
-	it('Perpindicular', () => {
-		const fuzz = 0.001;
-		expect(Vec2.unitX.cross(Vec3.unitZ)).objEq(Vec2.unitY.times(-1), fuzz);
-		expect(Vec2.unitX.orthog()).objEq(Vec2.unitY, fuzz);
-	});
-});

package/src/math/Vec2.ts

@@ -1,18 +0,0 @@
-import Vec3 from './Vec3';
-
-export namespace Vec2 {
-	export const of = (x: number, y: number): Vec2 => {
-		return Vec3.of(x, y, 0);
-	};
-
-	export const ofXY = ({x, y}: { x: number, y: number }): Vec2 => {
-		return Vec3.of(x, y, 0);
-	};
-
-	export const unitX = Vec2.of(1, 0);
-	export const unitY = Vec2.of(0, 1);
-	export const zero = Vec2.of(0, 0);
-}
-
-export type Point2 = Vec3;
-export type Vec2 = Vec3; // eslint-disable-line

package/src/math/Vec3.test.ts

@@ -1,44 +0,0 @@
-
-import Vec3 from './Vec3';
-
-describe('Vec3', () => {
-	it('.xy should contain the x and y components', () => {
-		const vec = Vec3.of(1, 2, 3);
-		expect(vec.xy).toMatchObject({
-			x: 1,
-			y: 2,
-		});
-	});
-
-	it('should be combinable with other vectors via .zip', () => {
-		const vec1 = Vec3.unitX;
-		const vec2 = Vec3.unitY;
-		expect(vec1.zip(vec2, Math.min)).objEq(Vec3.zero);
-		expect(vec1.zip(vec2, Math.max)).objEq(Vec3.of(1, 1, 0));
-	});
-
-	it('.cross should obey the right hand rule', () => {
-		const vec1 = Vec3.unitX;
-		const vec2 = Vec3.unitY;
-		expect(vec1.cross(vec2)).objEq(Vec3.unitZ);
-		expect(vec2.cross(vec1)).objEq(Vec3.unitZ.times(-1));
-	});
-
-	it('.orthog should return an orthogonal vector', () => {
-		expect(Vec3.unitZ.orthog().dot(Vec3.unitZ)).toBe(0);
-
-		// Should return some orthogonal vector, even if given the zero vector
-		expect(Vec3.zero.orthog().dot(Vec3.zero)).toBe(0);
-	});
-
-	it('.minus should return the difference between two vectors', () => {
-		expect(Vec3.of(1, 2, 3).minus(Vec3.of(4, 5, 6))).objEq(Vec3.of(1 - 4, 2 - 5, 3 - 6));
-	});
-
-	it('.orthog should return a unit vector', () => {
-		expect(Vec3.zero.orthog().magnitude()).toBe(1);
-		expect(Vec3.unitZ.orthog().magnitude()).toBe(1);
-		expect(Vec3.unitX.orthog().magnitude()).toBe(1);
-		expect(Vec3.unitY.orthog().magnitude()).toBe(1);
-	});
-});