(codePoint: CodePoint)

()

()

(error: any, prop: string)

({ h, s, l, alpha }: Readonly<Hsl>)

({ h, s, v, alpha }: Readonly<Hsv>)

(keyStatsMap: KeyStatsMap, target: Target)

(codePoint: CodePoint)

(email: string)

(key: KeyId)

()

( { r, g, b, alpha }: Readonly<Rgb>, to: Xyz, )

()

(text: string)

({ timeStamp }: Pick<IInputEvent, "timeStamp">)

(time: number)

(filter: Filter, random: RNG)

(startPos, endPos, offset)

(description)

()

(root: HTMLElement)

( vx: Vector, vy: Vector, degree: number, )

( selector: Element | string, )

(vx: Vector, vy: Vector, model: Model)

(reader: Reader)

( settings: TextDisplaySettings, chars: readonly Char[], )

(commands: readonly Command[], r = round)

(codePoint: CodePoint)

( { r, g, b, alpha }: Readonly<Rgb>, to: Rgb, )

( { r, g, b, alpha }: Readonly<Rgb>, to: Rgb, )

( work: AsyncIterable<any>, { delayer = defaultDelayer, signal = null }: Partial<SchedulerOptions> = {}, )

(char: string)

()

({ timeStamp }: Event)

(data: Uint8Array)

()

()

(parent: Element)

( list: readonly T[], weight: (v: T) => number, random: RNG = Math.random, )

( { x, y, z, alpha }: Readonly<Xyz>, to: Rgb, )

( schema: ZodType, report: Report = BadRequestError, )

(level: Level, args: unknown[])

(superClass: typeof Model)

(position: Point, diameter: number, ccw: boolean)

( map: Map<CodePoint, KeyCombo>, character: CodePoint, id: KeyId, modifier: KeyModifier, )

( map: Map<CodePoint, KeyCombo>, { dead }: DeadCharacter, id: KeyId, modifier: KeyModifier, )

(settings: Settings)

( theme: CustomTheme, property: "saturation" | "brightness", delta: number, )

()

()

()

(name: string)

()

({ tableName, createTable, }: { tableName: string; createTable: (knex: Knex, table: Knex.Cre

(...parts: readonly string[])

(event: Event)

(message: ClientMessage)

(codePoint: CodePoint)

(fonts: Enum<Font>, font: Font)

(id: string)

(character: Character | null)

( histogram: Iterable<readonly [{ readonly codePoint: CodePoint }, number]>, )

(content: Content)

(codePoint: CodePoint)

(results: Iterable<Result>)

(results: Iterable<Result>)

(id: string)

(dict: CharacterDict)

( grammar: Grammar, { start = "start", output = new Output(), rng = lcg, }: { readonly s

(self)

( settings: Settings, nextWord: WordGenerator, { repeatWords = 1 }: { readonly repeatWords?: number } =

(el: Element)

(modifier: string)

(dir: "first" | "prev" | "next" | "last")

(codePoint: CodePoint)

( state: ImportState, data: Blob, )

({ codePoint }: Letter)

(key: symbol, factory: (intl: IntlShape) => T)

(v: Prod)

(v: Prod)

(v: Prod)

(v: Prod)

(v: Prod)

(keyStatsMap: KeyStatsMap)

()

(publicId: PublicId)

(language: Language)

()

( { dead }: DeadCharacter, x: number, y: number, className: ClassName, )

(extra: Record<string, unknown> | null)

(label: LabelShape, className: ClassName = null)

( { ligature }: LigatureCharacter, x: number, y: number, className: ClassName, )

({ min, max }: Range, count: number)

(path)

(oklch: Readonly<Oklch>)

(event: IInputEvent)

( box: Rect, data: Vector, range: Range, { margin = 5, style, }: { readonly margin?: num

(prop: Prop)

(character: unknown)

(ro: ResourceOwner)