update some stuff

@zemn.me/math/matrix.ts

@@ -5,15 +5,15 @@ import * as vec from './vec'
 export interface Matrix<
 	I extends number = number,
 	J extends number = number,
-	T = number
+	T = number,
 > extends Vector<J, Vector<I, T>> {}
 
 export type Square<IJ extends number, T = number> = Matrix<IJ, IJ, T>
 
 export const as: <
 	I extends number = number,
 	J extends number = number,
-	T = number
+	T = number,
 >(
 	v: readonly (readonly T[] & { length: I })[] & { length: J },
 ) => Matrix<I, J, T> = (v) => v as any
@@ -73,15 +73,15 @@ export const mul: <
 	I1 extends number,
 	J1 extends number,
 	I2 extends number,
-	J2 extends number
+	J2 extends number,
 >(
 	m1: Matrix<I1, J1>,
 	m2: Matrix<I2, J2>,
 ) => Multiply<Matrix<I1, J1>, Matrix<I2, J2>> = <
 	I1 extends number,
 	J1 extends number,
 	I2 extends number,
-	J2 extends number
+	J2 extends number,
 >(
 	m1: Matrix<I1, J1>,
 	m2: Matrix<I2, J2>,
@@ -162,7 +162,7 @@ function mustIsSquare<T>(
 export type Multiply<
 	A extends Matrix<number, number, unknown>,
 	B extends Matrix<number, number, unknown>,
-	O = number
+	O = number,
 > = [A, B] extends [
 	Matrix<infer I1, infer J1, unknown>,
 	Matrix<infer I2, infer J2, unknown>,
@@ -177,7 +177,7 @@ export type Multiply<
 export type TransformTo<
 	In extends Matrix<number, number, unknown>,
 	Out extends Matrix<number, number, unknown>,
-	O = number
+	O = number,
 > = [In, Out] extends [
 	Matrix<infer I1, infer J1, unknown>,
 	Matrix<infer I2, infer J2, unknown>,
@@ -264,7 +264,7 @@ export const checkerboard: <I extends number, J extends number>(
  * Returns the inverse of a matrix of given dimensions
  */
 export const inverse: <IJ extends number>(m: Square<IJ>) => Square<IJ> = <
-	IJ extends number
+	IJ extends number,
 >(
 	m: Square<IJ>,
 ) => {

@zemn.me/math/shape/3d.ts

@@ -41,18 +41,17 @@ class As3D<T extends Canvas.Drawable2D> implements Canvas.Drawable3D {
 	constructor(public readonly target: T) {}
 	public lines3D(): Homog.Line3D[] {
 		return this.target.lines2D().map((line) =>
-			line.map(
-				(point: Homog.Point2D): Homog.Point3D => {
-					const [[x], [y], [scale]] = point
-					return [[x], [y], [0], [scale]] as const
-				},
-			),
+			line.map((point: Homog.Point2D): Homog.Point3D => {
+				const [[x], [y], [scale]] = point
+				return [[x], [y], [0], [scale]] as const
+			}),
 		)
 	}
 }
 
 export class Translate3D<T extends Canvas.Drawable3D>
-	implements Canvas.Drawable3D {
+	implements Canvas.Drawable3D
+{
 	constructor(public readonly target: T, public readonly by: Homog.Point3D) {}
 
 	public lines3D(): Homog.Line3D[] {

@zemn.me/math/shape/index.ts

@@ -0,0 +1,110 @@
+import * as Homog from '../homog'
+import * as Camera from '../camera'
+import * as Matrix from '../matrix'
+import * as Canvas from '../canvas'
+
+export class Square implements Canvas.Drawable2D {
+	public readonly r: number
+	public readonly d: number
+	get width() {
+		return this.d
+	}
+	constructor(width: number) {
+		this.d = width
+		this.r = this.d / 2
+	}
+	public TL(): Homog.Point2D {
+		return [[-this.r], [this.r], [1]] as const
+	}
+	public TR(): Homog.Point2D {
+		return [[this.r], [this.r], [1]] as const
+	}
+	public BL(): Homog.Point2D {
+		return [[-this.r], [-this.r], [1]] as const
+	}
+	public BR(): Homog.Point2D {
+		return [[this.r], [-this.r], [1]] as const
+	}
+	public lines2D() {
+		const ret: Homog.Line2D = [
+			this.TL(),
+			this.TR(),
+			this.BR(),
+			this.BL(),
+			this.TL(),
+		]
+		return [ret]
+	}
+}
+
+class As3D<T extends Canvas.Drawable2D> implements Canvas.Drawable3D {
+	constructor(public readonly target: T) {}
+	public lines3D(): Homog.Line3D[] {
+		return this.target.lines2D().map((line) =>
+			line.map((point: Homog.Point2D): Homog.Point3D => {
+				const [[x], [y], [scale]] = point
+				return [[x], [y], [0], [scale]] as const
+			}),
+		)
+	}
+}
+
+export class Translate3D<T extends Canvas.Drawable3D>
+	implements Canvas.Drawable3D
+{
+	constructor(public readonly target: T, public readonly by: Homog.Point3D) {}
+
+	public lines3D(): Homog.Line3D[] {
+		return this.target
+			.lines3D()
+			.map((line) => line.map((point) => Matrix.add(point, this.by)))
+	}
+}
+
+export class Cube implements Canvas.Drawable3D {
+	private readonly square: Square
+	constructor(public readonly diameter: number) {
+		this.square = new Square(diameter)
+	}
+
+	lines3D() {
+		const A = new Translate3D(new As3D(this.square), [
+			[0],
+			[0],
+			[-this.diameter],
+			[1],
+		] as const)
+		const B = new Translate3D(new As3D(this.square), [
+			[0],
+			[0],
+			[this.diameter],
+			[1],
+		] as const)
+		const [[ATL, ATR, ABR, ABL]] = A.lines3D()
+		const [[BTL, BTR, BBR, BBL]] = B.lines3D()
+
+		return [
+			...A.lines3D(),
+			...B.lines3D(),
+			[ATL, BTL],
+			[ATR, BTR],
+			[ABR, BBR],
+			[ABL, BBL],
+		]
+	}
+}
+
+export class Project<T extends Canvas.Drawable3D> implements Canvas.Drawable2D {
+	constructor(
+		public readonly value: T,
+		public readonly focalLength?: number,
+	) {}
+
+	lines2D() {
+		return this.value
+			.lines3D()
+			.map((line) =>
+				line.map((point) => Camera.transform(point, this.focalLength)),
+			)
+	}
+}

@zemn.me/math/vec.ts

@@ -37,20 +37,19 @@ export const imap: <T, U>(
 /**
  * Returns an iterable on a vector that iterates in reverse
  */
-export const reverse: <I extends number, T>(
-	v: Vector<I, T>,
-) => Iterable<T> = function* (v) {
-	for (let i = 0; i < v.length; i++) {
-		yield v[v.length - i - 1]
+export const reverse: <I extends number, T>(v: Vector<I, T>) => Iterable<T> =
+	function* (v) {
+		for (let i = 0; i < v.length; i++) {
+			yield v[v.length - i - 1]
+		}
 	}
-}
 
 export const as: <T, L extends number>(
 	v: readonly T[] & { length: L },
 ) => Vector<L, T> = (v) => v as any
 
 export const New: <N extends number>(n: number) => Vector<N, undefined> = (n) =>
-	([...Array(n)] as any) as Vector<any, undefined>
+	[...Array(n)] as any as Vector<any, undefined>
 
 export const add: <I extends number>(
 	v1: Vector<I>,

@zemn.me/path-scale/index.ts

@@ -34,7 +34,8 @@ type Filter<T, T2> = Pick<
 >
 
 export class Generator<cfg extends object>
-	implements Scalable<cfg & { width: number; height: number }> {
+	implements Scalable<cfg & { width: number; height: number }>
+{
 	scalable: Scalable<cfg>
 	keys: (keyof Filter<cfg, number>)[]
 	props: Scalable<cfg & { width: number; height: number }>['props']
@@ -56,7 +57,7 @@ export class Generator<cfg extends object>
 
 		const copy = { ...cfg }
 
-		for (const key of this.keys) ((copy[key] as any) as number) *= k
+		for (const key of this.keys) (copy[key] as any as number) *= k
 		return copy
 	}
 

@zemn.me/svg/index.tsx

@@ -15,7 +15,7 @@ export interface Canvas extends ReadonlyArray<Node> {}
 export type Scalar = number
 export type Path<
 	L extends number = number,
-	kind extends Cartesian | Homogenous = Cartesian
+	kind extends Cartesian | Homogenous = Cartesian,
 > = vector.Vector<L, kind>
 
 export type Cartesian = vector.Vector<2, number>

@zemn.me/typeutil/index.ts

@@ -1,14 +1,13 @@
 export type Upgrade<T1, T2> = Omit<T1, keyof T2> & T2
 
-export const assertInvalidNever: (what: string) => (v: never) => void = (
-	what,
-) => (v: never): asserts v is never => {
-	throw InvalidNever(v)
-}
+export const assertInvalidNever: (what: string) => (v: never) => void =
+	(what) =>
+	(v: never): asserts v is never => {
+		throw InvalidNever(v)
+	}
 
 export const InvalidNever = (what: string) => (v: never) =>
 	new Error(`Invalid ${what} ${v}`)
 
-export type ElementProperties<
-	T extends keyof JSX.IntrinsicElements
-> = JSX.IntrinsicElements[T]
+export type ElementProperties<T extends keyof JSX.IntrinsicElements> =
+	JSX.IntrinsicElements[T]

etc/updateDepIfTestsPass.sh

@@ -0,0 +1,3 @@
+yarn upgrade -L $1
+git add -A
+git commit -m "upgrade $1" -n

lib/guards.ts

@@ -82,7 +82,7 @@ export function hasMember<
 	K extends string | number | symbol,
 	I,
 	O extends I,
-	args extends unknown[]
+	args extends unknown[],
 >(
 	k: K,
 	t: (v: I, ...args: args) => v is O,

linear2/features/elements/CodeBlock/index.tsx

@@ -24,19 +24,19 @@ declare module 'react-syntax-highlighter' {
 	}
 
 	type Properties<
-		T extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements
+		T extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements,
 	> = { className: string[] } & Omit<JSX.IntrinsicElements[T], 'className'>
 
 	type Element<
-		T extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements
+		T extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements,
 	> = __Element & { tagName: T }
 
 	type __Element = ValueOf<
 		{ [k in keyof JSX.IntrinsicElements]: _Element<k> }
 	>
 
 	interface _Element<
-		T extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements
+		T extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements,
 	> {
 		type: 'element'
 		tagName: T

linear2/features/elements/elements.tsx

@@ -31,13 +31,14 @@ type ClassableElements = Filter<JSX.IntrinsicElements, { className?: string }>
 
 const e: <
 	E extends keyof ClassableElements,
-	K extends keyof ClassableElements[E]
+	K extends keyof ClassableElements[E],
 >(
 	name: E,
 	...propNames: K[]
-) => React.FC<ClassableElements[E]> = (e, ...k) => (props) => (
-	<Style>{React.createElement(e, pick(props, ...k))}</Style>
-)
+) => React.FC<ClassableElements[E]> =
+	(e, ...k) =>
+	(props) =>
+		<Style>{React.createElement(e, pick(props, ...k))}</Style>
 type PropsOf<T extends React.FC<unknown>> = T extends React.FC<infer Q>
 	? Q
 	: never

linear2/features/elements/headingsAndSections/fancy.tsx

@@ -3,7 +3,7 @@ import React from 'react'
 import { classes } from 'linear2/features/elements/util'
 
 export interface HeadingProps<
-	depth extends 1 | 2 | 3 | 4 | 5 = 1 | 2 | 3 | 4 | 5
+	depth extends 1 | 2 | 3 | 4 | 5 = 1 | 2 | 3 | 4 | 5,
 > {
 	heading: React.ReactElement
 	subtitle?: React.ReactElement

linear2/features/elements/headingsAndSections/headingsAndSections.tsx

@@ -112,9 +112,8 @@ export const useText: () => [
 	return [onElementMount, text]
 }
 
-export type HeadingElement<
-	T extends HeaderComponent = HeaderComponent
-> = React.ReactElement<HeadingProps & RefAttributes<HTMLHeadingElement>, T>
+export type HeadingElement<T extends HeaderComponent = HeaderComponent> =
+	React.ReactElement<HeadingProps & RefAttributes<HTMLHeadingElement>, T>
 
 export function mergeRefs<T = any>(
 	...refs: Array<React.MutableRefObject<T> | React.LegacyRef<T>>

linear2/features/elements/text.tsx

@@ -33,9 +33,8 @@ export const WithLang: (props: WithLangProps) => React.ReactElement = ({
 	return React.cloneElement(children, { ...children.props, ...useLang(lang) })
 }
 
-export const withTextContext = React.createContext<model.lang.Text | undefined>(
-	undefined,
-)
+export const withTextContext =
+	React.createContext<model.lang.Text | undefined>(undefined)
 export interface WithTextProps {
 	text?: model.lang.Text
 	children: React.ReactElement<{ lang?: string }>

linear2/features/elements/timeline/components.tsx

@@ -29,10 +29,8 @@ export const makeYears: (b: Bio['timeline']) => Year[] = (timeline) => {
 			event,
 		)
 
-	const yearsToMonths: Map<
-		number,
-		Map<model.time.date.Month, BioEvent[]>
-	> = new Map()
+	const yearsToMonths: Map<number, Map<model.time.date.Month, BioEvent[]>> =
+		new Map()
 
 	// i made this operation higher level and it made even
 	// less sense, for which i am sorry