@cosmoledo/gleam 1.0.0

package/dist/gleam.d.ts

@@ -0,0 +1,1195 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export interface RegisterData {
+	path: string;
+	name: string;
+	volume?: number;
+}
+export declare abstract class AudioBase {
+	protected songs: Map<string, HTMLAudioElement>;
+	private _enabled;
+	private registered;
+	get enabled(): boolean;
+	set enabled(value: boolean);
+	constructor(enabled?: boolean);
+	register(defaultVolume?: number, ...songs: (RegisterData | string)[]): void;
+	stop(): void;
+	private throwOnBadVolume;
+}
+/**
+ * Quadratic ease-in (slow start, accelerates).
+ */
+export declare function easeIn(t: number): number;
+/**
+ * Quadratic ease-in-out (accelerates, then decelerates).
+ */
+export declare function easeInOut(t: number): number;
+/**
+ * Quadratic ease-out (fast start, decelerates).
+ */
+export declare function easeOut(t: number): number;
+/**
+ * Identity (constant rate of change).
+ */
+export declare function linear(t: number): number;
+export type EasingName = "ease-in" | "ease-in-out" | "ease-out" | "linear";
+export declare const EASINGS: Record<EasingName, (t: number) => number>;
+export declare class Music extends AudioBase {
+	private last;
+	private current;
+	private next;
+	private fadeCancel;
+	get isPlaying(): boolean;
+	get enabled(): boolean;
+	set enabled(value: boolean);
+	fade(name?: string | null, fadeTime?: number, easing?: {
+		cur: EasingName;
+		next: EasingName;
+	}): void;
+	stop(): void;
+	private getRandom;
+}
+export declare class Sound extends AudioBase {
+	private currentSounds;
+	play(name: string): Promise<void>;
+	stop(): void;
+}
+export declare class Color {
+	static fromHex(hex: string): Color;
+	static fromHSL(h: number, s: number, l: number, a?: number): Color;
+	private _r;
+	private _g;
+	private _b;
+	private _alpha;
+	get r(): number;
+	get g(): number;
+	get b(): number;
+	get alpha(): number;
+	constructor(r: number, g: number, b: number, a?: number);
+	set(r: number, g: number, b: number, a?: number): this;
+	applyMatrix(m1: number, m2: number, m3: number, m4: number, m5: number, m6: number, m7: number, m8: number, m9: number): this;
+	brightness(factor: number): this;
+	contrast(factor: number): this;
+	grayscale(value?: number): this;
+	hueRotate(radians: number): this;
+	invert(factor?: number): this;
+	mix(other: Color, amount: number): this;
+	round(): this;
+	saturate(value?: number): this;
+	sepia(value?: number): this;
+	shade(percent: number): this;
+	toHex(): string;
+	toHSL(): string;
+	toHSLObject(): {
+		h: number;
+		s: number;
+		l: number;
+		a: number;
+	};
+	toRGB(): string;
+	clone(): Color;
+	equals(other: Color, compareAlpha?: boolean): boolean;
+}
+export type RGB = [
+	number,
+	number,
+	number
+];
+/**
+ * Convert an `(r, g, b)` triple (0-255) to a `#rrggbb` hex string.
+ * Low-level; prefer `Color.toHex()` outside hot per-pixel loops.
+ */
+export declare function rgb2hex(red: number, green: number, blue: number): string;
+/**
+ * Pack `(r, g, b[, a])` channels into a single integer key.
+ * RGB are 0-255. Alpha is 0-1 (CSS convention); divide canvas byte-alpha by 255 before passing.
+ * Without alpha: 24-bit `RGB`. With alpha: 32-bit `RGBA` (forced unsigned).
+ * Useful for fast per-pixel lookups: cheaper than building a hex string.
+ */
+export declare function rgb2Int(red: number, green: number, blue: number, alpha?: number): number;
+/**
+ * Convert a `#rgb` or `#rrggbb` hex string to an `[r, g, b]` integer tuple.
+ * Low-level; prefer `Color.fromHex()` outside hot per-pixel loops. Caller must pass a valid hex string.
+ */
+export declare function hex2rgb(hex: string): RGB;
+/**
+ * HSL → RGB channel helper used by `Color.fromHSL`. Inputs are normalized to `[0, 1]`.
+ */
+export declare function hue2rgb(p: number, q: number, t: number): number;
+/**
+ * Random `#rgb` short hex color.
+ */
+export declare function randomHex(): string;
+/**
+ * Random `[r, g, b]` integer tuple; each channel uniform in `[min, max]`.
+ */
+export declare function randomRgb(min?: number, max?: number): RGB;
+/**
+ * Used when hue-rotate does not work e.g. on dark images
+ * Based on https://codepen.io/sosuke/pen/Pjoqqp
+ * https://stackoverflow.com/questions/42966641/how-to-transform-black-into-any-given-color-using-only-css-filters/43960991#43960991
+ *
+ * As the result does vary because of a Math.random(),
+ * I would suggest console.log some filters, pick nice ones and hardcode them instead:
+ * console.log(colorShifter(randomRgb(1, 10)));
+ */
+export declare function colorShifter(rgb: RGB): string;
+export interface PolygonCollisionResult {
+	intersect: boolean;
+	minimumTranslationVector: Vec2;
+	willIntersect: boolean;
+}
+export declare class Polygon {
+	/**
+	 * `angle` is the simplification threshold in radians: vertices whose turn
+	 * angle wraps to within ±`angle` of straight are dropped.
+	 */
+	static fromCanvas(canvas: HTMLCanvasElement, detail: number, angle: number): Polygon;
+	static fromEdges(edges: number, size: Vec2 | number): Polygon;
+	static fromRect(rect: Rect): Polygon;
+	private _center;
+	private _points;
+	private edges;
+	get center(): Readonly<Vec2>;
+	get points(): Readonly<Vec2[]>;
+	constructor(...points: Vec2[]);
+	draw(context: CanvasRenderingContext2D, offset?: Vec2): void;
+	addPoint(x: number, y: number): Polygon;
+	addPoints(...points: Vec2[]): Polygon;
+	offset(x?: number, y?: number): Polygon;
+	rotate(angle: number, pos?: Readonly<Vec2>): this;
+	collide(otherPolygon: Polygon, velocity?: Vec2): PolygonCollisionResult;
+	clone(): Polygon;
+	private update;
+}
+export interface Sides {
+	bottom: number;
+	centerPos: Vec2;
+	halfSize: Vec2;
+	right: number;
+}
+export declare class Rect {
+	static fromBoundingClientRect(rect: DOMRect | HTMLElement): Rect;
+	static fromPolygon(polygon: Polygon): Rect;
+	private _h;
+	private _w;
+	private _x;
+	private _y;
+	private _sides;
+	private sideIsDirty;
+	get h(): number;
+	set h(value: number);
+	get w(): number;
+	set w(value: number);
+	get x(): number;
+	set x(value: number);
+	get y(): number;
+	set y(value: number);
+	get sides(): Readonly<Sides>;
+	constructor(x?: number, y?: number, w?: number, h?: number);
+	inflate(delta: number): Rect;
+	round(): Rect;
+	set(x?: Vector4 | Vector2 | number, y?: number, w?: number, h?: number): Rect;
+	collide(rect: Rect): boolean;
+	collideFull(rect: Rect): boolean;
+	collidePoint(vec: Vector2): boolean;
+	collideSide(rect: Rect): "none" | "top" | "bottom" | "left" | "right";
+	pos(): Vec2;
+	size(): Vec2;
+	toString(): string;
+	clone(): Rect;
+	equals(other: Rect, withSize?: boolean): boolean;
+}
+export interface Vector2 {
+	x: number;
+	y: number;
+}
+export interface Vector4 extends Vector2 {
+	w: number;
+	h: number;
+}
+/**
+ * 2D vector. Scalar args to `set`/`add`/`sub`/`mult`/`div`/`rem`/`mod`/`equals`
+ * broadcast to both axes: `vec.add(5)` adds 5 to x and y, `vec.mult(-1)` negates
+ * both. Pass `(x, y)` or a `Vector2` for per-axis values.
+ */
+export declare class Vec2 {
+	static fromAngle(rad: number, scaleX?: number, scaleY?: number): Vec2;
+	x: number;
+	y: number;
+	constructor(x?: Vector2 | number, y?: number);
+	set(v: Vector2): Vec2;
+	set(x: number, y?: number): Vec2;
+	abs(): Vec2;
+	add(v: Vector2): Vec2;
+	add(x: number, y?: number): Vec2;
+	ceil(): Vec2;
+	clamp(x: [
+		number,
+		number
+	], y?: [
+		number,
+		number
+	]): Vec2;
+	div(v: Vector2): Vec2;
+	div(x: number, y?: number): Vec2;
+	floor(): Vec2;
+	map(callback: (value: number, index: number) => number): Vec2;
+	mod(v: Vector2): Vec2;
+	mod(x: number, y?: number): Vec2;
+	mult(v: Vector2): Vec2;
+	mult(x: number, y?: number): Vec2;
+	negate(): Vec2;
+	normalize(): Vec2;
+	normalizeManhattan(): Vec2;
+	rem(v: Vector2): Vec2;
+	rem(x: number, y?: number): Vec2;
+	round(): Vec2;
+	sub(v: Vector2): Vec2;
+	sub(x: number, y?: number): Vec2;
+	angle(other?: Vector2): number;
+	distance(other: Vector2): number;
+	distanceManhattan(other: Vector2): number;
+	dotProduct(other: Vector2): number;
+	isValid(): boolean;
+	length(): number;
+	lengthManhattan(): number;
+	max(): number;
+	min(): number;
+	toArray(): [
+		number,
+		number
+	];
+	toRectAddPos(v: Vector2): Rect;
+	toRectAddPos(x: number, y?: number): Rect;
+	toRectAddSize(v: Vector2): Rect;
+	toRectAddSize(x: number, y?: number): Rect;
+	toString(): string;
+	clone(): Vec2;
+	equals(v: Vector2): boolean;
+	equals(x: number, y?: number): boolean;
+	private calculate;
+	private concat;
+	private getValues;
+}
+export interface SpriteAnimation {
+	default?: boolean;
+	name: string;
+	sprites: HTMLCanvasElement[] | HTMLImageElement[];
+	timing: number;
+}
+export type onEndType = () => void;
+export type onFrameType = Record<number, () => void>;
+export interface BaseEntity {
+	pos: Vec2;
+	flipX?: number;
+}
+export declare class Animator {
+	private static spriteCache;
+	/**
+	 * Drop cached rendered sprites. Pass a namespace to evict only that prefix; omit to clear all.
+	 */
+	static clearSpriteCache(namespace?: string): void;
+	active: boolean;
+	image: HTMLCanvasElement;
+	imageId: number;
+	lookLeft: boolean;
+	onEnd: onEndType | undefined;
+	size: Vec2;
+	private animations;
+	private currentAnimation;
+	private entity;
+	private lastPlayed;
+	private namespace;
+	private onFrame?;
+	private playVersion;
+	private timer;
+	get current(): SpriteAnimation;
+	/**
+	 * We store rendered images in a cache.
+	 * So if you have the same entity multiple times, the images get computed once and then shared.
+	 * This reduces overhead and frees time up for other important computations.
+	 *
+	 * `namespace` is the cache key prefix for these rendered images.
+	 * So pass a different key for different Animators; otherwise, you will see wrong images.
+	 */
+	constructor(entity: BaseEntity, namespace: string);
+	draw(context: CanvasRenderingContext2D, offset?: Vec2): void;
+	update(dt: number): void;
+	add(name: string, sprites: HTMLCanvasElement[] | HTMLImageElement[], timing: number, defaultAnim?: boolean): void;
+	addAnimation(anim: SpriteAnimation, defaultAnim?: boolean): void;
+	drawRotated(context: CanvasRenderingContext2D, angle: number, offset?: Vec2): void;
+	play(name: string, onEnd?: onEndType, onFrame?: onFrameType): void;
+	playIfNot(name: string, onEnd?: onEndType, onFrame?: onFrameType): boolean;
+	playNextOnce(name: string | undefined): void;
+	/**
+	 * Play `name` once, then return to the previously-playing animation. Calling with the currently-playing name re-loops it indefinitely (lastPlayed restores to itself).
+	 */
+	playOnce(name: string, onEnd?: onEndType, onFrame?: onFrameType): void;
+	randomTimer(): void;
+	removeAllAnimations(): void;
+	reset(): void;
+	isPlaying(name: string): boolean;
+	/**
+	 * Update `image` and `size` from the current sprite. Assumes uniform sprite size within an animation. Caches rendered canvases per (animation, frame, lookLeft) — if you mutate `entity.flipX` after first render, call `removeAllAnimations()` or recreate the Animator to invalidate.
+	 */
+	protected setImage(): void;
+}
+export declare class Particle {
+	protected color: string;
+	protected lifetime: number;
+	protected maxLifeTime: number;
+	protected pos: Vec2;
+	protected size: number;
+	protected vel: Vec2;
+	protected _rect: Rect;
+	get alive(): boolean;
+	get rect(): Readonly<Rect>;
+	constructor(pos: Vec2, color: string, size?: number);
+	draw(context: CanvasRenderingContext2D, offset?: Vec2): void;
+	update(dt: number): void;
+	resetLifetime(): void;
+}
+export declare class Projectile<T = unknown> {
+	maxLifetime: number;
+	payload?: T;
+	speed: number;
+	protected image: HTMLCanvasElement;
+	protected lifetime: number;
+	protected pos: Vec2;
+	protected rotation: number;
+	protected vel: Vec2;
+	protected _rect: Rect;
+	private originalImage;
+	get alive(): boolean;
+	get rect(): Readonly<Rect>;
+	constructor(pos: Vec2, image: HTMLCanvasElement, vel?: Vec2);
+	draw(context: CanvasRenderingContext2D, offset?: Vec2): void;
+	update(dt: number): void;
+	/**
+	 * Allocates a fresh rotated canvas on each call — no internal cache.
+	 * Caching by quantized rotation could be a feature when projectiles need to re-aim every tick (homing/seeking).
+	 */
+	rebuildRotation(): void;
+	remove(): void;
+}
+declare global {
+	interface HTMLCanvasElement {
+		/** `true` if any pixel has a non-zero RGBA byte. */
+		hasAnyColor(): boolean;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Read the pixel at `(x, y)`. Out-of-bounds reads return zero/transparent.
+		 * Not for hot paths — each call issues a fresh `getImageData`. For bulk reads, call `getImageData` once and index into the buffer.
+		 * @param output return format. Default `"integer"`.
+		 */
+		getPixelAt(x: number, y: number, output?: "integer"): number;
+		getPixelAt(x: number, y: number, output: "array"): [
+			...RGB,
+			number
+		];
+		getPixelAt(x: number, y: number, output: "json"): {
+			r: number;
+			g: number;
+			b: number;
+			a: number;
+		};
+		getPixelAt(x: number, y: number, output: "string"): string;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Replace pixel colors by RGB hex key. Alpha is ignored — fully-transparent pixels are skipped, semi-transparent pixels keep their alpha.
+		 */
+		replaceColors(replacements: Record<string, string>): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/** Rotate around the center into a new square canvas sized to fit any rotation (`diam = ceil(sqrt(w² + h²))`). */
+		rotateBy(radians: number): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/** Rotate around the center within the original `width × height`; corners that fall outside are clipped. */
+		rotateByAligned(radians: number): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/** Trim fully-transparent borders. Returns a new canvas cropped to the bounding box of opaque pixels. */
+		autoCrop(): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Scale into a new canvas. Throws if any factor is `≤ 0`.
+		 * @param scaleX horizontal scale factor. Default `1`.
+		 * @param scaleY vertical scale factor. Default = `scaleX`.
+		 */
+		scaleBy(scaleX?: number, scaleY?: number): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Scale into a new canvas so the chosen axis equals `size`, preserving aspect ratio.
+		 * @param isWidth match `size` against width when `true`, height when `false`. Default `true`.
+		 */
+		resize(size: number, isWidth?: boolean): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Mirror horizontally into a new canvas.
+		 * @param offsetX horizontal shift applied after flipping. Default `0`.
+		 */
+		flipX(offsetX?: number): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Mirror vertically into a new canvas.
+		 * @param offsetY vertical shift applied after flipping. Default `0`.
+		 */
+		flipY(offsetY?: number): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/**
+		 * Crop a `(w, h)` sub-region starting at `(x, y)` into a new canvas.
+		 * @param w default `this.width`
+		 * @param h default `this.height`
+		 */
+		subImage(x: number, y: number, w?: number, h?: number): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/** Copy this canvas (same dimensions, content, `id`, and `dataset`) into a new canvas. */
+		clone(): HTMLCanvasElement;
+	}
+}
+declare global {
+	interface HTMLCanvasElement {
+		/** Convert image canvas to `Promise<HTMLImageElement>` via `toDataURL`. */
+		toImage(): Promise<HTMLImageElement>;
+	}
+}
+export interface CanvasConstruct {
+	canvas: HTMLCanvasElement;
+	context: CanvasRenderingContext2D;
+}
+/**
+ * Create a new `<canvas>` of the given size with its 2D context. Antialiasing defaults to `Settings.antialias`.
+ */
+export declare function createNewCanvas(width: number, height: number, antialias?: boolean): CanvasConstruct;
+/**
+ * Look up an existing canvas by CSS selector and return it with its 2D context.
+ */
+export declare function getCanvasConstruct(selector: string): CanvasConstruct;
+/**
+ * Apply a CSS `filter` string to an image and return the result as a new canvas.
+ */
+export declare function applyFilterOnCanvas(image: HTMLCanvasElement | HTMLImageElement, filter: string, width?: number, height?: number): HTMLCanvasElement;
+/**
+ * Rotate the hue of an image by `hue` degrees via CSS `hue-rotate(...)` filter.
+ */
+export declare function rotateHue(image: HTMLCanvasElement | HTMLImageElement, hue: number, width?: number, height?: number): HTMLCanvasElement;
+/**
+ * Recolor an opaque canvas in place using composite operations,
+ * preserving the alpha mask of the source image. Wraps the body in `save`/`restore`
+ * so `fillStyle` / `globalCompositeOperation` writes don't leak to the caller's context.
+ * https://stackoverflow.com/a/45201094
+ */
+export declare function changeColor(context: CanvasRenderingContext2D, oriImg: HTMLCanvasElement, newColor: string): void;
+/**
+ * Split a sprite-sheet image into individual sprite canvases laid out as `elementsX × elementsY`.
+ * Throws if the image dimensions don't divide evenly — sheets are expected to be authored that way.
+ */
+export declare function splitSpriteSheet(img: HTMLCanvasElement, elementsX: number, elementsY: number): HTMLCanvasElement[];
+/**
+ * Count occurrences of each color in an image, keyed by `#rrggbb`.
+ * `pixelAmount` multiplies each count and floors to int; values < 1 will drop low-count colors entirely (count rounds to 0).
+ * `removeLowerThan` / `removeHigherThan` drop entries outside the range; `0` disables either bound.
+ */
+export declare function getUsedColors(image: HTMLCanvasElement, pixelAmount?: number, removeLowerThan?: number, removeHigherThan?: number): Map<string, number>;
+export declare const CANVAS_TYPES: {
+	readonly ANY: symbol;
+	readonly DEFAULT: symbol;
+	readonly BACKGROUND: symbol;
+	readonly MAIN: symbol;
+};
+export interface CanvasHolder extends CanvasConstruct {
+	id: string;
+	resize: boolean;
+	type: symbol;
+}
+export declare class CanvasManager {
+	canvasBoundingClientRect: DOMRect;
+	canvasHolder: Record<string, CanvasHolder>;
+	ratio: number;
+	resizedSize: Vec2;
+	private mainHolder;
+	get canvas(): HTMLCanvasElement;
+	get canvasContext(): CanvasRenderingContext2D;
+	get height(): number;
+	set height(height: number);
+	get size(): Vec2;
+	get width(): number;
+	set width(width: number);
+	finishSetup(): void;
+	resize(): void;
+	setFontSize(size: number, font?: string): void;
+	setupCanvas(canvasType: symbol, selector: string, resize?: boolean): CanvasHolder;
+}
+export declare class Gameloop {
+	levelTime: number;
+	private _isLooping;
+	private accumulator;
+	private game;
+	private stop;
+	get isLooping(): boolean;
+	constructor(game: Game);
+	startLoop(): void;
+	stopLoop(): void;
+	private draw;
+	private looper;
+}
+export declare const KEYBOARD_KEYS: {
+	readonly KEY_0: "Digit0";
+	readonly KEY_1: "Digit1";
+	readonly KEY_2: "Digit2";
+	readonly KEY_3: "Digit3";
+	readonly KEY_4: "Digit4";
+	readonly KEY_5: "Digit5";
+	readonly KEY_6: "Digit6";
+	readonly KEY_7: "Digit7";
+	readonly KEY_8: "Digit8";
+	readonly KEY_9: "Digit9";
+	readonly KEY_A: "KeyA";
+	readonly KEY_B: "KeyB";
+	readonly KEY_C: "KeyC";
+	readonly KEY_D: "KeyD";
+	readonly KEY_DOWN: "ArrowDown";
+	readonly KEY_E: "KeyE";
+	readonly KEY_ENTER: "Enter";
+	readonly KEY_ESCAPE: "Escape";
+	readonly KEY_F: "KeyF";
+	readonly KEY_G: "KeyG";
+	readonly KEY_H: "KeyH";
+	readonly KEY_I: "KeyI";
+	readonly KEY_J: "KeyJ";
+	readonly KEY_K: "KeyK";
+	readonly KEY_L: "KeyL";
+	readonly KEY_LEFT: "ArrowLeft";
+	readonly KEY_M: "KeyM";
+	readonly KEY_N: "KeyN";
+	readonly KEY_O: "KeyO";
+	readonly KEY_P: "KeyP";
+	readonly KEY_Q: "KeyQ";
+	readonly KEY_R: "KeyR";
+	readonly KEY_RIGHT: "ArrowRight";
+	readonly KEY_S: "KeyS";
+	readonly KEY_SPACE: "Space";
+	readonly KEY_T: "KeyT";
+	readonly KEY_TAB: "Tab";
+	readonly KEY_U: "KeyU";
+	readonly KEY_UP: "ArrowUp";
+	readonly KEY_V: "KeyV";
+	readonly KEY_W: "KeyW";
+	readonly KEY_X: "KeyX";
+	readonly KEY_Y: "KeyY";
+	readonly KEY_Z: "KeyZ";
+};
+export declare class Keyboard {
+	keys: Record<string, boolean>;
+	constructor(game: Game);
+	reset(): void;
+	stopPress(code: string): void;
+	isPressed(code: string): boolean;
+}
+export type SettingsOverrides = Partial<Omit<typeof Settings, "prototype" | "init" | "setLocalStorage" | "localStorage">>;
+export declare class Settings {
+	static antialias: boolean;
+	static autoloop: boolean;
+	static backgroundColor: string;
+	static debug: boolean;
+	static doNotClear: boolean;
+	static enableResize: boolean;
+	static font: string;
+	static fps: number;
+	static triedToClose?: () => void;
+	static useClearRect: boolean;
+	static warnBeforeClose: boolean;
+	private static initialized;
+	private static readonly _localStorage;
+	static get localStorage(): Readonly<typeof Settings._localStorage>;
+	static init(overrides: SettingsOverrides, game: Game): void;
+	static setLocalStorage<K extends keyof typeof Settings._localStorage>(key: K, value: (typeof Settings._localStorage)[K]): void;
+}
+declare global {
+	interface Window {
+		/** Translate `key` for the active language. Throws until `prepareLanguage` has run. */
+		t(key: string): string;
+	}
+}
+export type Languages = Record<string, Record<string, string>>;
+export declare function prepareLanguage(languages: Languages, defaultLanguage?: string): void;
+declare global {
+	interface HTMLAudioElement {
+		/** Deep-clone this audio element, preserving the current `volume`. */
+		clone(): HTMLAudioElement;
+	}
+}
+declare global {
+	interface HTMLAudioElement {
+		/** Volume restored by `stop()` after pausing. If unset, `stop()` leaves `volume` as-is. */
+		defaultVolume?: number;
+		/** Pause playback, reset `currentTime` to 0, and restore `volume` to `defaultVolume` if set. */
+		stop(): void;
+	}
+}
+export type Mode = "fill" | "stroke";
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Fill a two-color bar sized by `amount`. Writes `fillStyle`; persists on the context — wrap in `save()`/`restore()` to preserve prior state.
+		 * @param c1 background, default `"white"`
+		 * @param c2 foreground, default `"black"`
+		 */
+		fillBar(rect: Vector4, amount: number, c1?: string, c2?: string): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Fill a three-layer framed bar (outer band, frame, fill scaled by `amount`). Writes `fillStyle`; persists on the context — wrap in `save()`/`restore()` to preserve prior state.
+		 * @param amount fill fraction in `[0, 1]`. Default `0.8`. `≤ 0` skips the fill layer.
+		 * @param padding frame inset on all sides. Default `4`.
+		 * @param colors outer band, frame, fill. Default `["white", "black", "red"]`.
+		 */
+		fillFramedBar(rect: Vector4, amount?: number, padding?: number, colors?: [
+			string,
+			string,
+			string
+		]): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Draws a circle centered at `vecPos`.
+		 * @param amount sweep fraction in `[0, 1]`. Default `1` (full circle).
+		 */
+		drawCircle(vecPos: Vector2, rad: number, mode: Mode, amount?: number): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/** Draws a rectangle (from `Vector4` or `x, y, w, h`). */
+		drawRect(rect: Vector4, mode: Mode): void;
+		drawRect(x: number, y: number, w: number, h: number, mode: Mode): void;
+	}
+}
+export interface DrawRoundRectOptions {
+	/** Inset from the rect edges. Default `0` (no inset). */
+	padding?: number;
+	/** Corner radius. Default `16`. */
+	radius?: number;
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/** Draw a rounded rectangle from a `Vector4` or `x, y, w, h` plus an options bag. Delegates the corner path to native `roundRect` (Safari 16+ / Chrome 99+ / Firefox 113+). */
+		drawRoundRect(rect: Vector4, mode: Mode, options?: DrawRoundRectOptions): void;
+		drawRoundRect(x: number, y: number, w: number, h: number, mode: Mode, options?: DrawRoundRectOptions): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/** Stroke a dotted rectangle. Writes `lineWidth` and `setLineDash` — wrap in `save()`/`restore()` to preserve prior state. */
+		strokeDottedRect(rect: Vector4): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/** Draw a line segment from `(x1, y1)` to `(x2, y2)`. */
+		strokeLine(x1: number, y1: number, x2: number, y2: number): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Draw a regular polygon centered in `rect`, with vertices on a circle of radius `min(rect.w, rect.h) * 0.5`.
+		 */
+		drawPolygon(sides: number, rect: Vector4, mode: Mode): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/** Draw a triangle: top-left → top-right → bottom-center. */
+		drawTriangle(rect: Vector4, mode: Mode): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Write text horizontally offset around `x` by `measureTextOffset` of its measured width.
+		 * @param measureTextOffset in `[0, 1]`. Default `0.5` (centered around `x`).
+		 */
+		writeText(text: string, x: number, y: number, measureTextOffset?: number): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Word-wrap `text` into lines of pixel width `width`, drawing each line via `writeText`. Returns `false` and logs to `console.error` if `maxAttempts` is reached.
+		 * @param lineOffset vertical spacing between lines in px. Default `50`.
+		 * @param maxAttempts safety cap on wrap iterations. Default `50`.
+		 */
+		writeMultilineText(text: string, x: number, y: number, width: number, lineOffset?: number, maxAttempts?: number): boolean;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/**
+		 * Draw `image` rotated by `radians` around the center of its placement at `(x, y)`. Saves and restores the transform.
+		 * @param radians clockwise positive, in radians.
+		 */
+		drawImageRotated(image: HTMLCanvasElement, x: number, y: number, radians: number): void;
+	}
+}
+declare global {
+	interface CanvasRenderingContext2D {
+		/** Build a colored rounded-rect stencil with a `drawPartialRoundRect` helper. The returned helper writes `fillStyle = "white"` on the caller's context — wrap in `save()`/`restore()` to preserve prior state. */
+		generateColor(size: number, color: string): {
+			colors: [
+				number,
+				number
+			][];
+			image: HTMLCanvasElement;
+			drawPartialRoundRect: (rect: Rect, amount: number, offsetX?: number, offsetY?: number) => void;
+		};
+	}
+}
+declare global {
+	interface HTMLImageElement {
+		/**
+		 * Crop a `(w, h)` sub-region starting at `(x, y)` into a new canvas.
+		 * @param w default `this.width`
+		 * @param h default `this.height`
+		 */
+		subImage(x: number, y: number, w?: number, h?: number): HTMLCanvasElement;
+	}
+}
+export declare abstract class Game {
+	canman: CanvasManager;
+	gameloop: Gameloop;
+	keyboard: Keyboard;
+	pointer: Pointer;
+	private initialized;
+	constructor(settingOverrides?: SettingsOverrides);
+	draw(_context: CanvasRenderingContext2D): void;
+	update(_dt: number): void;
+	init(): Promise<void>;
+	protected preInit(doInit?: boolean): Promise<void>;
+}
+export declare const POINTER_KEYS: {
+	readonly LEFT: 0;
+	readonly MIDDLE: 1;
+	readonly RIGHT: 2;
+	readonly PREV: 3;
+	readonly FORWARD: 4;
+};
+export declare class Pointer {
+	hasMoved: boolean;
+	lastEvent: PointerEvent | null;
+	posReal: Vec2;
+	posRealLast: Vec2;
+	posScaled: Vec2;
+	posScaledLast: Vec2;
+	pressed: boolean[];
+	private game;
+	constructor(game: Game);
+	reset(): void;
+	private update;
+}
+export interface GameEventMap {
+	gameloopStopped: [
+	];
+	inputControllerConnected: [
+		event: Gamepad
+	];
+	inputControllerDisconnected: [
+	];
+	inputKeyboard: [
+		keys: Record<string, boolean>,
+		code: string,
+		pressed: boolean
+	];
+	inputPointer: [
+		pointer: Pointer
+	];
+	resized: [
+	];
+}
+export interface EventSystemOptions {
+	once?: boolean;
+	signal?: AbortSignal;
+}
+export declare class EventSystem {
+	private static eventListener;
+	private static logListenerError;
+	private static nextId;
+	static addEventListener<K extends keyof GameEventMap>(eventName: K, callback: (...args: GameEventMap[K]) => void, options?: EventSystemOptions): () => void;
+	static dispatchEvent<K extends keyof GameEventMap>(eventName: K, ...params: GameEventMap[K]): void;
+}
+export type CssStyleKey = {
+	[K in keyof CSSStyleDeclaration]: K extends string ? CSSStyleDeclaration[K] extends string ? K : never : never;
+}[keyof CSSStyleDeclaration];
+export type CssProxy = (key: CssStyleKey, value: string) => void;
+export interface ShakeType {
+	step: number;
+	update: (updateCss: CssProxy, time: number) => void;
+}
+export declare const SHAKE_TYPES: {
+	NORMAL: {
+		step: number;
+		update(updateCss: CssProxy, time: number): void;
+	};
+	FAST: {
+		step: number;
+		update(updateCss: CssProxy, time: number): void;
+	};
+};
+/**
+ * Only the built-in shake types (NORMAL, FAST) are supported today.
+ * Letting callers define their own could be a possible feature — impact pulses, slow rumble, directional jolts.
+ */
+export declare class Screenshake {
+	private isShaking;
+	private shakeType;
+	private style;
+	constructor(element: HTMLElement);
+	/** Best-effort style restore: each key the shake writes is snapshotted on first write and rewritten when the shake ends or is disposed. */
+	shake(shakeType?: ShakeType): null | (() => void);
+}
+export declare class ControllerCursor {
+	private axisId;
+	private controller;
+	private game;
+	private pos;
+	get centerPos(): Vec2;
+	constructor(controller: Controller, game: Game, axisId: number);
+	draw(context: CanvasRenderingContext2D): void;
+	update(dt: number): void;
+}
+export declare const CONTROLLER_KEYS: {
+	readonly A: 0;
+	readonly B: 1;
+	readonly X: 2;
+	readonly Y: 3;
+	readonly LB: 4;
+	readonly RB: 5;
+	readonly LT: 6;
+	readonly RT: 7;
+	readonly SELECT: 8;
+	readonly START: 9;
+	readonly LEFT_STICK: 10;
+	readonly RIGHT_STICK: 11;
+	readonly UP: 12;
+	readonly DOWN: 13;
+	readonly LEFT: 14;
+	readonly RIGHT: 15;
+	readonly GUIDE: 16;
+};
+export declare class Controller {
+	buttons: boolean[];
+	cursors: ControllerCursor[];
+	private axes;
+	private index;
+	private lastTime;
+	constructor(game: Game);
+	draw(context: CanvasRenderingContext2D): void;
+	update(dt: number): void;
+	reset(): void;
+	vibrate(): boolean;
+	stick(index: number): Vec2;
+	private getGamepad;
+}
+/**
+ * Validates URL format and protocol before any side effects.
+ * Throws on invalid URLs or disallowed protocols.
+ */
+export declare function validateUrl(url: string): void;
+/**
+ * Safe loading wrapper with global timeout and error handling.
+ * Use this for any async loading operation that needs timeout protection.
+ * Timeout rejects the returned promise but does not cancel the underlying
+ * fetch/Image — the request continues until natural completion. Adding
+ * AbortSignal support would require a full rewrite (factory-based API).
+ * Maybe a future feature, though.
+ */
+export declare function safeLoad<T>(promise: Promise<T>, url: string, operationName: string): Promise<T>;
+/**
+ * Loads an image with timeout and error handling
+ */
+export declare function loadImage(url: string): Promise<HTMLImageElement>;
+/**
+ * Loads a canvas from image URL with error handling
+ */
+export declare function loadCanvas(url: string): Promise<HTMLCanvasElement>;
+/**
+ * Loads text content from URL with error handling
+ */
+export declare function loadText(url: string): Promise<string>;
+/**
+ * Loads JSON data from URL with error handling
+ */
+export declare function loadJson<T = unknown>(url: string): Promise<T>;
+/**
+ * Loads JSON with inline comments
+ */
+export declare function loadJsonCommented<T = unknown>(url: string): Promise<T>;
+/**
+ * Loads image sprites from JSON configuration with error handling
+ */
+export declare function loadImageFromJson(baseUrl: string, filenameOrJson: string, jsonInput?: boolean): Promise<Record<string, HTMLCanvasElement>>;
+/**
+ * Loads multiple resources concurrently with error handling
+ */
+export declare function loadBunch<T extends Record<string, Promise<unknown>>>(bunch: T): Promise<{
+	[K in keyof T]: Awaited<T[K]>;
+}>;
+/**
+ * Split an array into chunks of at most `maxLength` elements each. Throws when `maxLength < 1`.
+ */
+export declare function chunk<T>(array: ReadonlyArray<T>, maxLength: number): T[][];
+/**
+ * Pick a uniformly random element from `array`. Throws if `array` is empty — guard at the call site if that's possible.
+ */
+export declare function randomItem<T>(array: ReadonlyArray<T>): T;
+/**
+ * Remove an entry of an Array
+ */
+export declare function remove<T>(arr: T[], item: T): void;
+/**
+ * Shuffle array using Fisher-Yates algorithm with custom random signer
+ */
+export declare function shuffle<T>(arr: ReadonlyArray<T>): T[];
+export interface CSSVariables {
+	root: HTMLElement;
+	get(name: string): string;
+	set(name: string, value: string): void;
+}
+/**
+ * `querySelector` variant that throws when no element matches.
+ * Optionally narrow the return type per tag, e.g. `getElement<HTMLCanvasElement>("canvas")`.
+ */
+export declare function getElement<T extends Element = HTMLElement>(query: string, parent?: ParentNode): T;
+/**
+ * Apply a partial `CSSStyleDeclaration` to an element.
+ */
+export declare function styleElement(element: HTMLElement, styles: Partial<CSSStyleDeclaration>): void;
+/**
+ * Toggle `element.style.display` between `""` (active) and `"none"` (inactive).
+ */
+export declare function setDisplay(element: HTMLElement, active: boolean): void;
+/**
+ * Toggle `element.style.visibility` between `""` (active) and `"hidden"` (inactive).
+ */
+export declare function setVisibility(element: HTMLElement, active: boolean): void;
+/**
+ * Returns `get` / `set` helpers for CSS custom properties (`--name`) on the `:root` element.
+ */
+export declare function initCSSVariables(): CSSVariables;
+/**
+ * Calls `callback` on pointerdown of the matched element, then keeps calling it every `delay` ms
+ * until pointerup or pointercancel. Uses pointer capture so the action persists while the cursor
+ * drags off the element (and over descendants). Unifies mouse, touch, and pen. Throws if no element
+ * matches. Returns a dispose function that removes the listeners and stops any in-flight interval.
+ */
+export declare function doWhilePressed(querySelector: string, callback: () => void, delay?: number): () => void;
+/**
+ * Resolves the next time `type` fires on `element` (one-shot listener). Pass an `AbortSignal`
+ * to cancel — rejects with `signal.reason` and removes the listener.
+ */
+export declare function waitForEvent<K extends keyof HTMLElementEventMap>(element: HTMLElement, type: K, signal?: AbortSignal): Promise<void>;
+/**
+ * Returns a debounced wrapper that runs `callback` only after `delay` ms of silence (trailing edge).
+ */
+export declare function debounce<T extends unknown[]>(callback: (...args: T) => void, delay: number): (...args: T) => void;
+/**
+ * Promise that resolves after `time` milliseconds.
+ */
+export declare function delay(time: number): Promise<void>;
+/**
+ * Returns `true` when touch is the primary input right now (game-UI question: show touch controls?).
+ * Mode-aware: a convertible in laptop mode returns `false`, in tablet mode returns `true`.
+ * Snapshot at call time — won't auto-update if the user switches modes mid-game.
+ */
+export declare function isTouchPrimary(): boolean;
+/**
+ * Run `tick(dt)` on every animation frame; `dt` is seconds since the previous
+ * frame (0 on the first call). Returns a cancel function that stops the loop —
+ * no further ticks fire after it's called, even if one was already queued.
+ */
+export declare function rafLoop(tick: (dt: number) => void): () => void;
+/**
+ * Returns a throttled wrapper that runs `callback` at most once per `delay` ms (leading edge).
+ * The callback receives the number of wrapper calls since the previous firing (inclusive of this one).
+ */
+export declare function throttle(callback: (callCount: number) => void, delay?: number): () => void;
+/**
+ * Like `throttle`, but tracks the last firing independently per `key` —
+ * different keys never throttle each other. Use for de-duplicating repeated
+ * error/warning logs by message identity. When the throttle fires, args from
+ * the most recent call for that key are passed through alongside `callCount`.
+ */
+export declare function throttleByKey<T extends unknown[]>(callback: (callCount: number, ...args: T) => void, delay?: number): (key: string, ...args: T) => void;
+/**
+ * Filename component of a URL/path, without directory, extension, or query string.
+ * Returns `null` when no usable name can be derived: a path ending in `/`, or a stem containing a malformed percent-escape that `decodeURIComponent` rejects.
+ */
+export declare function urlBasename(path: string): string | null;
+/**
+ * Clone a 2D grid; the outer array and each row become independent copies.
+ * Row cells are kept as-is (suitable for primitive cells; for nested structures use `deepClone`).
+ */
+export declare function cloneGrid<T>(grid: ReadonlyArray<ReadonlyArray<T>>): T[][];
+/**
+ * Convert a 1D index to `{x, y}` for a 2D grid of the given row width.
+ */
+export declare function convert1DTo2D(index: number, width: number): Vector2;
+/**
+ * Convert 2D `(x, y)` coordinates to a 1D index for a grid of the given row width.
+ */
+export declare function convert2DTo1D(indexX: number, indexY: number, width: number): number;
+export type GridPrimitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Generate a `height × width` 2D grid; every cell holds `defaultValue`. Restricted to primitives at the type level — for object/array cells use the factory overload to avoid every cell sharing the same reference.
+ */
+export declare function generateGrid<T extends GridPrimitive>(height: number, width: number, defaultValue: T): T[][];
+/**
+ * Generate a `height × width` 2D grid by invoking `factory(x, y)` for each cell. Use this overload for object/array cells (and for any per-cell computation).
+ */
+export declare function generateGrid<T>(height: number, width: number, factory: (x: number, y: number) => T): T[][];
+/**
+ * Recursively clone a value. Returns primitives and functions as-is (no copy).
+ * Cyclic references resolve via an internal `WeakMap`. Explicit branches preserve
+ * `Date`, `RegExp`, `Map`, `Set`, `Array`, `ArrayBuffer`, typed arrays, and `DataView`.
+ * For plain objects / class instances the prototype is preserved via
+ * `Object.create(...)` — the original constructor is *not* called, so no side
+ * effects fire. Symbol keys and non-enumerable data properties are carried via descriptors.
+ * Own accessor properties (`get`/`set`) are snapshotted to a data property by invoking
+ * the getter on the source; this severs any closure binding to the original instance
+ * but also drops live computation on the clone.
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Check if a value is a finite number or a string holding one. Accepts optional leading sign, decimal forms (`.5`, `5.`, `3.14`), and scientific notation (`1e5`, `-3.14e-2`).
+ */
+export declare function isNumeric(value: unknown): boolean;
+/**
+ * Generate a random angle between 0 and 2-PI in radians
+ */
+export declare function random2Pi(): number;
+/**
+ * Generate a random float between two values. Bounds may be passed in either order.
+ */
+export declare function randomBetweenFloat(min: number, max: number): number;
+/**
+ * Generate a random integer in `[min, max]` (both bounds inclusive). Bounds may be passed in either order.
+ */
+export declare function randomBetweenInt(min: number, max: number): number;
+/**
+ * Generate a random boolean value
+ */
+export declare function randomBoolean(): boolean;
+/**
+ * Generate a random sign (1 or -1)
+ */
+export declare function randomSign(): number;
+/**
+ * Format time in seconds as HH:MM:SS string
+ */
+export declare function toHHMMSS(time: number): string;
+/**
+ * Convert radians to degrees
+ */
+export declare function toDegrees(radians: number): number;
+/**
+ * Convert degrees to radians
+ */
+export declare function toRadians(degrees: number): number;
+/**
+ * Wrap an angle in radians into `[-PI, PI)`.
+ */
+export declare function wrapRadians(angle: number): number;
+/**
+ * Wrap an angle in degrees into `[-180, 180)`.
+ */
+export declare function wrapDegrees(angle: number): number;
+/**
+ * Round a number to a specified number of decimal places
+ */
+export declare function roundTo(number: number, digitsAfterPoint: number): number;
+/**
+ * Calculate factorial of a non-negative integer. Memoized — repeat calls reuse cached intermediates.
+ * Returns `Infinity` once `n!` overflows the IEEE 754 double range (around `n = 171`).
+ */
+export declare function getFactorial(n: number): number;
+/**
+ * Compare two numbers with float tolerance. Default epsilon absorbs typical accumulated rounding error from normalize/rotate/divide chains.
+ */
+export declare function approxEqual(a: number, b: number, epsilon?: number): boolean;
+/**
+ * Clamp values between two values
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Map value from one range to another. Returns `low2` when the source range is degenerate (`low1 === high1`).
+ */
+export declare function mapUnclamped(value: number, low1: number, high1: number, low2: number, high2: number): number;
+/**
+ * Map value from one range to another (with clamping). Output range allows to be inverted (`high2 < low2`).
+ */
+export declare function map(value: number, low1: number, high1: number, low2: number, high2: number): number;
+/**
+ * Zero out values with `|value| < cutoff`; pass the rest through unchanged.
+ */
+export declare function threshold(value: number, cutoff: number): number;
+/**
+ * Format number with dot separators (e.g., 1.000.000). Rounds to the nearest integer via `Math.round`; non-finite values pass through as their `toString()` form.
+ */
+export declare function toDotted(value: number): string;
+/**
+ * Wrap `value` into `[min, max)` modulo the range size. Useful for cyclic ranges like angles.
+ * Caller steps via `value + n`; this function handles the wrap-around.
+ * Bounds are swapped if passed in reverse order. Throws when `min ≈ max` (degenerate range, via `approxEqual`).
+ */
+export declare function wrapValue(value: number, min: number, max: number): number;
+export type Method<T, K extends keyof T> = T[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : never;
+/**
+ * Define `name` as a non-enumerable method on `proto`. Carries the declared signature so impl `this` and parameters are inferred from the merged declaration.
+ */
+export declare function defineMethod<T, K extends keyof T>(proto: T, name: K, value: Method<T, K>): void;
+/**
+ * Trim `str` and collapse internal whitespace runs to a single space.
+ */
+export declare function compact(str: string): string;
+/**
+ * Replace the single character at `index` in `str`. Indexes by code point, so emoji and other supplementary-plane characters count as one. Throws on out-of-range index or multi-character `char`.
+ */
+export declare function replaceCharAt(str: string, index: number, char: string): string;
+
+export {};