Rokay

doApd: (f: () => void) => void

If elements are potentially going to be added to the DOM, this function
should be called first and the elements should be appended within the
provided callback, which will be called synchronously. This ensures that
postApd works correctly. Note that match and mapHTML already handle
calling this function, and thus you probably should not ever need to use
this function is your own code.

postApd: (f: (el: T) => void) => (el: T) => void

This can be passed to an element that is being created. The callback is
called when the element has been added to the DOM.

accept: (val: string | number | boolean) => (el: Element) => void

action: (val: string | number | boolean) => (el: Element) => void

alt: (val: string | number | boolean) => (el: Element) => void

async: (el: HTMLScriptElement) => boolean

autocomplete: (val: "off" | "on") => (el: HTMLInputElement) => void

charset: (val: string | number | boolean) => (el: HTMLMetaElement) => void

checked: (checked: boolean) => (el: HTMLInputElement) => boolean

content: (val: string | number | boolean) => (el: Element) => void

controls: (el: HTMLVideoElement) => boolean

crossorigin: (val: string | number | boolean) => (el: Element) => void

datetime: (val: string | number | boolean) => (el: Element) => void

dbg: (val: string | number | boolean) => (el: Element) => void

defer: (el: HTMLScriptElement) => void

disable: (el: HTMLButtonElement | HTMLInputElement | HTMLTextAreaElement) => boolean

disabled: (disabled: any) => (el: HTMLButtonElement | HTMLInputElement | HTMLTextAreaElement) => boolean

download: (val: string | number | boolean) => (el: Element) => void

enable: (el: HTMLButtonElement | HTMLInputElement | HTMLTextAreaElement) => boolean

enabled: (enabled: any) => (el: HTMLButtonElement | HTMLInputElement | HTMLTextAreaElement) => boolean

height: (val: string | number | boolean) => (el: Element) => void

href: (val: string | number | boolean) => (el: Element) => void

id: (val: string | number | boolean) => (el: Element) => void

lang: (val: string | number | boolean) => (el: Element) => void

max: (val: string | number | boolean) => (el: HTMLInputElement) => void

min: (val: string | number | boolean) => (el: HTMLInputElement) => void

multiple: (el: HTMLInputElement) => boolean

name: (val: string | number | boolean) => (el: Element) => void

nonce: (val: string | number | boolean) => (el: Element) => void

placeholder: (val: string | number | boolean) => (el: Element) => void

poster: (val: string | number | boolean) => (el: HTMLVideoElement) => void

preload: (val: "auto" | "metadata" | "none") => (el: HTMLVideoElement) => void

rel: (val: string | number | boolean) => (el: Element) => void

rows: (val: string | number | boolean) => (el: Element) => void

rowspan: (val: string | number | boolean) => (el: Element) => void

size: (w: number, h?: number) => (el: Element) => Element

src: (val: string | number | boolean) => (el: Element) => void

srcObject: (srcObject: MediaProvider) => (el: HTMLMediaElement) => MediaProvider

step: (val: string | number | boolean) => (el: Element) => void

tabindex: (val: string | number | boolean) => (el: Element) => void

target: (val: string | number | boolean) => (el: Element) => void

title: (val: string | number | boolean) => (el: Element) => void

type: (val: string | number | boolean) => (el: Element) => void

value: (value: any) => (el: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement) => string

width: (val: string | number | boolean) => (el: Element) => void

cap: (prop: PropView, cb: (v: T) => ((el: U) => void) | undefined) => (el: U) => void

roughly $$, but captures and frees on each prop change

Capture: Capture

Capture: () => Capture

onDestroy: (f: () => void) => void

ApdArg: ApdArg

ApdArgs: ApdArgs

Cmt: Comment

Elt: Element

EltButton: HTMLButtonElement

EltDiv: HTMLDivElement

EltForm: HTMLFormElement

EltInput: HTMLInputElement

EltMedia: HTMLMediaElement

EltMeta: HTMLMetaElement

EltParagraph: HTMLParagraphElement

EltScript: HTMLScriptElement

EltSelect: HTMLSelectElement

EltStyle: HTMLStyleElement

EltTextArea: HTMLTextAreaElement

EltVideo: HTMLVideoElement

EltWithStyle: ElementCSSInlineStyle

Evt: Event

EvtBeforeUnload: BeforeUnloadEvent

EvtKeyboard: KeyboardEvent

EvtMouse: MouseEvent

EvtTgt: EventTarget

EvtTouch: TouchEvent

EvtTransition: TransitionEvent

Nod: Node

apd: (...chs: ApdArg[]) => (el: Node) => void

attr: (att: string) => (val: V) => (el: E) => void

clear: (el: Node) => string

cls: (cls: string) => (el: T) => void

clsIf: (cls: string) => (toggle: any) => (el: T) => boolean

com: (data: string) => Comment

elt: (t: K) => (...args: MixArgs) => HTMLElementTagNameMap[K]

html: (chs: ApdArg[]) => (el: Node) => Node

on: (ev: string) => (fn: (el: U, ev: T) => void) => (el: U) => () => void

NOTE: callbacks are cast to any as strict TS complains about the argument type not being strictly Event

once: (ev: string, cb: (el: U, ev: T) => void) => (el: U) => void

orphan: (el: Node) => Node | null

swap: (o: T, n: T) => T

style: (att: string) => (...vals: ("" | T)[]) => (el: T) => T

text: (val: any) => (el: T) => string

_form: (...args: MixArgs) => HTMLFormElement

_input: (...args: MixArgs) => HTMLInputElement

_link: (...args: MixArgs) => HTMLLinkElement

_meta: (...args: MixArgs) => HTMLMetaElement

_style: (...args: MixArgs) => HTMLStyleElement

a: (...args: MixArgs) => HTMLAnchorElement

address: (...args: MixArgs) => HTMLElement

aside: (...args: MixArgs) => HTMLElement

b: (...args: MixArgs) => HTMLElement

body: (...args: MixArgs) => HTMLBodyElement

br: (...args: MixArgs) => HTMLBRElement

button: (...args: MixArgs) => HTMLButtonElement

canvas: (...args: MixArgs) => HTMLCanvasElement

code: (...args: MixArgs) => HTMLElement

dd: (...args: MixArgs) => HTMLElement

div: (...args: MixArgs) => HTMLDivElement

dl: (...args: MixArgs) => HTMLDListElement

dt: (...args: MixArgs) => HTMLElement

figcaption: (...args: MixArgs) => HTMLElement

figure: (...args: MixArgs) => HTMLElement

footer: (...args: MixArgs) => HTMLElement

form: (...args: MixArgs) => HTMLFormElement

h1: (...args: MixArgs) => HTMLHeadingElement

h2: (...args: MixArgs) => HTMLHeadingElement

h3: (...args: MixArgs) => HTMLHeadingElement

h4: (...args: MixArgs) => HTMLHeadingElement

h5: (...args: MixArgs) => HTMLHeadingElement

h6: (...args: MixArgs) => HTMLHeadingElement

head: (...args: MixArgs) => HTMLHeadElement

header: (...args: MixArgs) => HTMLElement

hr: (...args: MixArgs) => HTMLHRElement

html: (...args: MixArgs) => HTMLHtmlElement

i: (...args: MixArgs) => HTMLElement

img: (...args: MixArgs) => HTMLImageElement

input: (_type: string, ...args: MixArgs) => HTMLInputElement

label: (...args: MixArgs) => HTMLLabelElement

li: (...args: MixArgs) => HTMLLIElement

link: (_rel: string, _href: string) => HTMLLinkElement

main: (...args: MixArgs) => HTMLElement

meta: (_name: string, _content: string) => HTMLMetaElement

nav: (...args: MixArgs) => HTMLElement

ol: (...args: MixArgs) => HTMLOListElement

option: (...args: MixArgs) => HTMLOptionElement

p: (...args: MixArgs) => HTMLParagraphElement

pre: (...args: MixArgs) => HTMLPreElement

script: (...args: MixArgs) => HTMLScriptElement

section: (...args: MixArgs) => HTMLElement

select: (...args: MixArgs) => HTMLSelectElement

small: (...args: MixArgs) => HTMLElement

span: (...args: MixArgs) => HTMLSpanElement

style: (...args: MixArgs) => HTMLStyleElement

submit: (...args: MixArgs) => HTMLButtonElement

table: (...args: MixArgs) => HTMLTableElement

tbody: (...args: MixArgs) => HTMLTableSectionElement

td: (...args: MixArgs) => HTMLTableCellElement

textarea: (...args: MixArgs) => HTMLTextAreaElement

tfoot: (...args: MixArgs) => HTMLTableSectionElement

th: (...args: MixArgs) => HTMLTableCellElement

thead: (...args: MixArgs) => HTMLTableSectionElement

time: (...args: MixArgs) => HTMLTimeElement

title: (...args: MixArgs) => HTMLTitleElement

tr: (...args: MixArgs) => HTMLTableRowElement

ul: (...args: MixArgs) => HTMLUListElement

video: (...args: MixArgs) => HTMLVideoElement

preventDefault: (el: EventTarget) => () => void

textCSS: (el: Element) => void

typeButton: (el: Element) => void

Fullscreen: () => PropView

Anim: Anim

Anim: (rate: number, frames?: number[] | undefined) => Anim

Animate: (anim: Anim) => (thing: Thing & Animate & Sprite) => void

Box: Box

BoxArgs: BoxArgs

BoxDims: BoxDims

Box: (args: BoxArgs) => (thing: Thing & BoxDims & WV) => void

BoxDebug: (thing: Thing & BoxDims & WV) => void

BoxDims: (args: BoxArgs) => { l: number; r: number; t: number; b: number; }

BoxRect: (x: number, y: number, w: number, h: number) => Box

includes: (bp: Readonly, b: BoxDims, p: Readonly) => boolean

overlaps: (ap: Readonly, a: BoxDims, bp: Readonly, b: BoxDims) => boolean

Camera: Camera

Camera: (focus: Readonly, getZoom: () => number, follow?: { pos: Readonly; }) => Camera

Ctx: CanvasRenderingContext2D

set: (att: T) => (val: CanvasRenderingContext2D[T]) => (ctx: CanvasRenderingContext2D) => CanvasRenderingContext2D[T]

align: (val: CanvasTextAlign) => (ctx: CanvasRenderingContext2D) => CanvasTextAlign

baseline: (val: CanvasTextBaseline) => (ctx: CanvasRenderingContext2D) => CanvasTextBaseline

bevel: (r: number, g: number, b: number, iterations: number) => (ctx: CanvasRenderingContext2D) => void

circle: (x: number, y: number, r: number) => (ctx: CanvasRenderingContext2D) => void

clear: (x: number, y: number, w: number, h: number) => (ctx: CanvasRenderingContext2D) => void

clearAll: (ctx: CanvasRenderingContext2D) => void

Danvas: (_width: number, _height: number, ...args: MixArgs) => HTMLCanvasElement

each: (start: number, end: number, step: number, cb: (i: number) => (ctx: CanvasRenderingContext2D) => void) => (el: CanvasRenderingContext2D) => CanvasRenderingContext2D

fills: (val: string | CanvasGradient | CanvasPattern) => (ctx: CanvasRenderingContext2D) => string | CanvasGradient | CanvasPattern

font: (val: string) => (ctx: CanvasRenderingContext2D) => string

image: (img: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number) => (ctx: CanvasRenderingContext2D) => void

move: (x: number, y: number) => (ctx: CanvasRenderingContext2D) => void

outline: (threshold?: number) => (ctx: CanvasRenderingContext2D) => void

parc: (x: number, y: number, r: number, start: number, end: number) => (ctx: CanvasRenderingContext2D) => void

pbegin: (ctx: CanvasRenderingContext2D) => void

pclip: (ctx: CanvasRenderingContext2D) => void

pend: (ctx: CanvasRenderingContext2D) => void

pfill: (ctx: CanvasRenderingContext2D) => void

pixel: (x: number, y: number) => (ctx: CanvasRenderingContext2D) => void

pixelCircle: (_x: number, _y: number, rx: number, ry?: number) => (ctx: CanvasRenderingContext2D) => void

pline: (x: number, y: number) => (ctx: CanvasRenderingContext2D) => void

plineJoin: (val: CanvasLineJoin) => (ctx: CanvasRenderingContext2D) => CanvasLineJoin

pmove: (x: number, y: number) => (ctx: CanvasRenderingContext2D) => void

pop: (ctx: CanvasRenderingContext2D) => void

pstroke: (ctx: CanvasRenderingContext2D) => void

push: (ctx: CanvasRenderingContext2D) => void

rect: (x: number, y: number, w: number, h: number) => (ctx: CanvasRenderingContext2D) => void

rotate: (ang: number) => (ctx: CanvasRenderingContext2D) => void

scale: (x: number, y: number) => (ctx: CanvasRenderingContext2D) => void

shrink: (ctx: CanvasRenderingContext2D) => void

solidify: (threshold?: number) => (ctx: CanvasRenderingContext2D) => void

strokeWidth: (val: number) => (ctx: CanvasRenderingContext2D) => number

strokes: (val: string | CanvasGradient | CanvasPattern) => (ctx: CanvasRenderingContext2D) => string | CanvasGradient | CanvasPattern

text: (text: string, x: number, y: number) => (ctx: CanvasRenderingContext2D) => void

withCtx: (...args: MixArgs) => (can: HTMLCanvasElement) => void

Game: (run: () => (dt: number) => void) => void

Group: (...members: T[]) => (group: Thing & Group) => void

addAll: (...things: T[]) => (group: Group) => void

Key: (key: string | number) => { down: () => boolean; justDown: () => boolean; }

initKeys: (el: Element) => () => void

Loop: (fn: () => void) => { destroy(): void; paused: () => boolean; start(): ...; stop(): ...; }

Moose: (el: T) => Moose

Physics: ({ drag, gravity }?: { drag?: number | undefined; gravity?: number | undefined; }) => (thing: Thing & WV & Physics) => void

physicsStep: (thing: { acc: Readonly; pos: Readonly; vel: Readonly; }, drag: Readonly, dt: number) => void

Pool: (get: (pool: Pool) => T) => (group: Thing & Pool) => void

ImageSource: (_src: string, ...args: MixArgs) => HTMLImageElement

img: (src: CanvasImageSource) => (ctx: CanvasRenderingContext2D) => void

init: () => Promise

Sprite: (img: HTMLCanvasElement | HTMLImageElement) => (thing: Thing & BoxDims & WV & Sprite) => void

Canvas: (w: number, h: number, ...args: MixArgs) => HTMLCanvasElement

Offset: (x: number, y: number) => (thing: Thing & Sprite) => void

SrcBox: (w: number, h?: number) => (thing: Thing & Sprite) => void

State: State

State: ({ enter, leave, step }?: Partial) => State

StateAfter: (seconds: number, after: () => void, { enter, leave, step }?: Partial) => State

StateProp: (initial: State) => Prop

nop: () => void

SyncMouse: SyncMouse

SyncMouse: () => SyncMouse

Thing: (...args: MixArgs) => T

RectangleData: (x: number, y: number, w: number, h: number) => Float32Array

RokayLocation: RokayLocation

RokayUniform1i: RokayUniform1i

RokayUniform2fv: RokayUniform2fv

RokayUniform4fv: RokayUniform4fv

RokayUniformMatrix3fv: RokayUniformMatrix3fv

RokayVertexAttribArray: RokayVertexAttribArray

RokayLocations: RokayLocations

Programmable: Programmable

RokayProgram: RokayProgram

RokayShader: RokayShader

FragmentShader: (gl: WebGLRenderingContext, src: string, locations: Programmable) => RokayShader

Program: (gl: WebGLRenderingContext, fragment: RokayShader, vertex: RokayShader) => RokayProgram<...>

Shader: (gl: WebGLRenderingContext, type: number, src: string, locations: Programmable) => RokayShader

Uniform1i: (gl: WebGLRenderingContext, program: WebGLProgram, name: string) => (i: number) => void

Uniform2fv: (gl: WebGLRenderingContext, program: WebGLProgram, name: string) => (v: [number, number]) => void

Uniform4fv: (gl: WebGLRenderingContext, program: WebGLProgram, name: string) => (v: [number, number, number, number]) => void

UniformLocation: (gl: WebGLRenderingContext, program: WebGLProgram, uniform: string) => WebGLUniformLocation

UniformMatrix3fv: (gl: WebGLRenderingContext, program: WebGLProgram, name: string) => (m: Matrix3D) => void

VertexAttribArray: (gl: WebGLRenderingContext, program: WebGLProgram, name: string) => RokayVertexAttribArray

VertexShader: (gl: WebGLRenderingContext, src: string, locations: Programmable) => RokayShader

RokayFramebuffer: RokayFramebuffer

RokayFramebuffers: RokayFramebuffers

RokayTexture: RokayTexture

Framebuffer: (gl: WebGLRenderingContext, width: number, height: number) => RokayFramebuffer

Framebuffers: (gl: WebGLRenderingContext, width: number, height: number) => RokayFramebuffers

Texture: (gl: WebGLRenderingContext, wrap?: number) => RokayTexture

withGL: (...args: MixArgs) => (can: HTMLCanvasElement) => void

HotKeys: HotKeys

Listeners: Listeners

HotKeys: (listeners: Listeners, ctrlListeners?: Listeners, debug?: boolean) => HotKeys

queryString: (...args: [string, string | number | undefined][]) => string

req: (method: "delete" | "get" | "post" | "put", url: string, data?: object | undefined) => Promise

statusIs: (...statuses: number[]) => (req: XMLHttpRequest) => U

statusIsOK: (req: XMLHttpRequest) => U

statusIsCreated: (req: XMLHttpRequest) => U

statusIsDeleted: (req: XMLHttpRequest) => U

toFD: (json: Record) => FormData

DBDB: DBDB

a wrapper around IDBDatabase that provides helpers for running transactions,
migrations, and creating Promisified ObjectStores

DBOS: DBOS

TransactCallback: TransactCallback

a callback passed to DBDB.transact or DBDB.migrate

Migration: Migration

MigrationCtx: MigrationCtx

getDB: (name: string, args: MixArgs) => Promise

createObjectStore: (name: string, params?: IDBObjectStoreParameters | undefined) => ({ db }: MigrationCtx) => IDBObjectStore

idbReq: (req: IDBRequest, onSuccess: (v: T) => void, onError?: ((error: DOMException) => void) | undefined) => IDBRequest

This helper exists for a few reasons:
1. IDB txns only continue if successive requests are made during the
   success or error handlers of the request. This rules out a Promise API
   so this API makes it easier to add listeners in a single expression.
2. The callbacks receive the result/error as an argument so that they
   don't have to be awkwardly read off of e.target or what have you.
3. This uses the more verbose addEventListener so that multiple success or
   error callbacks can be added without stepping on each other.

DBDB: (db: IDBDatabase) => DBDB

a wrapper around IDBDatabase that provides helpers for running transactions,
migrations, and creating Promisified ObjectStores

DBOS: (db: IDBDatabase, name: string) => DBOS

LocalStore: LocalStore

LocalStore: (key: string, def: () => T) => LocalStore

PropLS: (key: string, def: T) => Prop

Off: Off

mapHTML: (prop: PropView, render: (v: T) => V, empty?: ApdArg) => (el: Element & ElementCSSInlineStyle) => void

Off: (p?: Off | undefined, cap?: Capture | undefined, n?: Off | undefined) => Off

match: (prop: PropView, render: (v: T) => Node | null | undefined) => Node

matchIf: (prop: PropView, render: (v: T) => Node | null | undefined) => Node

mount: (el: T, render: () => Mixin) => void

onBeforeunload: (fn: (el: U, ev: BeforeUnloadEvent) => void) => (el: U) => () => void

onBlur: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onChange: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onClick: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onDblclick: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onError: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onFocus: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onFullscreenchange: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onInput: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onKeydown: (fn: (el: U, ev: KeyboardEvent) => void) => (el: U) => () => void

onKeypress: (fn: (el: U, ev: KeyboardEvent) => void) => (el: U) => () => void

onKeyup: (fn: (el: U, ev: KeyboardEvent) => void) => (el: U) => () => void

onLoad: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onLoadedmetadata: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onMousedown: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onMouseleave: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onMousemove: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onMouseout: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onMouseover: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onMouseup: (fn: (el: U, ev: MouseEvent) => void) => (el: U) => () => void

onPopstate: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onResize: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onScroll: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onSubmit: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

onTouchend: (fn: (el: U, ev: TouchEvent) => void) => (el: U) => () => void

onTouchleave: (fn: (el: U, ev: TouchEvent) => void) => (el: U) => () => void

onTouchmove: (fn: (el: U, ev: TouchEvent) => void) => (el: U) => () => void

onTouchstart: (fn: (el: U, ev: TouchEvent) => void) => (el: U) => () => void

onTransitionend: (fn: (el: U, ev: TransitionEvent) => void) => (el: U) => () => void

onVisibilitychange: (fn: (el: U, ev: Event) => void) => (el: U) => () => void

$: (prop: PropView, f: (v: T) => ((el: U) => void) | null) => (el: U) => void

$$: (prop: PropView, f: (el: U, v: T) => void) => (el: U) => void

bind: (prop: Prop) => (el: T) => T

BrowserRouter: () => Router

Serializer: Serializer

Search: () => { search: Prop; key: (key: string, serializer: Serializer) => { prop: PropView; set(value: T): void; }; }

GlobalValues: GlobalValues

alignItems: (...vals: ("" | "center" | "end" | "start" | GlobalValues | "baseline")[]) => (el: T) => T

animationDelay: (...vals: (string | number)[]) => (el: T) => T

background: (...vals: (string | number)[]) => (el: T) => T

backgroundColor: (...vals: (string | number)[]) => (el: T) => T

border: (...vals: (string | number)[]) => (el: T) => T

borderBottom: (...vals: (string | number)[]) => (el: T) => T

borderLeft: (...vals: (string | number)[]) => (el: T) => T

borderRadius: (...vals: (string | number)[]) => (el: T) => T

borderRight: (...vals: (string | number)[]) => (el: T) => T

borderTop: (...vals: (string | number)[]) => (el: T) => T

bottom: (...vals: (string | number)[]) => (el: T) => T

boxShadow: (...vals: (string | number)[]) => (el: T) => T

boxSizing: (...vals: ("" | GlobalValues | "border-box" | "content-box")[]) => (el: T) => T

color: (...vals: (string | number)[]) => (el: T) => T

cursor: (...vals: (string | number)[]) => (el: T) => T

display: (...vals: ("" | "none" | GlobalValues | "block" | "flex" | "grid" | "inline" | "inline-block" | "inline-flex" | "inline-grid")[]) => (el: T) => T

fill: (...vals: (string | number)[]) => (el: T) => T

flex: (...vals: (string | number)[]) => (el: T) => T

flexDirection: (...vals: ("" | GlobalValues | "column" | "row")[]) => (el: T) => T

float: (...vals: ("" | "none" | "left" | "right" | GlobalValues)[]) => (el: T) => T

fontFamily: (...vals: (string | number)[]) => (el: T) => T

fontSize: (...vals: (string | number)[]) => (el: T) => T

fontStyle: (...vals: ("" | "normal" | GlobalValues | "italic" | "oblique")[]) => (el: T) => T

fontWeight: (...vals: ("" | "normal" | GlobalValues | "bold" | "bolder" | "boldest")[]) => (el: T) => T

gap: (...vals: (string | number)[]) => (el: T) => T

gridTemplateColumns: (...vals: (string | number)[]) => (el: T) => T

height: (...vals: (string | number)[]) => (el: T) => T

imageRendering: (...vals: ("" | "auto" | GlobalValues | "crisp-edges" | "pixelated")[]) => (el: T) => T

justifyContent: (...vals: ("" | "center" | "end" | "start" | GlobalValues | "space-around" | "space-between")[]) => (el: T) => T

left: (...vals: (string | number)[]) => (el: T) => T

lineHeight: (...vals: (string | number)[]) => (el: T) => T

margin: (...vals: (string | number)[]) => (el: T) => T

marginBottom: (...vals: (string | number)[]) => (el: T) => T

marginLeft: (...vals: (string | number)[]) => (el: T) => T

marginRight: (...vals: (string | number)[]) => (el: T) => T

marginTop: (...vals: (string | number)[]) => (el: T) => T

maxHeight: (...vals: (string | number)[]) => (el: T) => T

maxWidth: (...vals: (string | number)[]) => (el: T) => T

minHeight: (...vals: (string | number)[]) => (el: T) => T

minWidth: (...vals: (string | number)[]) => (el: T) => T

opacity: (...vals: (string | number)[]) => (el: T) => T

outline: (...vals: (string | number)[]) => (el: T) => T

overflow: (...vals: ("" | "auto" | "scroll" | GlobalValues | "hidden")[]) => (el: T) => T

padding: (...vals: (string | number)[]) => (el: T) => T

paddingBottom: (...vals: (string | number)[]) => (el: T) => T

paddingLeft: (...vals: (string | number)[]) => (el: T) => T

paddingRight: (...vals: (string | number)[]) => (el: T) => T

paddingTop: (...vals: (string | number)[]) => (el: T) => T

pointerEvents: (...vals: ("" | "auto" | "none" | GlobalValues)[]) => (el: T) => T

position: (...vals: ("" | GlobalValues | "absolute" | "fixed" | "relative" | "static" | "sticky")[]) => (el: T) => T

right: (...vals: (string | number)[]) => (el: T) => T

size: (w: string, h?: string) => (el: T) => T

strokeDasharray: (...vals: (string | number)[]) => (el: T) => T

strokeWidth: (...vals: (string | number)[]) => (el: T) => T

textAlign: (...vals: (string | number)[]) => (el: T) => T

top: (...vals: (string | number)[]) => (el: T) => T

transform: (...vals: (string | number)[]) => (el: T) => T

transformOrigin: (...vals: (string | number)[]) => (el: T) => T

transition: (...vals: (string | number)[]) => (el: T) => T

userSelect: (...vals: ("" | "auto" | "none" | GlobalValues | "all" | "contain" | "text")[]) => (el: T) => T

verticalAlign: (...vals: ("" | "sub" | "bottom" | "middle" | "top" | GlobalValues | "baseline" | "super" | "text-bottom" | "text-top")[]) => (el: T) => T

visibility: (...vals: (string | number)[]) => (el: T) => T

whiteSpace: (...vals: ("" | "pre" | "normal" | GlobalValues | "break-spaces" | "nowrap" | "pre-line" | "pre-wrap")[]) => (el: T) => T

width: (...vals: (string | number)[]) => (el: T) => T

zIndex: (...vals: (string | number)[]) => (el: T) => T

hide: (el: T) => T

invisible: (el: T) => T

show: (el: T) => T

visible: (el: T) => T

hideIf: (h: any) => (el: T) => T

showIf: (s: any) => (el: T) => T

visibleIf: (v: boolean) => (el: T) => T

cx: (val: string | number | boolean) => (el: Element) => void

cy: (val: string | number | boolean) => (el: Element) => void

d: (val: string | number | boolean) => (el: Element) => void

dx: (val: string | number | boolean) => (el: Element) => void

dy: (val: string | number | boolean) => (el: Element) => void

fill: (val: string | number | boolean) => (el: Element) => void

fontSize: (val: string | number | boolean) => (el: Element) => void

height: (val: string | number | boolean) => (el: Element) => void

patternUnits: (val: string | number | boolean) => (el: Element) => void

points: (val: string | number | boolean) => (el: Element) => void

r: (val: string | number | boolean) => (el: Element) => void

rx: (val: string | number | boolean) => (el: Element) => void

ry: (val: string | number | boolean) => (el: Element) => void

stroke: (val: string | number | boolean) => (el: Element) => void

strokeDasharray: (val: string | number | boolean) => (el: Element) => void

strokeDashoffset: (val: string | number | boolean) => (el: Element) => void

strokeLinecap: (val: string | number | boolean) => (el: Element) => void

strokeLinejoin: (val: string | number | boolean) => (el: Element) => void

strokeWidth: (val: string | number | boolean) => (el: Element) => void

textAnchor: (val: string | number | boolean) => (el: Element) => void

transform: (val: string | number | boolean) => (el: Element) => void

version: (val: string | number | boolean) => (el: Element) => void

viewBox: (val: string | number | boolean) => (el: Element) => void

width: (val: string | number | boolean) => (el: Element) => void

x: (val: string | number | boolean) => (el: Element) => void

x1: (val: string | number | boolean) => (el: Element) => void

x2: (val: string | number | boolean) => (el: Element) => void

xmlns: (val: string | number | boolean) => (el: Element) => void

y: (val: string | number | boolean) => (el: Element) => void

y1: (val: string | number | boolean) => (el: Element) => void

y2: (val: string | number | boolean) => (el: Element) => void

elt: (t: K) => (...args: MixArgs) => SVGElementTagNameMap[K]

circle: (...args: MixArgs) => SVGCircleElement

defs: (...args: MixArgs) => SVGDefsElement

ellipse: (...args: MixArgs) => SVGEllipseElement

g: (...args: MixArgs) => SVGGElement

line: (...args: MixArgs) => SVGLineElement

path: (...args: MixArgs) => SVGPathElement

pattern: (...args: MixArgs) => SVGPatternElement

polygon: (...args: MixArgs) => SVGPolygonElement

polyline: (...args: MixArgs) => SVGPolylineElement

rect: (...args: MixArgs) => SVGRectElement

text: (...args: MixArgs) => SVGTextElement

svg: (...args: MixArgs) => SVGSVGElement

_svg: (...args: MixArgs) => SVGSVGElement

Visible: Visible

Interval: Interval

RAF: RAF

Visible: () => Visible

WindowSize: () => Prop>

ArrayIsh: ArrayIsh

ArrayLike: ArrayLike

each: (a: T, f: (a: T[0], i: number) => any) => T

equal: (a: T[], b: T[], equal?: (a: T, b: T) => boolean) => boolean

filterNotNil: (a: (T | undefined)[]) => T[]

groupBy: (a: T[], by: (v: T) => string) => Record

insert: (a: T[], i: number, v: T) => T[]

inserts value v at index i such that a[i] === v afterwords

max: (a: number[], min?: number) => number

maxBy: (a: T[], get: (v: T) => number, min?: number) => number

mapNotNull: (a: ArrayLike, f: (v: T, i: number) => U | undefined) => U[]

min: (a: number[], max?: number) => number

minBy: (a: T[], get: (v: T) => number, max?: number) => number

remove: (a: T[], v: T) => T[]

replace: (a: T[], o: T, n: T) => T[]

sum: (a: number[], base?: number) => number

sumBy: (a: T[], get: (v: T) => number, base?: number) => number

swap: (a: T[], i: number, j: number) => T[]

tab: (L: number, f: (i: number) => T) => T[]

tab2d: (rows: number, cols: number, f: (r: number, c: number) => T) => T[][]

toMap: (a: T[], by: (v: T) => string) => Record

Diff: Diff

DiffAdd: DiffAdd

DiffDelete: DiffDelete

DiffKeep: DiffKeep

diff: (old: T[], nu: T[]) => Diff

cached: (f: (a: T, b: T) => U) => (a: T, b: T) => U

diffSize: (diff: Diff) => number

DLL: DLL

DLLish: DLLish

DLLNode: DLLNode

DLL: >() => DLL

DLL_append: >(dll: DLL, node: T) => void

DLL_each: >(dll: DLL, cb: (node: T) => void) => void

DLL_iter: >(node: DLLNode | undefined, cb: (node: T) => void) => void

DLL_len: >(dll: DLL) => number

DLL_remove: >(dll: DLL, item: T, full: boolean) => void

identity: (v: T) => T

isFalsy: (v: T) => boolean

isTruthy: (v: T) => boolean

nop: () => void

not: (v: T) => boolean

returnFalse: () => boolean

returnTrue: () => boolean

strictEqual: (a: T, b: T) => boolean

getOrPut: (o: Map, key: K, f: () => T) => T

getOrPut: (o: { [key: string]: T; }, key: string, f: () => T) => T

omap: (o: { [key: string]: T; }, f: (p: T, key: string) => U | undefined) => { [key: string]: U; }

ownmap: (o: { [key: string]: T; }, f: (p: T, key: string) => U) => { [key: string]: U; }

Option: Option

None: None

Some: Some

Some: (value: T) => Some

add: (set: Set, value: T) => Set

containsAll: (a: Set, b: Set) => boolean

difference: (a: Set, b: Set) => Set

equal: (a: Set, b: Set) => boolean

intersection: (a: Set, b: Set) => Set

map: (set: Set, map: (v: T) => U) => Set

remove: (set: Set, value: T) => Set

union: (a: Set, b: Set) => Set

capitalize: (str: string) => string

asArray: (map: (v: unknown) => T) => (v: unknown) => T[]

asBoolean: (v: unknown) => boolean

asInt: (v: unknown) => number

asLiteral: (l: T) => (v: unknown) => T

asMap: (map: (v: unknown) => V) => (v: unknown) => { [key: string]: V; }

asNil: (v: unknown) => undefined

asNumber: (v: unknown) => number

asObject: (map: (v: {}) => T) => (v: unknown) => T

asOneOf: (...options: T[]) => (v: unknown) => T

asString: (v: unknown) => string

asStringLiteral: (l: T) => (v: unknown) => T

asUnion: (...options: ((v: unknown) => T)[]) => (v: unknown) => T

excludes: (...values: string[]) => (v: string) => string | undefined

getInt: (id: string) => Promise

getObject: (body: unknown) => Promise