littlejsengine 1.24.2 → 1.25.0

package/dist/littlejs.d.ts

@@ -88,6 +88,50 @@ declare module "littlejsengine" {
      * - Function called when sound is loaded
      */
     export type SoundLoadCallback = (sound: Sound) => any;
+    /**
+     * A Tiled map as Tiled saves it as JSON, what tileLayersLoad and objectLayersLoad take and tileLayersFromLDtk
+     * makes; the fields read are listed, and the rest of the file is kept as it is
+     */
+    export type TiledMap = {
+        /**
+         * - Cells across
+         */
+        width: number;
+        /**
+         * - Cells up
+         */
+        height: number;
+        /**
+         * - A tile's width in pixels
+         */
+        tilewidth?: number;
+        /**
+         * - A tile's height in pixels
+         */
+        tileheight?: number;
+        /**
+         * - Tile layers, object layers and groups of them, bottom first
+         */
+        layers: Array<any>;
+        /**
+         * - The first one's margin, spacing and columns are read
+         */
+        tilesets?: any[];
+        nextlayerid?: number;
+        nextobjectid?: number;
+        orientation?: string;
+        renderorder?: string;
+        infinite?: boolean;
+        type?: string;
+        /**
+         * - A number in files from Tiled before 1.6
+         */
+        version?: string | number;
+        tiledversion?: string;
+        compressionlevel?: number;
+        backgroundcolor?: string;
+        properties?: any[];
+    };
     /**
      * - Function that processes a particle
      */
@@ -96,6 +140,10 @@ declare module "littlejsengine" {
      * - Decides whether a particle stops at a tile, it is a filter rather than a notice
      */
     export type ParticleCollideCallback = (particle: Particle, tileData: number, pos: Vector2) => boolean;
+    /**
+     * - Callback for drag and drop events
+     */
+    export type DragAndDropCallback = (event: DragEvent) => any;
     /**
      * A scene, any object with the hooks it needs, each optional and called as a method so this is the scene
      */
@@ -234,10 +282,69 @@ declare module "littlejsengine" {
         normal: Vector3;
         type: number;
     };
+    /**
+     * A 3D level as it is saved, what level3DLoad takes and the 3D level editor edits
+     */
+    export type Level3D = {
+        /**
+         * - The format's version, 1
+         */
+        littlejs3D?: number;
+        /**
+         * - Each {id, type, pos, rotation, scale, properties}, all but type optional
+         */
+        objects: Array<any>;
+        /**
+         * - The scene block: sky, ambient, sunDirection, sunColor, fog, fogColor, shadows, lensFlare
+         */
+        scene?: any;
+        /**
+         * - A block map: {pos, size, blocks}
+         */
+        voxels?: any;
+        /**
+         * - A height map: {pos, size, height, color, heights, paint}
+         */
+        terrain?: any;
+        /**
+         * - The level's own prefabs by name, each {objects, attached}
+         */
+        prefabs?: any;
+    };
+    /**
+     * What bends a skinned part: its joints, the nodes that move it, their inverse bind matrices, and for each vertex
+     * of its mesh four joints and four weights, with the place and normal each pose bends from
+     */
+    export type GLTFSkin = {
+        /**
+         * - The joints, as node numbers
+         */
+        joints: Array<number>;
+        /**
+         * - Each joint's inverse bind matrix
+         */
+        inverseBind: Array<Matrix4>;
+        /**
+         * - Four joints a vertex, as places in joints
+         */
+        vertexJoints: Uint16Array;
+        /**
+         * - Four weights a vertex, summing to 1
+         */
+        vertexWeights: Float32Array;
+        /**
+         * - Each vertex's place as stored, x y z
+         */
+        bindPoints: Float32Array;
+        /**
+         * - Each vertex's normal as stored, x y z
+         */
+        bindNormals: Float32Array;
+    };
     /**
      * - Puts the player at a world position, for the level editor's Play from mouse
      */
-    export type EditorPlayFromCallback = (pos: Vector2) => any;
+    export type EditorPlayFromCallback = (pos: any) => any;
     /**
      * - Rebuilds the level from the map the level editor changed
      */
@@ -247,14 +354,15 @@ declare module "littlejsengine" {
      */
     export type EditorTileCallback = (layer: TileLayer, pos: Vector2, tile: number | undefined) => any;
     /**
-     * - What the level editor gives the callbacks of a tool of the game's own
+     * - What the level editor gives the callbacks of a tool of the game's own; P is
+     *   the type of pos, a Vector2 for a 2D tool, the default, and Vector3|undefined for a 3D one
      */
-    export type EditorToolAt = {
+    export type EditorToolAt<P = Vector2> = {
         /**
          * - Where the mouse is in the level: a Vector2 in the 2D editor; in the 3D one a Vector3 on
          * the level or the ground, undefined when the mouse is over the panel
          */
-        pos: any;
+        pos: P;
         /**
          * - 2D: the tile cell under the mouse on the selected tile layer
          */
@@ -262,7 +370,7 @@ declare module "littlejsengine" {
         /**
          * - 3D: the mouse's Ray3D
          */
-        ray: any;
+        ray: Ray3D | undefined;
         /**
          * - Is Shift held
          */
@@ -273,9 +381,10 @@ declare module "littlejsengine" {
         ctrl: boolean;
     };
     /**
-     * - A tool of the game's own for the level editor, see LevelEditor.addTool
+     * - A tool of the game's own for the level editor, see LevelEditor.addTool; P is the
+     *   type of its pos, as EditorToolAt has it
      */
-    export type EditorTool = {
+    export type EditorTool<P = Vector2> = {
         /**
          * - The key that picks it, as addKey spells one
          */
@@ -288,19 +397,19 @@ declare module "littlejsengine" {
          * - The left button went down in the level; returning false
          * says the press was not the tool's
          */
-        onPress?: (arg0: EditorToolAt) => any;
+        onPress?: (arg0: EditorToolAt<P>) => any;
         /**
          * - Each frame it is held
          */
-        onDrag?: (arg0: EditorToolAt) => any;
+        onDrag?: (arg0: EditorToolAt<P>) => any;
         /**
          * - It was let go
          */
-        onRelease?: (arg0: EditorToolAt) => any;
+        onRelease?: (arg0: EditorToolAt<P>) => any;
         /**
          * - Each frame the tool is on, to draw its cursor or preview
          */
-        onDraw?: (arg0: EditorToolAt) => any;
+        onDraw?: (arg0: EditorToolAt<P>) => any;
     };
     /**
      * - The 2D level editor's edit functions, levelEditor.edit2D
@@ -549,8 +658,9 @@ declare module "littlejsengine" {
      *    ()=> { drawHUD(); },                 // gameRenderPost
      *    ['tiles.png', 'tilesLevel.png']       // images to load
      *  );
-     *  @memberof Engine */
-    export function engineInit(gameInit?: GameInitCallback, gameUpdate?: GameCallback, gameUpdatePost?: GameCallback, gameRender?: GameCallback, gameRenderPost?: GameCallback, imageSources?: Array<string>, rootElement?: HTMLElement): Promise<void>;
+     *  @memberof Engine
+     *  @return {Promise<void>} - Done when the images have loaded and gameInit has run */
+    export function engineInit(gameInit?: GameInitCallback, gameUpdate?: GameCallback, gameUpdatePost?: GameCallback, gameRender?: GameCallback, gameRenderPost?: GameCallback, imageSources?: string[], rootElement?: HTMLElement): Promise<void>;
     /** Advance the engine by a number of frames
      *  Requires setEngineManualStep(true), before engineInit or while running; it stops early if an update turns it off
      *  Respects paused exactly as the normal update loop does
@@ -584,7 +694,7 @@ declare module "littlejsengine" {
      *  @param {boolean} [testCenters] - Test only each object's center, a little faster, and ignores object sizes
      *  @return {Array<EngineObject>} - List of collected objects
      *  @memberof Engine */
-    export function engineObjectsCollect(pos?: Vector2, size?: Vector2 | number, objects?: Array<EngineObject>, testCenters?: boolean): Array<EngineObject>;
+    export function engineObjectsCollect(pos?: Vector2, size?: number | Vector2, objects?: EngineObject[], testCenters?: boolean): Array<EngineObject>;
     /**
      * @callback ObjectCallbackFunction - Function that processes an object
      * @param {EngineObject} object
@@ -598,7 +708,7 @@ declare module "littlejsengine" {
      *  @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
      *  @param {boolean} [testCenters] - Test only each object's center, see engineObjectsCollect
      *  @memberof Engine */
-    export function engineObjectsCallback(pos?: Vector2, size?: Vector2 | number, callbackFunction?: ObjectCallbackFunction, objects?: Array<EngineObject>, testCenters?: boolean): void;
+    export function engineObjectsCallback(pos?: Vector2, size?: number | Vector2, callbackFunction?: ObjectCallbackFunction, objects?: EngineObject[], testCenters?: boolean): void;
     /** Return a list of objects intersecting a ray, objects destroyed this frame left out
      *  - Only objects with collideRaycast set are hit, which setCollision turns on
      *  @param {Vector2} start
@@ -606,7 +716,7 @@ declare module "littlejsengine" {
      *  @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
      *  @return {Array<EngineObject>} - List of objects hit
      *  @memberof Engine */
-    export function engineObjectsRaycast(start: Vector2, end: Vector2, objects?: Array<EngineObject>): Array<EngineObject>;
+    export function engineObjectsRaycast(start: Vector2, end: Vector2, objects?: EngineObject[]): Array<EngineObject>;
     /**
      * @callback PluginCallback - Update or render function for a plugin
      * @memberof Engine
@@ -688,7 +798,7 @@ declare module "littlejsengine" {
      */
     /**
      *  @callback EditorPlayFromCallback - Puts the player at a world position, for the level editor's Play from mouse
-     *  @param {Vector2} pos - Where to start playing
+     *  @param {any} pos - Where to start playing, a Vector2 from the 2D editor and a Vector3 from the 3D one
      *  @memberof Editor
      */
     /**
@@ -703,24 +813,28 @@ declare module "littlejsengine" {
      *  @memberof Editor
      */
     /**
-     *  @typedef {Object} EditorToolAt - What the level editor gives the callbacks of a tool of the game's own
-     *  @property {any} pos - Where the mouse is in the level: a Vector2 in the 2D editor; in the 3D one a Vector3 on
+     *  @template [P=Vector2]
+     *  @typedef {Object} EditorToolAt - What the level editor gives the callbacks of a tool of the game's own; P is
+     *    the type of pos, a Vector2 for a 2D tool, the default, and Vector3|undefined for a 3D one
+     *  @property {P} pos - Where the mouse is in the level: a Vector2 in the 2D editor; in the 3D one a Vector3 on
      *    the level or the ground, undefined when the mouse is over the panel
      *  @property {Vector2|undefined} cell - 2D: the tile cell under the mouse on the selected tile layer
-     *  @property {any} ray - 3D: the mouse's Ray3D
+     *  @property {Ray3D|undefined} ray - 3D: the mouse's Ray3D
      *  @property {boolean} shift - Is Shift held
      *  @property {boolean} ctrl - Is Ctrl held
      *  @memberof Editor
      */
     /**
-     *  @typedef {Object} EditorTool - A tool of the game's own for the level editor, see LevelEditor.addTool
+     *  @template [P=Vector2]
+     *  @typedef {Object} EditorTool - A tool of the game's own for the level editor, see LevelEditor.addTool; P is the
+     *    type of its pos, as EditorToolAt has it
      *  @property {string} [key] - The key that picks it, as addKey spells one
      *  @property {string} [hint] - The hint line while it is on
-     *  @property {function(EditorToolAt): any} [onPress] - The left button went down in the level; returning false
+     *  @property {function(EditorToolAt<P>): any} [onPress] - The left button went down in the level; returning false
      *    says the press was not the tool's
-     *  @property {function(EditorToolAt): any} [onDrag] - Each frame it is held
-     *  @property {function(EditorToolAt): any} [onRelease] - It was let go
-     *  @property {function(EditorToolAt): any} [onDraw] - Each frame the tool is on, to draw its cursor or preview
+     *  @property {function(EditorToolAt<P>): any} [onDrag] - Each frame it is held
+     *  @property {function(EditorToolAt<P>): any} [onRelease] - It was let go
+     *  @property {function(EditorToolAt<P>): any} [onDraw] - Each frame the tool is on, to draw its cursor or preview
      *  @memberof Editor
      */
     /**
@@ -816,9 +930,9 @@ declare module "littlejsengine" {
             onClick: Function;
             title: string;
         }>;
-        /** @type {Object<string, EditorTool>} */
+        /** @type {Object<string, EditorTool<any>>} */
         tools: {
-            [x: string]: EditorTool;
+            [x: string]: EditorTool<any>;
         };
         /** What the game does when the 2D editor paints a tile, like setting its collision or its look the way the
          *  game does when it loads the level; set it or override it, without one the collision layer gets collision 1
@@ -832,7 +946,7 @@ declare module "littlejsengine" {
         onRestart(): void;
         /** Put the player at a position, a Vector2 in the 2D editor and a Vector3 in the 3D one; set it or override it
          *  and the editor has Play from mouse, which starts play there
-         *  @param {any} pos */
+         *  @param {any} pos - A Vector2 from the 2D editor, a Vector3 from the 3D one */
         onPlayFrom(pos: any): void;
         /** Called when the editor opens, to set or override */
         onOpen(): void;
@@ -868,7 +982,7 @@ declare module "littlejsengine" {
          *  place(type, pos3D); setTransform(object, pos3D, rotationDegrees, scale3D); setProperty(object, name, value);
          *  pos(object), rotation(object) and scale(object); mousePoint(); undo(redo); toJSON()
          *  @return {EditorEdit3D|undefined} */
-        get edit3D(): EditorEdit3D;
+        get edit3D(): EditorEdit3D | undefined;
         /** Add a key of the game's own to the editor, the 2D and the 3D one
          *  - Escape and 0 are the editor's own, to play and to exit, and Ctrl is the one modifier: Shift is given to
          *    the action
@@ -890,15 +1004,16 @@ declare module "littlejsengine" {
          *    in 3D
          *  - What the callbacks change through edit2D or edit3D is one undo: the editor ends the stroke at the release,
          *    and takes it back when the right button or Escape ends the press
+         *  @template [P=Vector2]
          *  @param {string} name
-         *  @param {EditorTool} tool - {key, hint, onPress, onDrag, onRelease, onDraw}, each optional; onPress returning
+         *  @param {EditorTool<P>} tool - {key, hint, onPress, onDrag, onRelease, onDraw}, each optional; onPress returning
          *    false says the press was not the tool's */
-        addTool(name: string, tool: EditorTool): void;
+        addTool<P = Vector2>(name: string, tool: EditorTool<P>): void;
         /** Open the editor, pausing the game; until close(), Escape (the debug key) switches between playing and editing */
-        open(): any;
+        open(): void;
         /** Close the editor and end its session, the game carries on with the changes and Escape opens the debug
          *  overlay again */
-        close(): any;
+        close(): void;
     }
     /** Make a level editor of the game's own the one in use: an instance of a class that extends LevelEditor, with
      *  the game's hooks as its methods; set it before the editor opens
@@ -922,14 +1037,14 @@ declare module "littlejsengine" {
     export const debugPointSize: number;
     /** Draw a debug rectangle in world space, or on the screen with screenSpace
      *  @param {Vector2} pos
-     *  @param {Vector2} [size=vec2(0)]
+     *  @param {Vector2} [size=vec2()]
      *  @param {Color|string} [color]
      *  @param {number} [time]
      *  @param {number} [angle]
      *  @param {boolean} [fill]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugRect(pos: Vector2, size?: Vector2, color?: Color | string, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
+    export function debugRect(pos: Vector2, size?: Vector2, color?: string | Color, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
     /** Draw a debug poly in world space, or on the screen with screenSpace
      *  @param {Vector2} pos
      *  @param {Array<Vector2>} points
@@ -939,7 +1054,7 @@ declare module "littlejsengine" {
      *  @param {boolean} [fill]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugPoly(pos: Vector2, points: Array<Vector2>, color?: Color | string, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
+    export function debugPoly(pos: Vector2, points: Array<Vector2>, color?: string | Color, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
     /** Draw a debug circle in world space, or on the screen with screenSpace
      *  @param {Vector2} pos
      *  @param {number} [size] - diameter
@@ -948,7 +1063,7 @@ declare module "littlejsengine" {
      *  @param {boolean} [fill]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugCircle(pos: Vector2, size?: number, color?: Color | string, time?: number, fill?: boolean, screenSpace?: boolean): void;
+    export function debugCircle(pos: Vector2, size?: number, color?: string | Color, time?: number, fill?: boolean, screenSpace?: boolean): void;
     /** Draw a debug point in world space, or on the screen with screenSpace
      *  @param {Vector2} pos
      *  @param {Color|string} [color]
@@ -956,7 +1071,7 @@ declare module "littlejsengine" {
      *  @param {number} [angle]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugPoint(pos: Vector2, color?: Color | string, time?: number, angle?: number, screenSpace?: boolean): void;
+    export function debugPoint(pos: Vector2, color?: string | Color, time?: number, angle?: number, screenSpace?: boolean): void;
     /** Draw a debug line in world space, or on the screen with screenSpace
      *  @param {Vector2} posA
      *  @param {Vector2} posB
@@ -965,7 +1080,7 @@ declare module "littlejsengine" {
      *  @param {number} [time]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugLine(posA: Vector2, posB: Vector2, color?: Color | string, width?: number, time?: number, screenSpace?: boolean): void;
+    export function debugLine(posA: Vector2, posB: Vector2, color?: string | Color, width?: number, time?: number, screenSpace?: boolean): void;
     /** Draw a debug combined axis aligned bounding box in world space, or on the screen with screenSpace
      *  @param {Vector2} posA
      *  @param {Vector2} sizeA
@@ -975,7 +1090,7 @@ declare module "littlejsengine" {
      *  @param {number} [time]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugOverlap(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB: Vector2, color?: Color | string, time?: number, screenSpace?: boolean): void;
+    export function debugOverlap(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB: Vector2, color?: string | Color, time?: number, screenSpace?: boolean): void;
     /** Draw debug text in world space, or on the screen with screenSpace
      *  @param {string|number} text
      *  @param {Vector2} pos
@@ -986,7 +1101,7 @@ declare module "littlejsengine" {
      *  @param {string} [font]
      *  @param {boolean} [screenSpace=drawScreenSpace]
      *  @memberof Debug */
-    export function debugText(text: string | number, pos: Vector2, size?: number, color?: Color | string, time?: number, angle?: number, font?: string, screenSpace?: boolean): void;
+    export function debugText(text: string | number, pos: Vector2, size?: number, color?: string | Color, time?: number, angle?: number, font?: string, screenSpace?: boolean): void;
     /** Clear all debug primitives in the list
      *  @memberof Debug */
     export function debugClear(): void;
@@ -1005,7 +1120,8 @@ declare module "littlejsengine" {
      *  @memberof Debug */
     export function debugVideoCaptureStop(): void;
     /** Check if video capture is active
-     *  @memberof Debug */
+     *  @memberof Debug
+     *  @return {boolean} */
     export function debugVideoCaptureIsActive(): boolean;
     /**
      * LittleJS Engine Settings
@@ -1898,9 +2014,9 @@ declare module "littlejsengine" {
     export function formatTime(t: number): string;
     /** Fetches a JSON file from a URL and returns the parsed JSON object. Must be used with await!
      *  @param {string} url - URL of JSON file
-     *  @return {Promise<object>}
+     *  @return {Promise<any>} - The parsed JSON, any shape, as response.json() gives it
      *  @memberof Utilities */
-    export function fetchJSON(url: string): Promise<object>;
+    export function fetchJSON(url: string): Promise<any>;
     /** Save a text file to disk
      *  @param {string} text
      *  @param {string} [filename]
@@ -2512,7 +2628,7 @@ declare module "littlejsengine" {
      * Create a tile info object using a grid based system
      * - This can take vecs or floats for easier use and conversion
      * - If an index is passed in, the tile size and index will determine the position
-     * @param {Vector2|number} [index=0] - Index of the tile in 1d or 2d form
+     * @param {Vector2|number} [index] - Index of the tile in 1d or 2d form
      * @param {Vector2|number} [size] - Size of tile in pixels
      * @param {TextureInfo|number} [texture] - Texture index or info to use
      * @param {number} [padding] - How many pixels padding around tiles
@@ -2524,7 +2640,7 @@ declare module "littlejsengine" {
      * tile(1, 16, 3)                // a tile at index 1 of size 16 on texture 3
      * tile(vec2(4,8), vec2(30,10))  // a tile at index (4,8) with a size of (30,10)
      * @memberof Draw */
-    export function tile(index?: Vector2 | number, size?: Vector2 | number, texture?: TextureInfo | number, padding?: number, bleed?: number): TileInfo;
+    export function tile(index?: number | Vector2, size?: number | Vector2, texture?: number | TextureInfo, padding?: number, bleed?: number): TileInfo;
     /**
      * Tile Info - Stores info about how to draw a tile
      * @memberof Draw
@@ -2577,7 +2693,7 @@ declare module "littlejsengine" {
          * @param {Vector2|number} [index=0]
          * @return {TileInfo}
          */
-        index(index?: Vector2 | number): TileInfo;
+        index(index?: number | Vector2): TileInfo;
         /**
          * Set this tile to use a full image in a texture info
          * @param {TextureInfo} [textureInfo]
@@ -2598,7 +2714,7 @@ declare module "littlejsengine" {
          *   modes across and down, like [gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT], as a glTF sampler gives them
          * @param {boolean} [pixelated] - Hard edged or smooth for this texture alone, undefined follows tilesPixelated
          */
-        constructor(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, useWebGL?: boolean, wrap?: boolean | Array<number>, pixelated?: boolean);
+        constructor(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, useWebGL?: boolean, wrap?: boolean | number[], pixelated?: boolean);
         /** @property {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} - image source */
         image: OffscreenCanvas | ImageBitmap | HTMLCanvasElement | HTMLImageElement;
         /** @property {Vector2} - size of the image */
@@ -2626,7 +2742,7 @@ declare module "littlejsengine" {
         /** Set the wrap mode for this texture
          *  @param {boolean|Array<number>} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE, or the WebGL modes across
          *    and down */
-        setWrap(wrap?: boolean | Array<number>): void;
+        setWrap(wrap?: boolean | number[]): void;
         /** Make this texture hard edged or smooth on its own, whatever tilesPixelated says for the rest; it is made again
          *  with the new filtering
          *  @param {boolean} [pixelated] - undefined follows tilesPixelated again */
@@ -2915,10 +3031,10 @@ declare module "littlejsengine" {
      *  @param {TileInfo} [tileInfo] - Tile info to use, untextured if undefined
      *  @param {Color}    [color=WHITE] - Color to modulate with
      *  @param {number}   [angle] - Angle to rotate by
-     *  @param {boolean}  [mirror] - Is image flipped along the Y axis?
+     *  @param {boolean}  [mirror] - Is the image flipped left to right?
      *  @param {Color}    [additiveColor] - Additive color to be applied if any
      *  @param {boolean}  [useWebGL=glEnable] - Use accelerated WebGL rendering?
-     *  @param {boolean}  [screenSpace=drawScreenSpace] - Are the pos and size are in screen space?
+     *  @param {boolean}  [screenSpace=drawScreenSpace] - Are the pos and size in screen space?
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas 2D context to draw to
      *  @memberof Draw */
     export function drawTile(pos: Vector2, size?: Vector2, tileInfo?: TileInfo, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
@@ -2949,15 +3065,15 @@ declare module "littlejsengine" {
      *  @param {Vector2}  pos          - Center of the rect in world space
      *  @param {Vector2}  size         - Size of the rect in world space
      *  @param {Vector2}  wrapCount    - How many times the texture repeats (x, y)
-     *  @param {TextureInfo|number} [texture=0] - TextureInfo or texture index into textureInfos
+     *  @param {TextureInfo|number} [texture] - TextureInfo or texture index into textureInfos
      *  @param {Color}    [color=WHITE] - Color to modulate with
-     *  @param {number}   [angle=0] - Angle to rotate by
+     *  @param {number}   [angle] - Angle to rotate by
      *  @param {Color}    [additiveColor] - Additive color to be applied if any
      *  @param {boolean}  [useWebGL=glEnable] - Use accelerated WebGL rendering?
      *  @param {boolean}  [screenSpace=drawScreenSpace] - Are pos and size in screen space?
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas 2D context to draw to
      *  @memberof Draw */
-    export function drawTextureWrapped(pos: Vector2, size: Vector2, wrapCount: Vector2, texture?: TextureInfo | number, color?: Color, angle?: number, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    export function drawTextureWrapped(pos: Vector2, size: Vector2, wrapCount: Vector2, texture?: number | TextureInfo, color?: Color, angle?: number, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw connected lines between a series of points
      *  @param {Array<Vector2>} points
      *  @param {number}  [width]
@@ -3023,9 +3139,9 @@ declare module "littlejsengine" {
     export function drawEllipse(pos: Vector2, size?: Vector2, color?: Color, angle?: number, lineWidth?: number, lineColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw colored circle using passed in point
      *  @param {Vector2} pos
-     *  @param {number}  [size=1] - Diameter
+     *  @param {number}  [size] - Diameter
      *  @param {Color}   [color=WHITE]
-     *  @param {number}  [lineWidth=0]
+     *  @param {number}  [lineWidth]
      *  @param {Color}   [lineColor=BLACK]
      *  @param {boolean} [useWebGL=glEnable]
      *  @param {boolean} [screenSpace=drawScreenSpace]
@@ -3051,7 +3167,7 @@ declare module "littlejsengine" {
      *  - If drawing mostly textured sprites, bake the gradient into a texture and use drawTile instead
      *  - Stacking gradients at the exact same position may show a faint vertical artifact
      *  @param {Vector2} pos
-     *  @param {number}  [size=1] - Diameter
+     *  @param {number}  [size] - Diameter
      *  @param {Color}   [colorInner=WHITE]
      *  @param {Color}   [colorOuter=CLEAR_WHITE]
      *  @param {boolean} [useWebGL=glEnable]
@@ -3085,14 +3201,14 @@ declare module "littlejsengine" {
      *  @param {Color}   [color=WHITE]
      *  @param {number}  [lineWidth]
      *  @param {Color}   [lineColor=BLACK]
-     *  @param {'left'|'center'|'right'} [textAlign='center']
+     *  @param {'left'|'center'|'right'} [textAlign]
      *  @param {string}  [font=fontDefault]
      *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
      *  @param {number}  [angle]
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=drawContext]
      *  @memberof Draw */
-    export function drawText(text: string | number, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: 'left' | 'center' | 'right', font?: string, fontStyle?: string, maxWidth?: number, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    export function drawText(text: string | number, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: "center" | "left" | "right", font?: string, fontStyle?: string, maxWidth?: number, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw text in screen space
      *  Automatically splits new lines into rows
      *  @param {string|number}  text
@@ -3108,7 +3224,7 @@ declare module "littlejsengine" {
      *  @param {number}  [angle] - Clockwise, like the other screen space draws
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=drawContext]
      *  @memberof Draw */
-    export function drawTextScreen(text: string | number, pos: Vector2, size: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: 'left' | 'center' | 'right', font?: string, fontStyle?: string, maxWidth?: number, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    export function drawTextScreen(text: string | number, pos: Vector2, size: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: "center" | "left" | "right", font?: string, fontStyle?: string, maxWidth?: number, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Enable additive blending
      *  @param {boolean} [additive]
      *  @memberof Draw */
@@ -3164,7 +3280,7 @@ declare module "littlejsengine" {
          *  @param {boolean} [useWebGL=glEnable]
          *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
          */
-        drawText(text: string | number, pos: Vector2, size?: Vector2 | number, center?: boolean, color?: Color, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+        drawText(text: string | number, pos: Vector2, size?: number | Vector2, center?: boolean, color?: Color, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
         /** Draw text in screen space using the image font
          *  @param {string|number} text
          *  @param {Vector2} pos
@@ -3224,7 +3340,7 @@ declare module "littlejsengine" {
      *  @param {Vector2|number} [size] - world space size or diameter
      *  @return {boolean}
      *  @memberof Draw */
-    export function isOnScreen(pos: Vector2, size?: Vector2 | number): boolean;
+    export function isOnScreen(pos: Vector2, size?: number | Vector2): boolean;
     /**
      * LittleJS WebGL Interface
      * - WebGL2 rendering engine for high-performance graphics
@@ -3266,27 +3382,27 @@ declare module "littlejsengine" {
      *  @param {boolean|Array<number>} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE, or the WebGL modes across and
      *    down, like [gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT]
      *  @memberof WebGL */
-    export function glSetTextureWrap(texture: WebGLTexture, wrap?: boolean | Array<number>): void;
+    export function glSetTextureWrap(texture: WebGLTexture, wrap?: boolean | number[]): void;
     /** Compile WebGL shader of the given type, will throw errors if in debug mode
      *  @param {string} source
      *  @param {number} type
-     *  @return {WebGLShader}
+     *  @return {WebGLShader|undefined} - undefined with no WebGL
      *  @memberof WebGL */
-    export function glCompileShader(source: string, type: number): WebGLShader;
+    export function glCompileShader(source: string, type: number): WebGLShader | undefined;
     /** Create WebGL program with given shaders
      *  @param {string} vsSource
      *  @param {string} fsSource
-     *  @return {WebGLProgram}
+     *  @return {WebGLProgram|undefined} - undefined with no WebGL
      *  @memberof WebGL */
-    export function glCreateProgram(vsSource: string, fsSource: string): WebGLProgram;
+    export function glCreateProgram(vsSource: string, fsSource: string): WebGLProgram | undefined;
     /** Create WebGL texture from an image and init the texture settings
      *  Restores the active texture when done
      *  @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} [image]
      *  @param {boolean|Array<number>} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE, or the WebGL modes across and down
      *  @param {boolean} [pixelated] - Hard edged or smooth, undefined follows tilesPixelated
-     *  @return {WebGLTexture}
+     *  @return {WebGLTexture|undefined} - undefined with no WebGL
      *  @memberof WebGL */
-    export function glCreateTexture(image?: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, wrap?: boolean | Array<number>, pixelated?: boolean): WebGLTexture;
+    export function glCreateTexture(image?: OffscreenCanvas | ImageBitmap | HTMLCanvasElement | HTMLImageElement, wrap?: boolean | number[], pixelated?: boolean): WebGLTexture | undefined;
     /** Deletes a WebGL texture
      *  @param {WebGLTexture} [texture]
      *  @memberof WebGL */
@@ -3330,8 +3446,8 @@ declare module "littlejsengine" {
      *  @param {number} [uv0Y]
      *  @param {number} [uv1X]
      *  @param {number} [uv1Y]
-     *  @param {number} [rgba=-1] - white is -1
-     *  @param {number} [rgbaAdditive=0] - black is 0
+     *  @param {number} [rgba] - white is -1
+     *  @param {number} [rgbaAdditive] - black is 0
      *  @memberof WebGL */
     export function glDraw(x: number, y: number, sizeX: number, sizeY: number, angle?: number, uv0X?: number, uv0Y?: number, uv1X?: number, uv1Y?: number, rgba?: number, rgbaAdditive?: number): void;
     /** Add an untextured rect to the gl draw list
@@ -3433,19 +3549,16 @@ declare module "littlejsengine" {
      *  @memberof Input */
     export function inputClearKey(key: string | number, device?: number, clearDown?: boolean, clearPressed?: boolean, clearReleased?: boolean): void;
     /** Returns true if mouse button is down
-     *  @function
      *  @param {number} button
      *  @return {boolean}
      *  @memberof Input */
     export function mouseIsDown(button: number): boolean;
     /** Returns true if mouse button was pressed
-     *  @function
      *  @param {number} button
      *  @return {boolean}
      *  @memberof Input */
     export function mouseWasPressed(button: number): boolean;
     /** Returns true if mouse button was released
-     *  @function
      *  @param {number} button
      *  @return {boolean}
      *  @memberof Input */
@@ -3686,13 +3799,13 @@ declare module "littlejsengine" {
      */
     export class Sound {
         /** Create a sound object and cache the audio for later use
-         *  @param {string|URL|Array} [asset] - Filename or URL of an audio file, or a zzfx array
+         *  @param {string|URL|Array<number|undefined>} [asset] - Filename or URL of an audio file, or a zzfx array
          *  @param {number} [randomness] - How much to randomize frequency each time sound plays, for zzfx sounds it overrides the array's own randomness, which is used if undefined
          *  @param {number} [range=soundDefaultRange] - World space max range of sound
          *  @param {number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering
          *  @param {SoundLoadCallback} [onloadCallback] - callback function to call when sound is loaded
          */
-        constructor(asset?: string | URL | any[], randomness?: number, range?: number, taper?: number, onloadCallback?: SoundLoadCallback);
+        constructor(asset?: string | URL | (number | undefined)[], randomness?: number, range?: number, taper?: number, onloadCallback?: SoundLoadCallback);
         loadedPercent: number;
         set range(arg: number);
         /** World space max range of sound, 0 for no limit; a range that is set is the sound's own, in 3D too
@@ -3700,16 +3813,16 @@ declare module "littlejsengine" {
         get range(): number;
         /** @property {boolean} - No range was given, so it got soundDefaultRange; played in 3D such a sound is heard
          *  to render3D.soundDefaultRange instead, which is further; setting range makes it false */
-        rangeIsDefault: boolean;
+        rangeIsDefault: boolean | undefined;
         /** @property {number} - At what percentage of range should it start tapering */
-        taper: number;
+        taper: number | undefined;
         /** @property {number} - How much to randomize frequency each time sound plays
          *  @type {number} */
         randomness: number;
         /** @property {number} - Sample rate for this sound */
-        sampleRate: number;
+        sampleRate: number | undefined;
         /** @property {number} - How many samples per channel this sound has */
-        sampleLength: number;
+        sampleLength: number | undefined;
         /** @property {AudioBuffer|undefined} - Decoded audio shared by every play of this sound
          *  @type {AudioBuffer|undefined} */
         sampleBuffer: AudioBuffer | undefined;
@@ -3724,14 +3837,14 @@ declare module "littlejsengine" {
          *  @type {AudioNode|AudioEffectNodes|undefined} */
         output: AudioNode | AudioEffectNodes | undefined;
         /** @param {Array<Array<number>|Float32Array>} sampleChannels */
-        set sampleChannels(arg: (number[] | Float32Array)[]);
+        set sampleChannels(arg: (number[] | Float32Array)[] | undefined);
         /** Sample data for each channel
          *  Sounds keep their samples in an audio buffer, so reading this rebuilds
          *  the arrays from it and caches them. The copies are safe to hold onto,
          *  playing a sound detaches the buffer's own channel arrays.
          *  @return {Array<Array<number>|Float32Array>|undefined} */
-        get sampleChannels(): (number[] | Float32Array)[];
-        rangeValue: number;
+        get sampleChannels(): (number[] | Float32Array)[] | undefined;
+        rangeValue: number | undefined;
         /** Move this sound's samples into an audio buffer that every play can share
          *  Does nothing if there is already a buffer or no samples to build one from */
         buildSampleBuffer(): void;
@@ -3923,7 +4036,7 @@ declare module "littlejsengine" {
      *  @param {number}   [rate] - The playback rate to use
      *  @param {number}   [pan] - How much to apply stereo panning
      *  @param {boolean}  [loop] - True if the sound should loop when it reaches the end
-     *  @param {number}   [sampleRate=44100] - Sample rate for the sound
+     *  @param {number}   [sampleRate=audioDefaultSampleRate] - Sample rate for the sound
      *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing (disconnected when the sound ends)
      *  @param {number}   [offset] - Where to start in the sound, in its own seconds whatever the rate
      *  @param {AudioEndedCallback} [onended] - Callback for when the sound ends
@@ -3949,7 +4062,7 @@ declare module "littlejsengine" {
     export function playAudioBuffer(buffer: AudioBuffer, volume?: number, rate?: number, pan?: number, loop?: boolean, gainNode?: GainNode, offset?: number, onended?: AudioEndedCallback, output?: AudioNode | AudioEffectNodes, pannerNode?: StereoPannerNode): AudioBufferSourceNode | undefined;
     /** Copy arrays of samples into a new audio buffer
      *  @param {Array}  sampleChannels - Array of arrays of samples (for stereo playback)
-     *  @param {number} [sampleRate=44100] - Sample rate for the sound
+     *  @param {number} [sampleRate=audioDefaultSampleRate] - Sample rate for the sound
      *  @return {AudioBuffer} - The audio buffer holding the samples
      *  @memberof Audio */
     export function createAudioBuffer(sampleChannels: any[], sampleRate?: number): AudioBuffer;
@@ -4137,16 +4250,20 @@ declare module "littlejsengine" {
          *  @param {boolean} [immediate] - true removes attached effects like particle emitters at once, false lets them finish first */
         destroy(immediate?: boolean): void;
         /** Convert from local space to world space
-         *  @param {Vector2} pos - local space point */
+         *  @param {Vector2} pos - local space point
+         *  @return {Vector2} */
         localToWorld(pos: Vector2): Vector2;
         /** Convert from world space to local space
-         *  @param {Vector2} pos - world space point */
+         *  @param {Vector2} pos - world space point
+         *  @return {Vector2} */
         worldToLocal(pos: Vector2): Vector2;
         /** Convert from local space to world space for a vector (rotation only)
-         *  @param {Vector2} vec - local space vector */
+         *  @param {Vector2} vec - local space vector
+         *  @return {Vector2} */
         localToWorldVector(vec: Vector2): Vector2;
         /** Convert from world space to local space for a vector (rotation only)
-         *  @param {Vector2} vec - world space vector */
+         *  @param {Vector2} vec - world space vector
+         *  @return {Vector2} */
         worldToLocalVector(vec: Vector2): Vector2;
         /** Called to check if a tile collision should be resolved. Return true for physics to resolve the collision or false to ignore and resolve it manually.
          *  - Called for each solid tile the physics tests, which can be several times a frame for the same tile, and for
@@ -4224,10 +4341,6 @@ declare module "littlejsengine" {
          *  @param {boolean} [collideLevel]        - Does it collide with the level, its tile collision layers?
          *  @param {boolean} [collideRaycast]      - Does it collide with raycasts? */
         setCollision(collideSolidObjects?: boolean, isSolid?: boolean, collideLevel?: boolean, collideRaycast?: boolean): void;
-        set collideTiles(arg: boolean);
-        /** @deprecated since 1.20, use collideLevel
-         *  @type {boolean} */
-        get collideTiles(): boolean;
         /** Returns string containing info about this object for debugging
          *  @return {string} */
         toString(): string;
@@ -4243,9 +4356,30 @@ declare module "littlejsengine" {
      * - TileLayer for rendering, TileCollisionLayer for physics
      * - Collision callbacks for tile interactions with objects
      * - Optimized raycast support for tile-based physics
-     * - Integration with Box2D physics via Box2DTileLayer plugin
+     * - Integration with Box2D physics via the Box2dTileLayer plugin
      * @namespace TileLayers
      */
+    /** A Tiled map as Tiled saves it as JSON, what tileLayersLoad and objectLayersLoad take and tileLayersFromLDtk
+     *  makes; the fields read are listed, and the rest of the file is kept as it is
+     *  @typedef {Object} TiledMap
+     *  @property {number} width - Cells across
+     *  @property {number} height - Cells up
+     *  @property {number} [tilewidth] - A tile's width in pixels
+     *  @property {number} [tileheight] - A tile's height in pixels
+     *  @property {Array<Object>} layers - Tile layers, object layers and groups of them, bottom first
+     *  @property {Array<Object>} [tilesets] - The first one's margin, spacing and columns are read
+     *  @property {number} [nextlayerid]
+     *  @property {number} [nextobjectid]
+     *  @property {string} [orientation]
+     *  @property {string} [renderorder]
+     *  @property {boolean} [infinite]
+     *  @property {string} [type]
+     *  @property {string|number} [version] - A number in files from Tiled before 1.6
+     *  @property {string} [tiledversion]
+     *  @property {number} [compressionlevel]
+     *  @property {string} [backgroundcolor]
+     *  @property {Array<Object>} [properties]
+     *  @memberof TileLayers */
     /** Keep track of all tile layers with collision
      *  @type {Array<TileCollisionLayer>}
      *  @memberof TileLayers */
@@ -4277,7 +4411,7 @@ declare module "littlejsengine" {
      *  @param {Vector2} posEnd
      *  @param {EngineObject|TileCollisionCallback} [callbackObject] - Callback, engine object, or undefined
      *  @param {Vector2} [normal] - Optional normal of the surface hit
-     *  @param {boolean} [solidOnly=true] - Only check solid layers?
+     *  @param {boolean} [solidOnly] - Only check solid layers?
      *  @return {Vector2|undefined} - where the ray meets the first tile hit, nudged just inside it, or undefined if no hit
      *  @memberof TileLayers */
     export function tileCollisionRaycast(posStart: Vector2, posEnd: Vector2, callbackObject?: EngineObject | TileCollisionCallback, normal?: Vector2, solidOnly?: boolean): Vector2 | undefined;
@@ -4295,7 +4429,7 @@ declare module "littlejsengine" {
      * - An object or image layer keeps its index, with its slot in the returned array left empty
      * - A hidden layer (visible false) is loaded, its collision included, but not drawn; its render
      *   is a no-op, delete that and call redraw() to show it
-     *  @param {Object}   tileMapData - Level data from exported data
+     *  @param {TiledMap} [tileMapData] - Level data from exported data, a 50 by 50 empty level when left out
      *  @param {TileInfo} [tileInfo] - Default tile info (used for size and texture), tile() by default, none when no image is loaded
      *  @param {number}   [renderOrder] - Render order of the top layer
      *  @param {number|string} [collisionLayer] - Layer to use for collision if any, by its index or its name
@@ -4303,7 +4437,7 @@ declare module "littlejsengine" {
      *  @return {Array<TileCollisionLayer>} - It throws for a map that is not whole cells, or a layer whose tiles do not
      *    fill it, before it makes any layer
      *  @memberof TileLayers */
-    export function tileLayersLoad(tileMapData: any, tileInfo?: TileInfo, renderOrder?: number, collisionLayer?: number | string, draw?: boolean): Array<TileCollisionLayer>;
+    export function tileLayersLoad(tileMapData?: TiledMap, tileInfo?: TileInfo, renderOrder?: number, collisionLayer?: string | number, draw?: boolean): Array<TileCollisionLayer>;
     /**
      * Make a Tiled map of a level of an LDtk project, to load with tileLayersLoad and objectLayersLoad
      * - Each Tiles, AutoLayer and IntGrid layer is a tile layer, the bottom one first as in Tiled; where LDtk stacks
@@ -4324,13 +4458,13 @@ declare module "littlejsengine" {
      * - The level editor edits the map this returns, and saves it as a Tiled map
      * @param {Object} ldtk - The LDtk project, its JSON
      * @param {number|string} [level] - Which level, by its index or its identifier
-     * @return {Object} - A Tiled map: width, height, tilewidth, tileheight, tilesets and layers
+     * @return {TiledMap} - A Tiled map: width, height, tilewidth, tileheight, tilesets and layers
      * @example
      * const map = tileLayersFromLDtk(await fetchJSON('world.ldtk'), 'Level_0');
      * const layers = tileLayersLoad(map, tile(0, 16), 0, 'Collisions'); // its IntGrid layer is solid
      * objectLayersLoad(map);
      * @memberof TileLayers */
-    export function tileLayersFromLDtk(ldtk: any, level?: number | string): any;
+    export function tileLayersFromLDtk(ldtk: any, level?: string | number): TiledMap;
     /** Add a type of object, so objectLayersLoad makes one wherever a map's object layer has an object of that type
      *  - The name is the object's type in Tiled (its class in Tiled 1.9); it is a string because minified builds
      *    rename classes
@@ -4340,13 +4474,15 @@ declare module "littlejsengine" {
      *  - Adding a name again replaces it
      *  @param {string} name - The type the objects have in Tiled
      *  @param {Function} make - A class made at each object's position, or a function called with it
-     *  @param {Object} [defaults] - Properties set on each one made, the level editor shows inputs for them
+     *  @param {Object<string, any>} [defaults] - Properties set on each one made, the level editor shows inputs for them
      *  @param {TileInfo} [tileInfo] - An icon for the level editor
      *  @memberof TileLayers
      *  @example
      *  objectLayersAddType('Coin', Coin, {value: 1}, tile(5, 16));
      *  objectLayersAddType('PlayerStart', (pos)=> playerStartPos = pos); */
-    export function objectLayersAddType(name: string, make: Function, defaults?: any, tileInfo?: TileInfo): void;
+    export function objectLayersAddType(name: string, make: Function, defaults?: {
+        [x: string]: any;
+    }, tileInfo?: TileInfo): void;
     /** Make the objects in a map's object layers, each from the type added for its name with objectLayersAddType
      *  - An object is made at its position, the world y up as tileLayersLoad places the layers; layer offsets are
      *    not read, and a shape or tile object is made at its position too
@@ -4354,10 +4490,10 @@ declare module "littlejsengine" {
      *  - The object's properties in Tiled are set over the type's defaults: numbers, booleans, strings, and colors,
      *    and for a Vector2 default the string x,y
      *  - An object whose type was not added is skipped, with a warning in debug builds
-     *  @param {Object} tileMapData - The same Tiled map given to tileLayersLoad
+     *  @param {TiledMap} tileMapData - The same Tiled map given to tileLayersLoad
      *  @return {Array<any>} - What each object's type made, a function that made nothing is left out
      *  @memberof TileLayers */
-    export function objectLayersLoad(tileMapData: any): Array<any>;
+    export function objectLayersLoad(tileMapData: TiledMap): Array<any>;
     /**
      * Tile layer data object stores info about how to draw a tile
      * @memberof TileLayers
@@ -4373,7 +4509,7 @@ declare module "littlejsengine" {
         /** Create a tile layer data object, one for each tile in a TileLayer
          *  @param {number}  [tile] - The tile to use, from 0 like tile(); undefined is an empty cell that draws nothing
          *  @param {number}  [direction] - Integer direction of tile, in 90 degree increments
-         *  @param {boolean} [mirror] - If the tile should be mirrored along the x axis
+         *  @param {boolean} [mirror] - If the tile is flipped left to right
          *  @param {Color}   [color] - Color of the tile */
         constructor(tile?: number, direction?: number, mirror?: boolean, color?: Color);
         /** @property {number|undefined} - The tile to use, from 0 like tile(); undefined is an empty cell that draws nothing
@@ -4381,7 +4517,7 @@ declare module "littlejsengine" {
         tile: number | undefined;
         /** @property {number} - Integer direction of tile, in 90 degree increments */
         direction: number;
-        /** @property {boolean} - If the tile should be mirrored along the x axis */
+        /** @property {boolean} - If the tile is flipped left to right */
         mirror: boolean;
         /** @property {Color} - Color of the tile */
         color: Color;
@@ -4411,9 +4547,9 @@ declare module "littlejsengine" {
         */
         constructor(pos?: Vector2, size?: Vector2, angle?: number, renderOrder?: number, canvasSize?: Vector2, useWebGL?: boolean);
         /** @property {OffscreenCanvasRenderingContext2D} - The 2D canvas context used by this layer */
-        context: OffscreenCanvasRenderingContext2D;
+        context: OffscreenCanvasRenderingContext2D | undefined;
         /** @property {OffscreenCanvas} - The canvas used by this layer */
-        canvas: OffscreenCanvas;
+        canvas: OffscreenCanvas | undefined;
         /** @property {TextureInfo} - Texture info to use for this object rendering */
         textureInfo: TextureInfo;
         /** Draw this canvas layer centered in world space
@@ -4421,7 +4557,7 @@ declare module "littlejsengine" {
         *  @param {Vector2} [size] - Size in world space
         *  @param {Color}   [color] - Color to modulate with
         *  @param {number}  [angle] - Angle to rotate by
-        *  @param {boolean} [mirror] - If true image is flipped along the Y axis
+        *  @param {boolean} [mirror] - If true the image is flipped left to right
         *  @param {Color}   [additiveColor] - Additive color to be applied if any
         *  @param {boolean} [screenSpace=drawScreenSpace] - If true the pos and size are in screen space
         *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas 2D context to draw to */
@@ -4456,7 +4592,7 @@ declare module "littlejsengine" {
         data: TileLayerData[];
         /** @property {boolean} - Is this layer using a webgl texture? */
         isUsingWebGL: boolean;
-        tilesInWebGL: boolean;
+        tilesInWebGL: boolean | undefined;
         /** @property {boolean} - Show this layer's bounds and values when the debug overlay's Debug Tiles is on,
          *  turn it off for layers that only add noise */
         debugShow: boolean;
@@ -4489,7 +4625,7 @@ declare module "littlejsengine" {
          *  @param {TileInfo} [tileInfo] - Tile info to use, untextured if undefined
          *  @param {Color}    [color=WHITE] - Color to modulate with
          *  @param {number}   [angle] - Angle to rotate by
-         *  @param {boolean}  [mirror] - Is image flipped along the Y axis?
+         *  @param {boolean}  [mirror] - Is the image flipped left to right?
          *  @param {Color}    [additiveColor] - Additive color to be applied if any */
         drawLayerTile(pos: Vector2, size?: Vector2, tileInfo?: TileInfo, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color): void;
         /** Draw a rectangle in layer space
@@ -4535,8 +4671,8 @@ declare module "littlejsengine" {
         onRedraw(): void;
         redrawIfSwitched(): void;
         /** @type {[CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, number, Color, Shader|undefined]} */
-        savedRenderSettings: [CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, number, Color, Shader | undefined];
-        savedRenderTarget: any[];
+        savedRenderSettings: [CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, number, Color, Shader | undefined] | undefined;
+        savedRenderTarget: any[] | undefined;
     }
     /**
      * Tile Collision Layer - a tile layer with collision
@@ -4616,13 +4752,13 @@ declare module "littlejsengine" {
      * let pos = vec2(2,3);
      * let particleEmitter = new ParticleEmitter
      * (
-     *     pos, 0, 1, 0, 500, PI,      // pos, angle, emitSize, emitTime, emitRate, emitCone
+     *     pos, 0, 1, 0, 500, PI,      // pos, angle, emitSize, emitTime, emitRate, emitConeAngle
      *     tile(0, 16),                // tileInfo
      *     rgb(1,1,1,1), rgb(0,0,0,1), // colorStartA, colorStartB
      *     rgb(1,1,1,0), rgb(0,0,0,0), // colorEndA, colorEndB
-     *     1, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
-     *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleCone, fadeRate
-     *     .5, true             // randomness, collide
+     *     1, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, speed, angleSpeed
+     *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleConeAngle, fadeRate
+     *     .5, true             // randomness, collideLevel
      * );
      */
     export class ParticleEmitter extends EngineObject {
@@ -4730,7 +4866,8 @@ declare module "littlejsengine" {
         /** Spawn one particle
          *  @return {Particle} */
         emitParticle(): Particle;
-        /** is emitter actively spawning */
+        /** is emitter actively spawning
+         *  @return {boolean} */
         isActive(): boolean;
     }
     /**
@@ -4980,8 +5117,6 @@ declare module "littlejsengine" {
         session_id: string | null;
         /** @property {Promise<NewgroundsPlugin>} - Resolves once the session is checked and the lists are in, empty if the server could not be reached */
         ready: Promise<this>;
-        /** @deprecated since 1.20, the view is logged when the plugin starts, so this does nothing */
-        logView(): void;
         /** Log the view, check the session, fetch the medals and scoreboards, then keep the session alive; the constructor runs it once
          *  @private */
         private init;
@@ -5077,6 +5212,18 @@ declare module "littlejsengine" {
         constructor(shaderCode?: string, includeMainCanvas?: boolean, feedbackTexture?: boolean);
         /** @property {string} - The shadertoy style mainImage code it shades with, see setShaderCode */
         shaderCode: string;
+        /** @property {Object<string, number|Array<number>>} - The game's own values for the shader, a uniform each
+         *  by its name, a number a float and a list of 2 to 4 numbers a vector, set every frame as they are; an
+         *  effect setting can be one of these names, so it changes every frame without making the shader again, all
+         *  but glow's size, which sets how many samples it takes; adding or removing a name makes the shader again,
+         *  and the shader is first made at the first render, so values set right after the plugin are in it; a name
+         *  is a GLSL name not starting with an underscore, which the effects keep for their own, nor i and a capital
+         *  or gl_, and not c, uv or p, the names mainImage works on
+         *  @type {Object<string, number|Array<number>>} */
+        values: {
+            [x: string]: number | Array<number>;
+        };
+        valueNames: string;
         /** @property {WebGLProgram|undefined} - Shader for post processing
          *  @type {WebGLProgram|undefined} */
         shader: WebGLProgram | undefined;
@@ -5096,8 +5243,8 @@ declare module "littlejsengine" {
     }
     /**
      * Set up post processing with a bloom effect, so bright colors and lights glow
-     * @param {number} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
-     * @param {number} [strength] - How much glow to add
+     * @param {number|string} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
+     * @param {number|string} [strength] - How much glow to add
      * @param {number} [size] - How far the glow spreads in pixels
      * @param {boolean} [includeMainCanvas] - Glow the 2D canvas too, off by default so HUD text stays crisp
      *   (a HUD drawn with WebGL in gameRenderPost glows either way, draw it with useWebGL=false)
@@ -5106,17 +5253,18 @@ declare module "littlejsengine" {
      * @example
      * postProcessBloom(); // in gameInit, after any Render3DPlugin
      */
-    export function postProcessBloom(threshold?: number, strength?: number, size?: number, includeMainCanvas?: boolean): PostProcessPlugin;
+    export function postProcessBloom(threshold?: string | number, strength?: string | number, size?: number, includeMainCanvas?: boolean): PostProcessPlugin;
     /**
      * Shader code for a bloom effect, the bright parts of the image blurred back over it
      * - Pass it to PostProcessPlugin, or edit the string to build an effect on top of it
-     * @param {number} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
-     * @param {number} [strength] - How much glow to add
-     * @param {number} [size] - How far the glow spreads in pixels, which also sets how many samples it takes
+     * @param {number|string} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
+     * @param {number|string} [strength] - How much glow to add
+     * @param {number} [size] - How far the glow spreads in pixels, which also sets how many samples it takes, so a
+     *   number and not a value's name
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessBloomShader(threshold?: number, strength?: number, size?: number): string;
+    export function postProcessBloomShader(threshold?: string | number, strength?: string | number, size?: number): string;
     /**
      * Join effects into one post process shader, in the order given, for PostProcessPlugin or setShaderCode
      * - Each effect is a piece of shader code on c, the pixel's color, and uv, where it is on the screen from 0 to 1;
@@ -5132,82 +5280,109 @@ declare module "littlejsengine" {
     export function postProcessEffects(...effects: string[]): string;
     /**
      * Bright parts glow, the bloom as an effect to join with others; postProcessBloom sets up bloom on its own
-     * @param {number} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
-     * @param {number} [strength] - How much glow to add
-     * @param {number} [size] - How far the glow spreads in pixels, which also sets how many samples it takes
+     * @param {number|string} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
+     * @param {number|string} [strength] - How much glow to add
+     * @param {number} [size] - How far the glow spreads in pixels, which also sets how many samples it takes, so a
+     *   number and not a value's name
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessGlow(threshold?: number, strength?: number, size?: number): string;
+    export function postProcessGlow(threshold?: string | number, strength?: string | number, size?: number): string;
     /**
      * Scan lines across the screen, like an old TV
-     * @param {number} [strength] - How dark the lines are, and how bright between them
-     * @param {number} [spacing] - Pixels from one line to the next
+     * @param {number|string} [strength] - How dark the lines are, and how bright between them
+     * @param {number|string} [spacing] - Pixels from one line to the next
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessScanlines(strength?: number, spacing?: number): string;
+    export function postProcessScanlines(strength?: string | number, spacing?: string | number): string;
     /**
      * Static noise over the picture, changing every frame
-     * @param {number} [strength] - How bright the static is
-     * @param {number} [size] - Size of a speck in pixels
+     * @param {number|string} [strength] - How bright the static is
+     * @param {number|string} [size] - Size of a speck in pixels
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessNoise(strength?: number, size?: number): string;
+    export function postProcessNoise(strength?: string | number, size?: string | number): string;
     /**
      * Darken toward the edges and corners
-     * @param {number} [strength] - How dark the corners get, 1 is black
-     * @param {number} [falloff] - How far in it reaches, low darkens most of the screen, high only the corners
+     * @param {number|string} [strength] - How dark the corners get, 1 is black
+     * @param {number|string} [falloff] - How far in it reaches, low darkens most of the screen, high only the corners
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessVignette(strength?: number, falloff?: number): string;
+    export function postProcessVignette(strength?: string | number, falloff?: string | number): string;
     /**
      * Bend the picture like the bulged glass of an old TV, black past the corners; put it first
-     * @param {number} [strength] - How much it bends
+     * @param {number|string} [strength] - How much it bends
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessCurve(strength?: number): string;
+    export function postProcessCurve(strength?: string | number): string;
     /**
      * Split red and blue apart toward the edges, like a cheap lens; put it before what shades the picture
-     * @param {number} [strength] - How far apart at the edge, as a part of the screen
+     * @param {number|string} [strength] - How far apart at the edge, as a part of the screen
      * @return {string}
      * @memberof PostProcess
      */
-    export function postProcessChromatic(strength?: number): string;
+    export function postProcessChromatic(strength?: string | number): string;
     /**
      * Draw lines where the 3D depth jumps, around objects and along their creases; needs render3D.depthTexture on
      * @param {Color} [color] - The lines' color, its alpha how strong they are
-     * @param {number} [thickness] - How wide the lines are in pixels
-     * @param {number} [threshold] - How big a jump makes a line, as a part of the distance, lower draws more
+     * @param {number|string} [thickness] - How wide the lines are in pixels
+     * @param {number|string} [threshold] - How big a jump makes a line, as a part of the distance, lower draws more
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessOutline(color?: Color, thickness?: string | number, threshold?: string | number): string;
+    /**
+     * Keep a band across the screen sharp and blur the picture above and below it, as a tilt shift lens does, which
+     * makes a scene look like a small model; it reads only the screen, so it works in 2D and 3D; put it first
+     * @param {number|string} [focus] - Height of the middle of the sharp band, 0 the bottom of the screen and 1 the top
+     * @param {number|string} [size] - Height of the sharp band, as a part of the screen
+     * @param {number|string} [blur] - Widest blur in pixels, reached half the screen past the band, at most 32
+     * @return {string}
+     * @memberof PostProcess
+     * @example
+     * new PostProcessPlugin(postProcessEffects(postProcessTiltShift(.4, .2, 10), postProcessVignette(.5)));
+     */
+    export function postProcessTiltShift(focus?: string | number, size?: string | number, blur?: string | number): string;
+    /**
+     * Keep what is a distance from the camera sharp and blur what is nearer or farther, as a camera lens does; needs
+     * render3D.depthTexture on, and blurs 3D only, 2D draws having no depth; put it first
+     * - What is in focus stays sharp at its edges: a blur in front of or behind it leaves out what is in focus
+     * @param {number|string} [focus] - Distance from the camera, along its view, that is sharpest, in world units
+     * @param {number|string} [range] - How deep the sharp part is; the blur grows over as far again past it
+     * @param {number|string} [blur] - Widest blur in pixels, at most 32
      * @return {string}
      * @memberof PostProcess
+     * @example
+     * render3D.depthTexture = true;
+     * new PostProcessPlugin(postProcessEffects(postProcessDepthOfField(10, 4, 8)));
      */
-    export function postProcessOutline(color?: Color, thickness?: number, threshold?: number): string;
+    export function postProcessDepthOfField(focus?: string | number, range?: string | number, blur?: string | number): string;
     /**
      * The look of an old TV, as one effect to use alone or join with others: static noise, scan lines, a soft glow and
      * a vignette, and a bulged screen when curve is set; any setting at 0 leaves that part out
      * @param {Object} [settings]
-     * @param {number} [settings.noise] - Static noise strength
-     * @param {number} [settings.scanlines] - Scan line strength
-     * @param {number} [settings.scanlineSpacing] - Pixels from one scan line to the next
-     * @param {number} [settings.glow] - Soft glow strength
-     * @param {number} [settings.vignette] - Vignette strength
-     * @param {number} [settings.curve] - How much the screen bulges, 0 by default for flat
+     * @param {number|string} [settings.noise] - Static noise strength
+     * @param {number|string} [settings.scanlines] - Scan line strength
+     * @param {number|string} [settings.scanlineSpacing] - Pixels from one scan line to the next
+     * @param {number|string} [settings.glow] - Soft glow strength
+     * @param {number|string} [settings.vignette] - Vignette strength
+     * @param {number|string} [settings.curve] - How much the screen bulges, 0 by default for flat
      * @return {string}
      * @example
      * new PostProcessPlugin(postProcessEffects(postProcessTV({scanlines: .4, curve: .1})));
      * @memberof PostProcess
      */
     export function postProcessTV({ noise, scanlines, scanlineSpacing, glow, vignette, curve }?: {
-        noise?: number;
-        scanlines?: number;
-        scanlineSpacing?: number;
-        glow?: number;
-        vignette?: number;
-        curve?: number;
+        noise?: string | number;
+        scanlines?: string | number;
+        scanlineSpacing?: string | number;
+        glow?: string | number;
+        vignette?: string | number;
+        curve?: string | number;
     }): string;
     /**
      * LittleJS Light System Plugin
@@ -5263,7 +5438,7 @@ declare module "littlejsengine" {
         /** @property {Color} - Baseline color applied to unlit areas of the scene. Defaults to BLACK (pitch dark). Set to a small RGB for a faint ambient. The lightmap is cleared to this color each frame, then lights add on top, then the result multiplies the scene. */
         ambientColor: Color;
         /** @property {Vector2} - Size of the lightmap texture, follows mainCanvasSize (css pixels, so it is not scaled by canvasPixelRatio) unless a size was passed */
-        textureSize: Vector2;
+        textureSize: Vector2 | undefined;
         /** @property {boolean} - True when no size was passed, so the lightmap follows mainCanvasSize */
         textureSizeAuto: boolean;
         /** @property {WebGLTexture|undefined} - The lightmap texture
@@ -5416,14 +5591,14 @@ declare module "littlejsengine" {
         /** @property {number} - Wet/dry balance, 0 is fully dry and 1 is fully wet */
         mix: number;
         /** @property {GainNode} - Connect sounds to this node */
-        input: GainNode;
+        input: GainNode | undefined;
         /** @property {GainNode} - This node carries the mixed result, send it somewhere with connect(), never by assigning here
          *  - Unlike sound.output, which is where a sound's audio goes and can be set to an effect */
-        output: GainNode;
+        output: GainNode | undefined;
         /** @property {GainNode} - Level of the unprocessed signal */
-        dryGain: GainNode;
+        dryGain: GainNode | undefined;
         /** @property {GainNode} - Level of the processed signal */
-        wetGain: GainNode;
+        wetGain: GainNode | undefined;
         /** Set the wet/dry balance
          *  @param {number} mix - 0 is fully dry and 1 is fully wet
          *  @param {number} [fadeTime] - Seconds to ramp over so the change doesn't click */
@@ -5466,7 +5641,7 @@ declare module "littlejsengine" {
          *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
         constructor(type?: BiquadFilterType, frequency?: number, q?: number, mix?: number);
         /** @property {BiquadFilterNode} - The filter node */
-        node: BiquadFilterNode;
+        node: BiquadFilterNode | undefined;
         /** Set the cutoff or center frequency
          *  @param {number} frequency - Frequency in Hz
          *  @param {number} [fadeTime] - Seconds to sweep over */
@@ -5492,7 +5667,7 @@ declare module "littlejsengine" {
          *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
         constructor(duration?: number, decay?: number, mix?: number);
         /** @property {ConvolverNode} - The convolver node */
-        node: ConvolverNode;
+        node: ConvolverNode | undefined;
         /** Change the room by rebuilding the impulse response
          *  @param {number} duration - Seconds until the reverb tail is silent
          *  @param {number} [decay] - How quickly the tail fades, higher is faster */
@@ -5518,9 +5693,9 @@ declare module "littlejsengine" {
          *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
         constructor(time?: number, feedback?: number, mix?: number);
         /** @property {DelayNode} - The delay node */
-        node: DelayNode;
+        node: DelayNode | undefined;
         /** @property {GainNode} - How much of the delayed signal feeds back in */
-        feedbackGain: GainNode;
+        feedbackGain: GainNode | undefined;
         /** Set the time between echoes
          *  - Browsers hold a delay in a feedback loop to at least one render quantum, so 0 is not a bypass
          *  @param {number} time - Seconds, up to 5
@@ -5547,7 +5722,7 @@ declare module "littlejsengine" {
         /** @property {number} - How hard the signal is driven, 0 is clean and 1 is crushed */
         amount: number;
         /** @property {WaveShaperNode} - The wave shaper node */
-        node: WaveShaperNode;
+        node: WaveShaperNode | undefined;
         /** Set how hard to drive the signal, rebuilds the shaping curve
          *  @param {number} amount - 0 is clean and 1 is crushed */
         setAmount(amount: number): void;
@@ -5568,7 +5743,7 @@ declare module "littlejsengine" {
          *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
         constructor(threshold?: number, ratio?: number, mix?: number);
         /** @property {DynamicsCompressorNode} - The compressor node */
-        node: DynamicsCompressorNode;
+        node: DynamicsCompressorNode | undefined;
         /** Set the level above which the signal is reduced
          *  @param {number} threshold - Level in dB
          *  @param {number} [fadeTime] - Seconds to ramp over */
@@ -5606,6 +5781,11 @@ declare module "littlejsengine" {
      *  @param {number|boolean} debugMode
      *  @memberof UISystem */
     export function uiSetDebug(debugMode: number | boolean): void;
+    /**
+     * @callback DragAndDropCallback - Callback for drag and drop events
+     * @param {DragEvent} event - The drag event
+     * @memberof UISystem
+     */
     /**
      * UI System Global Object
      * @memberof UISystem
@@ -5748,35 +5928,30 @@ declare module "littlejsengine" {
         *  @param {'left'|'center'|'right'} [align]
         *  @param {string}  [font=uiSystem.defaultFont]
         *  @param {string}  [fontStyle]
-        *  @param {boolean} [applyMaxWidth=true]
+        *  @param {boolean} [applyMaxWidth]
         *  @param {Vector2} [textShadow]
         *  @param {Color}   [shadowColor]
         *  @param {number}  [shadowBlur]
         *  @param {Vector2} [shadowOffset] */
-        drawText(text: string, pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, align?: 'left' | 'center' | 'right', font?: string, fontStyle?: string, applyMaxWidth?: boolean, textShadow?: Vector2, shadowColor?: Color, shadowBlur?: number, shadowOffset?: Vector2): void;
-        /**
-         * @callback DragAndDropCallback - Callback for drag and drop events
-         * @param {DragEvent} event - The drag event
-         * @memberof UISystem
-         */
+        drawText(text: string, pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, align?: "center" | "left" | "right", font?: string, fontStyle?: string, applyMaxWidth?: boolean, textShadow?: Vector2, shadowColor?: Color, shadowBlur?: number, shadowOffset?: Vector2): void;
         /** Setup drag and drop event handlers
         *  Automatically prevents defaults and calls the given functions
         *  @param {DragAndDropCallback} [onDrop] - when a file is dropped
         *  @param {DragAndDropCallback} [onDragEnter] - when a file is dragged onto the window
         *  @param {DragAndDropCallback} [onDragLeave] - when a file is dragged off the window
         *  @param {DragAndDropCallback} [onDragOver] - continuously when dragging over */
-        setupDragAndDrop(onDrop?: (event: DragEvent) => any, onDragEnter?: (event: DragEvent) => any, onDragLeave?: (event: DragEvent) => any, onDragOver?: (event: DragEvent) => any): void;
+        setupDragAndDrop(onDrop?: DragAndDropCallback, onDragEnter?: DragAndDropCallback, onDragLeave?: DragAndDropCallback, onDragOver?: DragAndDropCallback): void;
         /** Convert a screen space position to native UI position
          *  @param {Vector2} pos
          *  @return {Vector2} */
         screenToNative(pos: Vector2): Vector2;
-        set keyInputObject(arg: UIObject);
+        set keyInputObject(arg: UIObject | undefined);
         /** Object to send keyboard input to (typically a UITextInput), which keeps the keys from the game while set.
          *  The keyboard listeners are only attached while this is set,
          *  so games that never use text input pay no event-handling cost.
          *  To end typing in a field, call its stopEditing(), which also fires its onChange and release sound
          *  @type {UIObject|undefined} */
-        get keyInputObject(): UIObject;
+        get keyInputObject(): UIObject | undefined;
         /** Destroy and remove all objects */
         destroyObjects(): void;
         /** Get all navigable UI objects sorted by navigationIndex
@@ -5951,15 +6126,20 @@ declare module "littlejsengine" {
         getTextPos(textSize: Vector2): Vector2;
         /** Called when the navigation button is pressed on this object */
         navigatePressed(): void;
-        /** @return {boolean} - Is the mouse hovering over this element */
+        /** Is the mouse hovering over this element
+         *  @return {boolean} */
         isHoverObject(): boolean;
-        /** @return {boolean} - Is the mouse held onto this element */
+        /** Is the mouse held onto this element
+         *  @return {boolean} */
         isActiveObject(): boolean;
-        /** @return {boolean} - Is the gamepad or keyboard navigation object */
+        /** Is the gamepad or keyboard navigation object
+         *  @return {boolean} */
         isNavigationObject(): boolean;
-        /** @return {boolean} - Is this object in keyboard input mode */
+        /** Is this object in keyboard input mode
+         *  @return {boolean} */
         isKeyInputObject(): boolean;
-        /** @return {boolean} - Can it be interacted with, it and every parent visible and enabled */
+        /** Can it be interacted with, it and every parent visible and enabled
+         *  @return {boolean} */
         isInteractive(): boolean;
         /** Returns string containing info about this object for debugging
          *  @return {string} */
@@ -6004,7 +6184,8 @@ declare module "littlejsengine" {
          *  @param {'left'|'center'|'right'} [align]
          *  @param {string}  [font=uiSystem.defaultFont]
          */
-        constructor(pos?: Vector2, size?: Vector2, text?: string, align?: 'left' | 'center' | 'right', font?: string);
+        constructor(pos?: Vector2, size?: Vector2, text?: string, align?: "center" | "left" | "right", font?: string);
+        text: string;
     }
     /**
      * UITextInput - An editable text input field
@@ -6024,6 +6205,7 @@ declare module "littlejsengine" {
         constructor(pos?: Vector2, size?: Vector2, text?: string);
         /** @property {number} - Max length of input (0 = no limit) */
         maxLength: number;
+        text: string;
         /** Stop editing the text */
         stopEditing(): void;
     }
@@ -6064,6 +6246,7 @@ declare module "littlejsengine" {
         constructor(pos?: Vector2, size?: Vector2, text?: string, color?: Color);
         /** @property {Vector2} - Text offset for the button */
         textOffset: Vector2;
+        text: string;
     }
     /**
      * UICheckbox - A UI object that acts as a checkbox
@@ -6081,6 +6264,7 @@ declare module "littlejsengine" {
         constructor(pos?: Vector2, size?: Vector2, checked?: boolean, text?: string, color?: Color);
         /** @property {boolean} - Is the checkbox currently checked? */
         checked: boolean;
+        text: string;
     }
     /**
      * UISlider - A UI object that acts as a slider or scrollbar
@@ -6107,6 +6291,7 @@ declare module "littlejsengine" {
         handleSlice: TileSlice | undefined;
         /** @property {boolean} - Should it fill up like a progress bar? */
         fillMode: boolean;
+        text: string;
         /** Draw the handle, or the fill of a fill mode slider, with the handle slice, the slider's own, or a rectangle
          *  @param {Vector2} pos
          *  @param {Vector2} size
@@ -6127,9 +6312,9 @@ declare module "littlejsengine" {
          *  @param {Vector2} pos
          *  @param {Vector2} size
          *  @param {string} src - Video file path or URL
-         *  @param {boolean} [autoplay=false] - Start playing immediately?
-         *  @param {boolean} [loop=false] - Loop the video?
-         *  @param {number} [volume=1] - Volume percent scaled by global volume (0-1)
+         *  @param {boolean} [autoplay] - Start playing immediately?
+         *  @param {boolean} [loop] - Loop the video?
+         *  @param {number} [volume] - Volume percent scaled by global volume (0-1)
          */
         constructor(pos: Vector2, size: Vector2, src: string, autoplay?: boolean, loop?: boolean, volume?: number);
         /** @property {number} - The video volume */
@@ -6191,10 +6376,10 @@ declare module "littlejsengine" {
     export class UILayout extends UIObject {
         /** Create a UILayout container that auto-arranges children
          *  @param {Vector2} [pos]
-         *  @param {number}  [columns=1]     - Number of columns (1 = vertical list)
-         *  @param {number}  [gap=10]        - Space between children
-         *  @param {number}  [padding=10]    - Space between container border and children
-         *  @param {boolean} [transparent=false] - If true, draws no background, outline, or shadow
+         *  @param {number}  [columns]     - Number of columns (1 = vertical list)
+         *  @param {number}  [gap]        - Space between children
+         *  @param {number}  [padding]    - Space between container border and children
+         *  @param {boolean} [transparent] - If true, draws no background, outline, or shadow
          */
         constructor(pos?: Vector2, columns?: number, gap?: number, padding?: number, transparent?: boolean);
         /** @property {number} - Number of columns in the layout */
@@ -6290,13 +6475,15 @@ declare module "littlejsengine" {
          *  @param {boolean} [includeSensors] - Also hit sensors, trigger zones are passed through by default
          *  @return {Box2dRaycastResult|undefined} */
         raycast(start: Vector2, end: Vector2, includeSensors?: boolean): Box2dRaycastResult | undefined;
-        /** box aabb cast and return all the objects
+        /** Every object whose shapes' bounding boxes overlap a box, not the shapes themselves, so near the corner of a
+         *  turned box or a circle it finds one the box does not touch; use pointCast or a raycast for exact
          *  @param {Vector2} pos
          *  @param {Vector2} size
          *  @param {boolean} [includeSensors] - Also find sensors, trigger zones are passed through by default
          *  @return {Array<Box2dObject>} */
         boxCastAll(pos: Vector2, size: Vector2, includeSensors?: boolean): Array<Box2dObject>;
-        /** box aabb cast and return the first object
+        /** The first object whose shapes' bounding boxes overlap a box, not the shapes themselves, so near the corner of
+         *  a turned box or a circle it finds one the box does not touch; use pointCast or a raycast for exact
          *  @param {Vector2} pos
          *  @param {Vector2} size
          *  @param {boolean} [includeSensors] - Also find sensors, trigger zones are passed through by default
@@ -6331,23 +6518,29 @@ declare module "littlejsengine" {
          *  @param {CanvasRenderingContext2D} [context] */
         drawFixture(fixture: any, pos: Vector2, angle: number, color?: Color, lineColor?: Color, lineWidth?: number, useWebGL?: boolean, context?: CanvasRenderingContext2D): void;
         /** converts a box2d vec2 to a Vector2
-         *  @param {Object} v */
+         *  @param {Object} v
+         *  @return {Vector2} */
         vec2From(v: any): Vector2;
         /** converts a box2d vec2 pointer to a Vector2
-         *  @param {Object} vp */
+         *  @param {Object} vp
+         *  @return {Vector2} */
         vec2FromPointer(vp: any): Vector2;
         /** converts a Vector2 to a new box2d vec2, which stays until destroyed with box2d.instance.destroy;
          *  the plugin itself passes Box2D reused ones, since Box2D copies every vector it is given
-         *  @param {Vector2} v */
+         *  @param {Vector2} v
+         *  @return {Object} - A Box2D vector, its b2Vec2 */
         vec2dTo(v: Vector2): any;
         /** checks if a box2d object is null
-         *  @param {Object} o */
+         *  @param {Object} o
+         *  @return {boolean} */
         isNull(o: any): boolean;
         /** casts a box2d object to a shape type
-         *  @param {Object} o */
+         *  @param {Object} o
+         *  @return {Object} - The shape as its own Box2D type */
         castShapeObject(o: any): any;
         /** casts a box2d object to a joint type
-         *  @param {Object} o */
+         *  @param {Object} o
+         *  @return {Object} - The joint as its own Box2D type */
         castJointObject(o: any): any;
     }
     /**
@@ -6408,7 +6601,8 @@ declare module "littlejsengine" {
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
+         *  @param {boolean} [isSensor]
+         *  @return {Object} - The fixture made, Box2D's own */
         addShape(shape: any, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
         /** Add a box shape to the body
          *  @param {Vector2} [size]
@@ -6419,38 +6613,43 @@ declare module "littlejsengine" {
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
-        addBox(size?: Vector2, offset?: Vector2, angle?: number, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
+         *  @param {boolean} [isSensor]
+         *  @return {Object|undefined} - The fixture made, Box2D's own, undefined for a shape too small to make */
+        addBox(size?: Vector2, offset?: Vector2, angle?: number, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any | undefined;
         /** Add a polygon shape to the body, the convex hull of its points; Box2D takes 3 to 8 points,
          *  not all in a line, and no fixture is made from any other; points closer than .001 count as one
          *  @param {Array<Vector2>} points
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
-        addPoly(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
+         *  @param {boolean} [isSensor]
+         *  @return {Object|undefined} - The fixture made, Box2D's own, undefined for a shape too small to make */
+        addPoly(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any | undefined;
         /** Add a regular polygon shape to the body
          *  @param {number}  [diameter]
          *  @param {number}  [sides] - 3 to 8, the most Box2D polygons have
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
-        addRegularPoly(diameter?: number, sides?: number, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
+         *  @param {boolean} [isSensor]
+         *  @return {Object|undefined} - The fixture made, Box2D's own, undefined for a shape too small to make */
+        addRegularPoly(diameter?: number, sides?: number, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any | undefined;
         /** Add a random polygon shape to the body
          *  @param {number}  [diameter]
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
-        addRandomPoly(diameter?: number, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
+         *  @param {boolean} [isSensor]
+         *  @return {Object|undefined} - The fixture made, Box2D's own, undefined for a shape too small to make */
+        addRandomPoly(diameter?: number, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any | undefined;
         /** Add a circle shape to the body
          *  @param {number}  [diameter]
          *  @param {Vector2} [offset]
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
+         *  @param {boolean} [isSensor]
+         *  @return {Object} - The fixture made, Box2D's own */
         addCircle(diameter?: number, offset?: Vector2, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
         /** Add an edge shape to the body
          *  @param {Vector2} point1
@@ -6458,22 +6657,25 @@ declare module "littlejsengine" {
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
+         *  @param {boolean} [isSensor]
+         *  @return {Object} - The fixture made, Box2D's own */
         addEdge(point1: Vector2, point2: Vector2, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
         /** Add an edge list to the body
          *  @param {Array<Vector2>} points
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
-        addEdgeList(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any[];
+         *  @param {boolean} [isSensor]
+         *  @return {Array<Object>} - The fixtures made, Box2D's own */
+        addEdgeList(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): Array<any>;
         /** Add an edge loop to the body, an edge loop connects the end points
          *  @param {Array<Vector2>} points
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
-         *  @param {boolean} [isSensor] */
-        addEdgeLoop(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any[];
+         *  @param {boolean} [isSensor]
+         *  @return {Array<Object>} - The fixtures made, Box2D's own */
+        addEdgeLoop(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): Array<any>;
         /** Destroy a fixture from the body, from a contact callback once the step is done
          *  @param {Object} fixture */
         destroyFixture(fixture: any): void;
@@ -6800,6 +7002,8 @@ declare module "littlejsengine" {
      * Box2D Pin Joint
      * - Pins two objects together at a point, where they still turn freely, like a nail through two boards
      * - A revolute joint at that point, so it holds exactly and its limits and motor work too
+     * - new Box2dPinJoint(objectA, objectB, pos, collide): the point defaults to objectA's position, where a revolute
+     *   joint's anchor defaults to objectB's
      * @extends Box2dRevoluteJoint
      * @memberof Box2D
      */
@@ -7115,12 +7319,6 @@ declare module "littlejsengine" {
         /** Get the damping ratio
          *  @return {number} */
         getDampingRatio(): number;
-        /** @deprecated since 1.20, use setDampingRatio
-         *  @param {number} ratio */
-        setSpringDampingRatio(ratio: number): void;
-        /** @deprecated since 1.20, use getDampingRatio
-         *  @return {number} */
-        getSpringDampingRatio(): number;
     }
     /**
      * Box2D Friction Joint
@@ -7273,7 +7471,7 @@ declare module "littlejsengine" {
      *  @param {Vector2} pos - Screen space position
      *  @param {Vector2} size - Screen space size
      *  @param {TileInfo} startTile - Top-left tile of the 3x3 block to sample (see drawNineSlice)
-     *  @param {Color|number} [color=WHITE] - Color to modulate with; a number here is the borderSize of the order before 1.20, deprecated
+     *  @param {Color} [color=WHITE] - Color to modulate with
      *  @param {number} [borderSize] - Rendered thickness of the border sections
      *  @param {Color} [additiveColor] - Additive color
      *  @param {number} [extraSpace] - Extra spacing adjustment
@@ -7281,7 +7479,7 @@ declare module "littlejsengine" {
      *  @param {boolean} [useWebGL] - Use WebGL for rendering
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas context to use
      *  @memberof DrawUtilities */
-    export function drawNineSliceScreen(pos: Vector2, size: Vector2, startTile: TileInfo, color?: Color | number, borderSize?: number, additiveColor?: Color, extraSpace?: number, angle?: number, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, ...args: any[]): void;
+    export function drawNineSliceScreen(pos: Vector2, size: Vector2, startTile: TileInfo, color?: Color, borderSize?: number, additiveColor?: Color, extraSpace?: number, angle?: number, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw a scalable three-slice UI element in world space
      *  Color and additive color apply in WebGL and Canvas2D (with canvasColorTiles)
      *  The three-slice samples 3 consecutive tiles from the tilesheet, it does not
@@ -7309,7 +7507,7 @@ declare module "littlejsengine" {
      *  @param {Vector2} pos - Screen space position
      *  @param {Vector2} size - Screen space size
      *  @param {TileInfo} startTile - First of 3 consecutive tiles: corner, side, center (see drawThreeSlice)
-     *  @param {Color|number} [color=WHITE] - Color to modulate with; a number here is the borderSize of the order before 1.20, deprecated
+     *  @param {Color} [color=WHITE] - Color to modulate with
      *  @param {number} [borderSize] - Rendered thickness of the border sections
      *  @param {Color} [additiveColor] - Additive color
      *  @param {number} [extraSpace] - Extra spacing adjustment
@@ -7317,7 +7515,7 @@ declare module "littlejsengine" {
      *  @param {boolean} [useWebGL] - Use WebGL for rendering
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas context to use
      *  @memberof DrawUtilities */
-    export function drawThreeSliceScreen(pos: Vector2, size: Vector2, startTile: TileInfo, color?: Color | number, borderSize?: number, additiveColor?: Color, extraSpace?: number, angle?: number, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, ...args: any[]): void;
+    export function drawThreeSliceScreen(pos: Vector2, size: Vector2, startTile: TileInfo, color?: Color, borderSize?: number, additiveColor?: Color, extraSpace?: number, angle?: number, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /**
      * A tile drawn as a box of any size, kept as a style to draw with, like a UI skin
      * - 9 slices is a nine-slice from the 3x3 block of tiles at tileInfo, see drawNineSlice
@@ -7414,9 +7612,9 @@ declare module "littlejsengine" {
          *  callback receives the interpolated value (a number, or a fresh instance
          *  for lerp-able types). Both endpoints must be the same type.
          *  @param {function(NonNullable<T>):void} callback - Called with the interpolated value each frame
-         *  @param {T} [start=0] - Starting value
-         *  @param {T} [end=1] - Ending value
-         *  @param {number} [duration=1] - Duration in seconds
+         *  @param {T} [start] - Starting value
+         *  @param {T} [end] - Ending value
+         *  @param {number} [duration] - Duration in seconds
          *  @param {Object} [options]
          *  @param {function(number):number} [options.ease] - Easing function (defaults to LINEAR)
          *  @param {boolean} [options.useRealTime=false] - Advance even when the game is paused (matches Timer's useRealTime)
@@ -7455,9 +7653,12 @@ declare module "littlejsengine" {
         /** Remaining iterations including the current run (loop/pingPong only).
          *  @private */
         private loopRemaining;
-        /** Whether it is in the active list, see isActive
+        /** Whether it is running, see isActive
          *  @private */
         private active;
+        /** Whether it is in the active list, which a stopped one leaves at the next update
+         *  @private */
+        private listed;
         /** The update it was started in, it first moves on the one after
          *  @private */
         private activePass;
@@ -7474,7 +7675,7 @@ declare module "littlejsengine" {
         } | undefined;
         /** Set the easing curve and return this for chaining.
          *  @param {function(number):number} easeFn
-         *  @returns {Tween<T>} */
+         *  @return {Tween<T>} */
         setEase(easeFn: (arg0: number) => number): Tween<T>;
         /** Set the completion callback, `onComplete`, and return this for chaining.
          *  It is called once the tween completes: when its pass ends, or for a
@@ -7484,7 +7685,7 @@ declare module "littlejsengine" {
          *  - It is kept by `restart`, so a restarted tween calls it again when it completes
          *  - `stop` and `tweenStopAll` end a tween without calling it
          *  @param {function():void} callback
-         *  @returns {Tween<T>} */
+         *  @return {Tween<T>} */
         then(callback: () => void): Tween<T>;
         /** Repeat this tween `n` total times. After each iteration finishes, the
          *  same tween starts over, so the handle returned stays good for the whole
@@ -7495,7 +7696,7 @@ declare module "littlejsengine" {
          *  A `then` callback, set before or after, is called when the last
          *  iteration ends.
          *  @param {number} [count=Infinity]
-         *  @returns {Tween<T>} */
+         *  @return {Tween<T>} */
         loop(count?: number): Tween<T>;
         /** Like `loop`, but swap `start` and `end` between iterations so the value
          *  bounces back and forth. `pingPong()` with no argument bounces forever.
@@ -7504,7 +7705,7 @@ declare module "littlejsengine" {
          *  A `then` callback, set before or after, is called when the last
          *  iteration ends.
          *  @param {number} [count=Infinity]
-         *  @returns {Tween<T>} */
+         *  @return {Tween<T>} */
         pingPong(count?: number): Tween<T>;
         /** Pause this tween. While paused, tweenUpdate skips it. */
         pause(): void;
@@ -7520,16 +7721,16 @@ declare module "littlejsengine" {
          *  again when it completes. */
         restart(): void;
         /** True if this tween is in the active list and not paused.
-         *  @returns {boolean} */
+         *  @return {boolean} */
         isActive(): boolean;
         /** Get how far this tween has progressed, from 0 (just started) to 1
          *  (completed). Clamped — overshoot past completion still reads 1.
-         *  @returns {number} */
+         *  @return {number} */
         getPercent(): number;
         /** Get the current interpolated value (the value most recently passed to
          *  the callback). Returns a number, Vector2, Vector3 or Color depending on the
          *  tween's start/end types.
-         *  @returns {T} */
+         *  @return {T} */
         getValue(): T;
         /** Compute the interpolated value at the given remaining `life`.
          *  At life === duration the result is `start`; at life === 0 it is `end`.
@@ -7537,7 +7738,7 @@ declare module "littlejsengine" {
          *  - A vector goes past its ends as far as the easing does, as a number does; a Color stays between them,
          *    so its channels stay in range, and any other type goes as far as its own lerp takes it
          *  @param {number} life
-         *  @returns {T} */
+         *  @return {T} */
         interp(life: number): T;
         /** Remove this tween from the active list, ending a loop or pingPong too, without calling
          *  the then-callback. It keeps the then-callback, so a restart calls it when it completes. */
@@ -7558,12 +7759,12 @@ declare module "littlejsengine" {
      *  @param {string} propertyPath - Dot-separated path, e.g. `'pos.x'` or `'color'`
      *  @param {T} start - Starting value
      *  @param {T} end - Ending value
-     *  @param {number} [duration=1] - Duration in seconds
+     *  @param {number} [duration] - Duration in seconds
      *  @param {Object} [options] - Same options as the Tween constructor
      *  @param {function(number):number} [options.ease] - Easing function (defaults to LINEAR)
      *  @param {boolean} [options.useRealTime=false] - Advance even when the game is paused
      *  @param {boolean} [options.paused=false] - Start in paused state
-     *  @returns {Tween<T>}
+     *  @return {Tween<T>}
      *  @memberof TweenSystem
      *  @example
      *  // Numeric: slide an object's x with an ease-out sine curve
@@ -7702,7 +7903,8 @@ declare module "littlejsengine" {
      *  gridFinder.isWalkable = (x, y) => myGrid[y*50 + x] === 0;
      */
     export class PathFinder {
-        /** @param {TileCollisionLayer|Vector2} source - Either a TileCollisionLayer
+        /** Make a path finder over a tile layer or a grid
+         *  @param {TileCollisionLayer|Vector2} source - Either a TileCollisionLayer
          *  (size and walkability auto-derived) or a Vector2 grid size (user
          *  overrides isWalkable). */
         constructor(source: TileCollisionLayer | Vector2);
@@ -7743,27 +7945,27 @@ declare module "littlejsengine" {
          *  the instance or via a subclass.
          *  @param {number} x - Tile x
          *  @param {number} y - Tile y
-         *  @returns {boolean} */
+         *  @return {boolean} */
         isWalkable(x: number, y: number): boolean;
         /** Default extra cost for stepping on a cell. Returns 0 (free) by default.
          *  Override to add cost-weighted terrain (mud, swamp, etc).
          *  @param {number} x - Tile x
          *  @param {number} y - Tile y
-         *  @returns {number} */
+         *  @return {number} */
         getCost(x: number, y: number): number;
         /** Get the node at tile coords, or null if out of bounds.
          *  @param {number} x
          *  @param {number} y
-         *  @returns {PathFinderNode|null} */
+         *  @return {PathFinderNode|null} */
         getNode(x: number, y: number): PathFinderNode | null;
         /** Convert a world-space position to integer tile coords (no clamping).
          *  @param {Vector2} worldPos
-         *  @returns {Vector2} */
+         *  @return {Vector2} */
         worldToTile(worldPos: Vector2): Vector2;
         /** Convert integer tile coords to the world-space center of that tile.
          *  @param {number} x
          *  @param {number} y
-         *  @returns {Vector2} */
+         *  @return {Vector2} */
         tileToWorld(x: number, y: number): Vector2;
         /** Reset all nodes and re-populate walkable / cost / posWorld from the
          *  current isWalkable / getCost overrides. Called at the start of
@@ -7774,7 +7976,7 @@ declare module "littlejsengine" {
          *  reached; false on disconnected goal or maxLoop exhaustion, which sets searchGaveUp.
          *  @param {PathFinderNode} startNode
          *  @param {PathFinderNode} endNode
-         *  @returns {boolean}
+         *  @return {boolean}
          *  @private */
         private aStarSearch;
         /** Find the clear (walkable, zero-cost) node closest to the given world
@@ -7787,9 +7989,9 @@ declare module "littlejsengine" {
          *  unchanged walkability, pass `rebuild=false` and call `buildNodeData()`
          *  once externally to avoid redundant work.
          *  @param {Vector2} worldPos
-         *  @param {number} [searchRange=10] - Max box-radius in tiles
-         *  @param {boolean} [rebuild=true] - Whether to call buildNodeData first
-         *  @returns {PathFinderNode|null} */
+         *  @param {number} [searchRange] - Max box-radius in tiles
+         *  @param {boolean} [rebuild] - Whether to call buildNodeData first
+         *  @return {PathFinderNode|null} */
         getNearestClearNode(worldPos: Vector2, searchRange?: number, rebuild?: boolean): PathFinderNode | null;
         /** Smooth a node path by removing redundant turns and tightening corners
          *  where a grid-aligned diagonal is clear. Modifies the path in place.
@@ -7824,7 +8026,7 @@ declare module "littlejsengine" {
          *  and clear (walkable, zero-cost). Used by isLineClear's hot path.
          *  @param {number} x
          *  @param {number} y
-         *  @returns {boolean}
+         *  @return {boolean}
          *  @private */
         private isNodeClear;
         /** Check that the line between two tile-coord endpoints stays entirely
@@ -7836,7 +8038,7 @@ declare module "littlejsengine" {
          *  CheckLine() in pathFinding.cpp.
          *  @param {Vector2} startPos - Tile coords
          *  @param {Vector2} endPos - Tile coords
-         *  @returns {boolean}
+         *  @return {boolean}
          *  @private */
         private isLineClear;
         /** Find a path from startPos to endPos in world space. Returns an array
@@ -7853,7 +8055,7 @@ declare module "littlejsengine" {
          *  @param {Vector2} startPos - World-space start
          *  @param {Vector2} endPos - World-space end
          *  @param {boolean} [rebuild] - Whether to call buildNodeData first
-         *  @returns {Vector2[]} */
+         *  @return {Vector2[]} */
         findPath(startPos: Vector2, endPos: Vector2, rebuild?: boolean): Vector2[];
     }
     /** A single grid cell tracked by the pathfinder. Allocated once per cell at
@@ -7861,7 +8063,8 @@ declare module "littlejsengine" {
      *  findPath call.
      *  @memberof PathFinding */
     export class PathFinderNode {
-        /** @param {number} x - Tile x
+        /** Make the node of a grid cell, as PathFinder does for each
+         *  @param {number} x - Tile x
          *  @param {number} y - Tile y */
         constructor(x: number, y: number);
         /** @property {Vector2} - Tile coords (integer) */
@@ -7891,7 +8094,8 @@ declare module "littlejsengine" {
         resetSearch(): void;
         /** Reset per-search state and walkability (called by buildNodeData). */
         reset(): void;
-        /** True if walkable and not blocked by cost. */
+        /** True if walkable and not blocked by cost.
+         *  @return {boolean} */
         isClear(): boolean;
     }
     /** Options for a tweak
@@ -8171,7 +8375,7 @@ declare module "littlejsengine" {
         static lookAt(eye: Vector3, target: Vector3, up?: Vector3): Matrix4;
         /** Create a matrix, identity by default
          *  @param {Float32Array|Array<number>} [m] - 16 column major values */
-        constructor(m?: Float32Array | Array<number>);
+        constructor(m?: number[] | Float32Array);
         /** @property {Float32Array} - The 16 column major values */
         m: Float32Array;
         /** Returns a new matrix that is a copy of this
@@ -8587,7 +8791,8 @@ declare module "littlejsengine" {
         streamCount: number;
         /** @type {TextureInfo|undefined} */
         streamTileInfo: TextureInfo | undefined;
-        streamState: any;
+        /** @type {Object|undefined} */
+        streamState: any | undefined;
         streamUnlit: boolean;
         /** @type {Mesh|undefined} */
         capture: Mesh | undefined;
@@ -8640,10 +8845,10 @@ declare module "littlejsengine" {
          *  like polished metal; set from each object's shininess
          *  @return {number} */
         get shininess(): number;
-        set normalMap(arg: TextureInfo);
+        set normalMap(arg: TextureInfo | undefined);
         /** Normal map for the next draws, set from each object's normalMap
          *  @return {TextureInfo|undefined} */
-        get normalMap(): TextureInfo;
+        get normalMap(): TextureInfo | undefined;
         set normalScale(arg: number);
         /** How strongly the normal map bends the surface, set from each object's normalScale
          *  @return {number} */
@@ -8652,20 +8857,20 @@ declare module "littlejsengine" {
         /** How much the surface reflects the sky, 0 to 1, set from each object's reflectivity
          *  @return {number} */
         get reflectivity(): number;
-        set emissiveMap(arg: TextureInfo);
+        set emissiveMap(arg: TextureInfo | undefined);
         /** Emissive map for the next draws, set from each object's emissiveMap
          *  @return {TextureInfo|undefined} */
-        get emissiveMap(): TextureInfo;
+        get emissiveMap(): TextureInfo | undefined;
         set emissiveMapColor(arg: Color);
         /** Multiplies the emissive map, set from each object's emissiveMapColor; compared by its rgb, so a Color
          *  changed in place is seen when it is set again, and undefined is white
          *  @return {Color} */
         get emissiveMapColor(): Color;
-        set shader(arg: Shader);
+        set shader(arg: Shader | undefined);
         /** Custom Shader for the next draws, set from each object's shader; undefined draws
          *  with the plugin's own
          *  @return {Shader|undefined} */
-        get shader(): Shader;
+        get shader(): Shader | undefined;
         set receiveShadow(arg: boolean);
         /** Darken by the shadow map when shadows are on, turn it off for things that should
          *  stay lit inside a shadow
@@ -8715,7 +8920,7 @@ declare module "littlejsengine" {
          *  @param {Vector2|Ray3D} from - A screen position like mousePosScreen, or a ray to look along
          *  @param {Array<EngineObject>} [objects] - Defaults to every object; only those with a mesh or a sprite count
          *  @return {{object: EngineObject3D, distance: number}|undefined} */
-        pick(from: Vector2 | Ray3D, objects?: Array<EngineObject>): {
+        pick(from: Vector2 | Ray3D, objects?: EngineObject[]): {
             object: EngineObject3D;
             distance: number;
         } | undefined;
@@ -8752,7 +8957,7 @@ declare module "littlejsengine" {
          *  @param {TileInfo|TextureInfo} [tileInfo] - Texture, mesh uvs map across the tile or the whole texture
          *  @param {Color} [color] - Tint
          *  @return {void} */
-        drawMesh(mesh: Mesh, matrix?: Matrix4 | Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color): void;
+        drawMesh(mesh: Mesh, matrix?: Vector3 | Matrix4, tileInfo?: TileInfo | TextureInfo, color?: Color): void;
         /** Draw a triangle strip, batched into the stream with the current draw state
          *  - Strip order: the first three points make a triangle, then each point makes another with the two before it
          *  - List the first three points counter clockwise as seen from the front, or the face points away
@@ -8765,14 +8970,14 @@ declare module "littlejsengine" {
          *  @param {Color|Array<Color>} [colors] - One for all or one per point, vertex colors come before the texture
          *  @param {TileInfo|TextureInfo} [tileInfo] - Texture for this strip
          *  @return {void} */
-        drawStrip(points: Array<Vector3>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>, tileInfo?: TileInfo | TextureInfo): void;
+        drawStrip(points: Array<Vector3>, normals?: Vector3 | Vector3[], uvs?: Vector2 | Vector2[], colors?: Color | Color[], tileInfo?: TileInfo | TextureInfo): void;
         /** Draw a strip with lighting off, for camera facing shapes where the light direction means nothing
          *  @param {Array<Vector3>} points - Strip order
          *  @param {Vector3|Array<Vector3>} [normals]
          *  @param {Vector2|Array<Vector2>} [uvs]
          *  @param {Color|Array<Color>} [colors]
          *  @param {TileInfo|TextureInfo} [tileInfo] */
-        drawStripUnlit(points: Array<Vector3>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>, tileInfo?: TileInfo | TextureInfo): void;
+        drawStripUnlit(points: Array<Vector3>, normals?: Vector3 | Vector3[], uvs?: Vector2 | Vector2[], colors?: Color | Color[], tileInfo?: TileInfo | TextureInfo): void;
         /** Draw the pending stream vertices as one strip with the state they were drawn under, called automatically when needed */
         flush(): void;
         /** Build a mesh once out of draw calls, instead of redrawing the shapes every frame
@@ -8820,7 +9025,7 @@ declare module "littlejsengine" {
          *  @param {Vector3|number} [size] - Full size, a number for a cube
          *  @param {Color} [color]
          *  @param {Vector3} [rotation] - vec3(pitch, yaw, roll) */
-        drawBox(pos: Vector3, size?: Vector3 | number, color?: Color, rotation?: Vector3): void;
+        drawBox(pos: Vector3, size?: number | Vector3, color?: Color, rotation?: Vector3): void;
         /** Draw a sphere, untextured and smooth shaded
          *  @param {Vector3} pos - Center
          *  @param {number} [size] - Diameter
@@ -8843,7 +9048,7 @@ declare module "littlejsengine" {
          *  @param {Vector3} d
          *  @param {TileInfo|TextureInfo} [tileInfo]
          *  @param {Color|Array<Color>} [color] - One for all or one per corner */
-        drawQuad(a: Vector3, b: Vector3, c: Vector3, d: Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color | Array<Color>): void;
+        drawQuad(a: Vector3, b: Vector3, c: Vector3, d: Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color | Color[]): void;
         /** Draw a triangle, counter clockwise from outside is the front
          *  @param {Vector3} a
          *  @param {Vector3} b
@@ -8865,7 +9070,7 @@ declare module "littlejsengine" {
          *  @param {Color|Array<Color>} [color] - One for all or one per point
          *  @param {Vector3|Array<Vector3>} [side] - Direction across the ribbon, one for all or one per point, default
          *    faces the camera */
-        drawRibbon(points: Array<Vector3>, width?: number | Array<number>, tileInfo?: TileInfo | TextureInfo, color?: Color | Array<Color>, side?: Vector3 | Array<Vector3>): void;
+        drawRibbon(points: Array<Vector3>, width?: number | number[], tileInfo?: TileInfo | TextureInfo, color?: Color | Color[], side?: Vector3 | Vector3[]): void;
         /** Draw a disc that fades to transparent at the rim, unlit, for glows, puffs and sky dots
          *  @param {Vector3} pos - Center
          *  @param {number} [size] - Diameter
@@ -9184,7 +9389,7 @@ declare module "littlejsengine" {
          *  @param {Vector2|Array<Vector2>} [uvs] - One for all or one per point, default zero
          *  @param {Color|Array<Color>} [colors] - One for all or one per point, default white
          *  @return {Mesh} */
-        addStrip(points: Array<Vector3>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>): Mesh;
+        addStrip(points: Array<Vector3>, normals?: Vector3 | Vector3[], uvs?: Vector2 | Vector2[], colors?: Color | Color[]): Mesh;
         /** Add triangles over their own vertices, the indexed form a model file comes in
          *  - The mesh becomes indexed: a strip mesh is turned into triangles first, and strips added later join as triangles
          *  - List each triangle counter clockwise as seen from the front, like a strip's first triangle
@@ -9194,7 +9399,7 @@ declare module "littlejsengine" {
          *  @param {Vector2|Array<Vector2>} [uvs] - One for all or one per point, default zero
          *  @param {Color|Array<Color>} [colors] - One for all or one per point, default white
          *  @return {Mesh} */
-        addTriangles(points: Array<Vector3>, indices: Array<number>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>): Mesh;
+        addTriangles(points: Array<Vector3>, indices: Array<number>, normals?: Vector3 | Vector3[], uvs?: Vector2 | Vector2[], colors?: Color | Color[]): Mesh;
         /** Turn a strip mesh into the indexed form, each distinct vertex once and the real triangles over them, in place
          *  - An indexed mesh is left as it is; the builders make strips and a loader makes this, and either draws the same
          *  @return {Mesh} */
@@ -9207,13 +9412,13 @@ declare module "littlejsengine" {
          *  @param {Color|Array<Color>} [color] - One for all or one per corner
          *  @param {Array<Vector2>} [uvs] - One per corner, default across the tile
          *  @return {Mesh} */
-        addQuad(a: Vector3, b: Vector3, c: Vector3, d: Vector3, color?: Color | Array<Color>, uvs?: Array<Vector2>): Mesh;
+        addQuad(a: Vector3, b: Vector3, c: Vector3, d: Vector3, color?: Color | Color[], uvs?: Vector2[]): Mesh;
         /** Append another mesh transformed by a matrix, for building one shape out of several
          *  @param {Mesh} mesh
          *  @param {Matrix4|Vector3} [matrix] - Transform, or just a position to move it to
          *  @param {Color} [color] - Multiplies the appended vertex colors
          *  @return {Mesh} */
-        combine(mesh: Mesh, matrix?: Matrix4 | Vector3, color?: Color): Mesh;
+        combine(mesh: Mesh, matrix?: Vector3 | Matrix4, color?: Color): Mesh;
         /** Returns a new mesh: this one and its mirror image across the plane through the origin facing axis
          *  - For modeling half a shape against that plane, a part that crosses it overlaps its image
          *  @param {Vector3} [axis] - Faces the mirror plane, vec3(1,0,0) mirrors across x
@@ -9228,7 +9433,7 @@ declare module "littlejsengine" {
          *  @param {Mesh} mesh - Closed, as the builders make them apart from the open ones like buildGrid
          *  @param {Matrix4|Vector3} [matrix] - Places the other mesh, or just a position to move it to
          *  @return {Mesh} */
-        union(mesh: Mesh, matrix?: Matrix4 | Vector3): Mesh;
+        union(mesh: Mesh, matrix?: Vector3 | Matrix4): Mesh;
         /** Returns a new mesh of this one with the other cut out of it, CSG with BSP trees
          *  - Both must be closed, every edge shared by two triangles, as the builders make them apart from the open
          *    ones like buildGrid and buildRibbon; the result is closed and indexed, and neither mesh changes
@@ -9245,12 +9450,12 @@ declare module "littlejsengine" {
          *  @return {Mesh}
          *  @example
          *  const wall = buildBox(vec3(4, 3, .5)).subtract(buildBox(vec3(1, 2, 1)), vec3(0, -.5, 0)); // a doorway */
-        subtract(mesh: Mesh, matrix?: Matrix4 | Vector3): Mesh;
+        subtract(mesh: Mesh, matrix?: Vector3 | Matrix4): Mesh;
         /** Returns a new mesh of only what is in both this mesh and the other, see subtract
          *  @param {Mesh} mesh - Closed, as the builders make them apart from the open ones like buildGrid
          *  @param {Matrix4|Vector3} [matrix] - Places the other mesh, or just a position to move it to
          *  @return {Mesh} */
-        intersect(mesh: Mesh, matrix?: Matrix4 | Vector3): Mesh;
+        intersect(mesh: Mesh, matrix?: Vector3 | Matrix4): Mesh;
         /** Scale every uv, so a whole texture repeats across the mesh when its TextureInfo wraps
          *  @param {Vector2|number} scale - Repeats across and up, a number for both
          *  @return {Mesh} */
@@ -9303,7 +9508,7 @@ declare module "littlejsengine" {
          *  @param {Matrix4|Vector3} [matrix] - Object transform, or just a position to draw it at
          *  @param {TileInfo|TextureInfo} [tileInfo] - Texture, mesh uvs map across the tile or the whole texture
          *  @param {Color} [color] - Tint */
-        render(matrix?: Matrix4 | Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color): void;
+        render(matrix?: Vector3 | Matrix4, tileInfo?: TileInfo | TextureInfo, color?: Color): void;
         /** Delete the GPU buffer now, the CPU arrays stay so the mesh can be rendered again
          *  - Optional, the buffer is freed anyway once the mesh is garbage collected, this frees it right away */
         dispose(): void;
@@ -9362,11 +9567,11 @@ declare module "littlejsengine" {
         boundsEnd: number;
         /** @type {number|undefined} */
         fixedRadius: number | undefined;
-        buffer: WebGLBuffer;
+        buffer: WebGLBuffer | null | undefined;
         /** @type {WebGLBuffer|undefined} */
         colorBuffer: WebGLBuffer | undefined;
         bufferGeneration: number;
-        uvTileInfo: TileInfo | TextureInfo;
+        uvTileInfo: TileInfo | TextureInfo | undefined;
         /** Place an instance by its position, rotation and scale, what buildMatrix takes, written straight in with no
          *  matrix made; in world space
          *  @param {number} i
@@ -9507,7 +9712,7 @@ declare module "littlejsengine" {
      * @return {Mesh}
      * @memberof Render3D
      */
-    export function buildBox(size?: Vector3 | number, bevel?: number, bevelSegments?: number): Mesh;
+    export function buildBox(size?: number | Vector3, bevel?: number, bevelSegments?: number): Mesh;
     /**
      * Build a heightfield grid in the XZ plane centered on the origin
      * - smooth rounds the lighting across cells and colors each corner
@@ -9525,7 +9730,7 @@ declare module "littlejsengine" {
      * @example
      * const ground = buildGrid(vec2(20), 10, (x, z)=> (floor(x / 2) + floor(z / 2)) & 1 ? GRAY : WHITE); // 2 unit checks
      */
-    export function buildGrid(size?: Vector2 | number, segments?: Vector2 | number, color?: Color | ((arg0: number, arg1: number) => Color), heightFunction?: (arg0: number, arg1: number) => number, smooth?: boolean): Mesh;
+    export function buildGrid(size?: number | Vector2, segments?: number | Vector2, color?: Color | ((arg0: number, arg1: number) => Color), heightFunction?: (arg0: number, arg1: number) => number, smooth?: boolean): Mesh;
     /**
      * Build a lit ribbon along a path, for roads, tracks and walls
      * - Each segment is a flat quad, the sides are across the path in the plane of the up vector
@@ -9540,7 +9745,7 @@ declare module "littlejsengine" {
      * @example
      * const road = buildRibbon(trackPoints, 8, GRAY, true); // a loop of road
      */
-    export function buildRibbon(points: Array<Vector3>, width?: number | Array<number>, color?: Color | Array<Color>, closed?: boolean, up?: Vector3): Mesh;
+    export function buildRibbon(points: Array<Vector3>, width?: number | number[], color?: Color | Color[], closed?: boolean, up?: Vector3): Mesh;
     /**
      * Build a hull from a row of diamond shaped slices along Z, for ships, planes and cars
      * - Each slice is [z, width, top, bottom, sideHeight]
@@ -9632,7 +9837,7 @@ declare module "littlejsengine" {
          *  @param {Array<Array<Color>>|HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|TextureInfo} [colors]
          *  @param {Vector3} [pos3D] - Center of the map
          *  @param {boolean} [smooth] - Defaults to render3D.smoothShading */
-        constructor(heights: Array<Array<number>> | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | TextureInfo, mapSize?: Vector2, height?: number, colors?: Array<Array<Color>> | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | TextureInfo, pos3D?: Vector3, smooth?: boolean);
+        constructor(heights: Array<Array<number>> | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | TextureInfo, mapSize?: Vector2, height?: number, colors?: OffscreenCanvas | HTMLCanvasElement | HTMLImageElement | TextureInfo | Color[][], pos3D?: Vector3, smooth?: boolean);
         /** @property {Array<Array<number>>} - Heights 0-1 as [row][column], rows along Z, rebuild() after changing them */
         heights: number[][];
         /** @property {Array<Array<Color>>|undefined} - Vertex colors as [row][column], undefined for white
@@ -9692,7 +9897,7 @@ declare module "littlejsengine" {
         levelSegment3D(from: Vector3, to: Vector3): {
             distance: number;
             normal: Vector3;
-        };
+        } | undefined;
         /** Keep an object above the ground, called by the engine for each object with collideLevel
          *  @param {EngineObject3D} o
          *  @param {Vector3} oldPos - Where it was before it moved
@@ -9731,6 +9936,8 @@ declare module "littlejsengine" {
         constructor(pos3D?: Vector3, mapSize?: Vector3, tileInfo?: TileInfo);
         /** @property {Vector3} - Cells along X, Y and Z */
         mapSize: Vector3;
+        /** @property {TileInfo} - The sheet's first tile, rebuild() after changing it or resizing its texture */
+        tileInfo: TileInfo;
         /** @property {Uint8Array} - The block type of each cell, x + mapSize.x * (y + mapSize.y * z), 0 empty; call
          *  rebuild() after changing it directly */
         data: Uint8Array;
@@ -9920,13 +10127,13 @@ declare module "littlejsengine" {
          *  @param {Color} [color] - Tints the flare, with the light's own color
          *  @return {LensFlare3D} - The flare, to change: light.addFlare().shapes = ['hex'] */
         addFlare(size?: number, count?: number, intensity?: number, saturation?: number, color?: Color): LensFlare3D;
-        set flare(arg: LensFlare3D);
+        set flare(arg: LensFlare3D | undefined);
         /** The light's lens flare, undefined for none: addFlare makes it, or set a LensFlare3D of your own, and
          *  destroying the flare takes it away
          *  - The flare is the light's: it is attached to the light as its child, so it stays through a scene change
          *    when the light does, and is destroyed with the light or when another takes its place
          *  @type {LensFlare3D|undefined} */
-        get flare(): LensFlare3D;
+        get flare(): LensFlare3D | undefined;
     }
     /**
      * DirectionalLight3D - A Light3D that shines from far away with no falloff, like sunlight
@@ -10220,7 +10427,7 @@ declare module "littlejsengine" {
         }>;
         /** Forget the trail so far, for when the object teleports */
         clear(): void;
-        worldPos3D: Vector3;
+        worldPos3D: Vector3 | undefined;
     }
     /**
      * A part of a lens flare
@@ -10308,18 +10515,28 @@ declare module "littlejsengine" {
          *  glowSize and ghostSize, a glow and a core at the sun and the ghosts, made again when one of those changes
          *  @return {Array<LensFlareElement>} */
         getElements(): Array<LensFlareElement>;
+        /** What the flare is of, seen from the camera: the way to it, how far it is, Infinity for the sun and for a
+         *  directional light, which shines from its place toward the origin, and a point to find it on the screen by;
+         *  undefined with no direction, or a light that is gone or at the camera
+         *  @return {{direction: Vector3, distance: number, pos: Vector3}|undefined}
+         *  @ignore */
         flareSource(): {
             direction: Vector3;
             distance: number;
             pos: Vector3;
-        };
+        } | undefined;
+        /** How the flare would show with nothing in the way: where its source is on the screen, how strong it is there,
+         *  fading as it leaves the screen, its tint and the height its sizes are parts of; undefined when it would not
+         *  show at all, behind the camera, off the screen, or of a light that is off or seen from outside its cone
+         *  @return {{sun: Vector2, center: Vector2, strength: number, tint: Color, height: number}|undefined}
+         *  @ignore */
         flareLook(): {
             sun: Vector2;
             center: Vector2;
             strength: number;
             tint: Color;
             height: number;
-        };
+        } | undefined;
         /** Where the sun, or the flare's light, is on the screen, in pixels like mousePosScreen, undefined when it is
          *  behind the camera
          *  @return {Vector2|undefined} */
@@ -10353,7 +10570,7 @@ declare module "littlejsengine" {
      * @return {Array<EngineObject3D>}
      * @memberof Render3D
      */
-    export function engineObjectsCollect3D(pos: Vector3, size: Vector3 | number, objects?: Array<EngineObject>, testCenters?: boolean): Array<EngineObject3D>;
+    export function engineObjectsCollect3D(pos: Vector3, size: Vector3 | number, objects?: EngineObject[], testCenters?: boolean): Array<EngineObject3D>;
     /**
      * Call a function for each EngineObject3D whose box overlaps a sphere or a box
      * - An object destroyed by an earlier callback is skipped
@@ -10364,7 +10581,7 @@ declare module "littlejsengine" {
      * @param {boolean} [testCenters] - Test only each object's center, see engineObjectsCollect3D
      * @memberof Render3D
      */
-    export function engineObjectsCallback3D(pos: Vector3, size: Vector3 | number, callback: (arg0: EngineObject3D) => void, objects?: Array<EngineObject>, testCenters?: boolean): void;
+    export function engineObjectsCallback3D(pos: Vector3, size: Vector3 | number, callback: (arg0: EngineObject3D) => void, objects?: EngineObject[], testCenters?: boolean): void;
     /**
      * Collect every EngineObject3D a ray passes through, nearest first, the 3D twin of engineObjectsRaycast
      * - The ray has no end, so everything along it counts however far away it is
@@ -10374,7 +10591,7 @@ declare module "littlejsengine" {
      * @return {Array<EngineObject3D>}
      * @memberof Render3D
      */
-    export function engineObjectsRaycast3D(ray: Ray3D, objects?: Array<EngineObject>): Array<EngineObject3D>;
+    export function engineObjectsRaycast3D(ray: Ray3D, objects?: EngineObject[]): Array<EngineObject3D>;
     /**
      * Parse Wavefront OBJ text into a Mesh
      * - Reads v, vt, vn and f lines with convex polygons of any size, materials and groups are ignored
@@ -10404,8 +10621,9 @@ declare module "littlejsengine" {
      * @memberof GLTF
      */
     export class GLTFModel {
-        /** @param {Array<GLTFPart>} parts @param {Array<GLTFAnimation>} [animations] @param {Object} [nodeTree] */
-        constructor(parts: Array<GLTFPart>, animations?: Array<GLTFAnimation>, nodeTree?: any);
+        /** Make a model from its parts, as the loader does
+         *  @param {Array<GLTFPart>} parts @param {Array<GLTFAnimation>} [animations] @param {Object} [nodeTree] */
+        constructor(parts: Array<GLTFPart>, animations?: GLTFAnimation[], nodeTree?: any);
         /** @property {Array<GLTFPart>} - One per primitive of every node that has a mesh */
         parts: GLTFPart[];
         /** @property {Array<GLTFAnimation>} - The animations, play one through createObject's GLTFObject
@@ -10451,6 +10669,7 @@ declare module "littlejsengine" {
          *  @param {number} time - Seconds into it
          *  @return {Array<Matrix4>} */
         getPose(animation: GLTFAnimation, time: number): Array<Matrix4>;
+        partPoses(worldOf: any): Matrix4[];
         /** Free the GPU buffers of every part's mesh and of the combined mesh, and the textures, for a model that is
          *  done with, like a level's models when the next level loads
          *  - Destroy the objects createObject made from it first; a mesh drawn again only uploads again, but a freed
@@ -10468,9 +10687,11 @@ declare module "littlejsengine" {
      * - Loads glTF 2.0 models: a .gltf with its .bin and images beside it, or a .glb with everything in one file
      * - A model comes back as parts, one Mesh per primitive of every node placed by the node tree, each with its
      *   material's color and base color texture, plus everything combined into one Mesh
-     * - Geometry: positions, normals, uvs, vertex colors and indices; skins and morph targets are not read
-     * - Node animations play: parts that move, turn and scale, like doors, wheels and propellers, through the
-     *   GLTFObject that createObject makes; a skinned character's walk is not read
+     * - Geometry: positions, normals, uvs, vertex colors and indices, and skins, the four strongest joints of a vertex
+     *   of up to eight; morph targets are not read
+     * - Animations play through the GLTFObject that createObject makes: parts that move, turn and scale, like doors,
+     *   wheels and propellers, and skinned characters, their meshes bent by their joints each frame; play takes a
+     *   blend time to cross-fade from one animation to the next
      * - Materials give a base color and texture and whether they blend; glass made with KHR_materials_transmission blends too,
      *   and a KHR_materials_unlit material comes in emissive, its own color with no shading
      * - A material's normal map and emissive map load too, with its normal scale and emissive factor, read at the base
@@ -10488,6 +10709,7 @@ declare module "littlejsengine" {
      * const model = await loadGLTF('ship.glb');   // in an async gameInit
      * const ship = model.createObject(vec3(0, 1, 0)); // an object with a child per part, textures and all
      * ship.play('fly');                            // and its animation, by name or number
+     * ship.play('land', false, 1, .3);             // then another, cross-faded over .3 seconds
      * new EngineObject3D(vec3(), model.mesh);      // or the whole thing as one mesh, still
      */
     /**
@@ -10495,7 +10717,8 @@ declare module "littlejsengine" {
      * @memberof GLTF
      */
     export class GLTFPart {
-        /** @param {string} name @param {Mesh} mesh @param {Color} color @param {TextureInfo|undefined} textureInfo @param {boolean} transparent */
+        /** Make a part, as the loader does for each primitive
+         *  @param {string} name @param {Mesh} mesh @param {Color} color @param {TextureInfo|undefined} textureInfo @param {boolean} transparent */
         constructor(name: string, mesh: Mesh, color: Color, textureInfo: TextureInfo | undefined, transparent: boolean);
         /** @property {string} - The node's name, or its mesh's */
         name: string;
@@ -10528,6 +10751,12 @@ declare module "littlejsengine" {
         emissiveMap: TextureInfo | undefined;
         /** @property {Color} - The emissiveFactor, which multiplies the emissive map */
         emissiveMapColor: Color;
+        /** @property {GLTFSkin|undefined} - For a skinned mesh, what bends it: mesh is its resting pose, and the
+         *  object createObject makes bends a copy of its own to each pose
+         *  @type {GLTFSkin|undefined} */
+        skin: GLTFSkin | undefined;
+        /** @type {Array<number>|undefined} */
+        vertexSource: Array<number> | undefined;
     }
     /**
      * GLTFObject - A model as an object with a child per part, which plays the model's animations
@@ -10558,28 +10787,65 @@ declare module "littlejsengine" {
         animationLoop: boolean;
         /** @property {boolean} - Whether it is moving through the animation now */
         animationPlaying: boolean;
+        /** @type {{animation?: GLTFAnimation, time?: number, speed?: number, loop?: boolean, nodes?: Map<number, Object>}|undefined} */
+        blendFrom: {
+            animation?: GLTFAnimation;
+            time?: number;
+            speed?: number;
+            loop?: boolean;
+            nodes?: Map<number, any>;
+        } | undefined;
+        blendTime: number;
+        blendElapsed: number;
+        /** @type {Map<number, Object>|undefined} */
+        poseNodes: Map<number, any> | undefined;
+        poseMixed: boolean;
+        /** @type {(function(number): Matrix4)|undefined} */
+        poseWorldOf: ((arg0: number) => Matrix4) | undefined;
         /** @property {Array<EngineObject3D>} - The child that draws each of the model's parts, in the order of
          *  model.parts, which an animation poses; one destroyed or taken off the object is left alone
          *  @type {Array<EngineObject3D>} */
         parts: Array<EngineObject3D>;
-        /** Play an animation from its start
+        /** Play an animation from its start, at once or cross-faded from the pose it is in
+         *  - A play with a blend of the animation already playing goes on with it, so state code may call it each
+         *    frame; without a blend it starts the animation again
          *  @param {string|number|GLTFAnimation} [animation] - Its name, its number in model.animations, or itself
          *  @param {boolean} [loop] - Start again at the end, or stop there
-         *  @param {number} [speed] - 1 is as made, negative plays it backward from its end */
-        play(animation?: string | number | GLTFAnimation, loop?: boolean, speed?: number): void;
-        /** Stop the animation where it is, the parts hold that pose */
+         *  @param {number} [speed] - 1 is as made, negative plays it backward from its end
+         *  @param {number} [blend] - Seconds to cross-fade from the pose it is in, 0 to switch at once; the animation
+         *    it comes from goes on through the fade, and a fade started during another fades from the mix there */
+        play(animation?: string | number | GLTFAnimation, loop?: boolean, speed?: number, blend?: number): void;
+        /** Stop the animation where it is, the parts hold that pose; a cross-fade going on stops too, holding the mix */
         stop(): void;
         /** Put the parts where the animation has them at a time, playing or not
          *  @param {number} time - Seconds into the animation */
         setAnimationTime(time: number): void;
+        /** A node's matrix in the world as the model is posed now, by its name in the file, to hang something on a
+         *  joint, a sword on a hand or a hat on a head; undefined when the model has no node of that name
+         *  @param {string} name
+         *  @return {Matrix4|undefined} */
+        getJointMatrix(name: string): Matrix4 | undefined;
     }
+    /**
+     * What bends a skinned part: its joints, the nodes that move it, their inverse bind matrices, and for each vertex
+     * of its mesh four joints and four weights, with the place and normal each pose bends from
+     * @typedef {Object} GLTFSkin
+     * @property {Array<number>} joints - The joints, as node numbers
+     * @property {Array<Matrix4>} inverseBind - Each joint's inverse bind matrix
+     * @property {Uint16Array} vertexJoints - Four joints a vertex, as places in joints
+     * @property {Float32Array} vertexWeights - Four weights a vertex, summing to 1
+     * @property {Float32Array} bindPoints - Each vertex's place as stored, x y z
+     * @property {Float32Array} bindNormals - Each vertex's normal as stored, x y z
+     * @memberof GLTF
+     */
     /**
      * GLTFAnimation - One animation of a model: keys that move, turn and scale its nodes over time
      * - Play it through the GLTFObject that model.createObject makes
      * @memberof GLTF
      */
     export class GLTFAnimation {
-        /** @param {string} name @param {Array<Object>} channels */
+        /** Make an animation from its channels, as the loader does
+         *  @param {string} name @param {Array<Object>} channels */
         constructor(name: string, channels: Array<any>);
         /** @property {string} - Its name in the file, or 'animation' and its number when it has none */
         name: string;
@@ -10623,7 +10889,7 @@ declare module "littlejsengine" {
      *  @param {number} [time] - How long to show it, 0 is one frame
      *  @param {Vector3} [rotation] - vec3(pitch, yaw, roll)
      *  @memberof Render3D */
-    export function debugBox3D(pos: Vector3, size?: Vector3 | number, color?: Color, time?: number, rotation?: Vector3): void;
+    export function debugBox3D(pos: Vector3, size?: number | Vector3, color?: Color, time?: number, rotation?: Vector3): void;
     /** Draw a debug wireframe sphere as three rings
      *  @param {Vector3} pos - Center
      *  @param {number} [size] - Diameter
@@ -10658,13 +10924,15 @@ declare module "littlejsengine" {
      *  - Adding a name again replaces it, Box, Sphere, Cylinder and Light too
      *  @param {string} name - The type the objects have in the level
      *  @param {Function} make - A class made at each object's position, or a function called with it
-     *  @param {Object} [defaults] - Properties of each one made, the level editor shows inputs for them
+     *  @param {Object<string, any>} [defaults] - Properties of each one made, the level editor shows inputs for them
      *  @param {TileInfo} [tileInfo] - An icon for the level editor
      *  @memberof Level3D
      *  @example
      *  level3DAddType('Crate', Crate, {health: 3});
      *  level3DAddType('PlayerStart', (pos)=> playerStart = pos); */
-    export function level3DAddType(name: string, make: Function, defaults?: any, tileInfo?: TileInfo): void;
+    export function level3DAddType(name: string, make: Function, defaults?: {
+        [x: string]: any;
+    }, tileInfo?: TileInfo): void;
     /** Add a type that is a mesh and nothing more, a static prop with no class to write, for a built mesh or a model
      *  - Each object has a color and a solid property, solid collides as the box around the mesh
      *  @param {string} name - The type the objects have in the level
@@ -10698,10 +10966,10 @@ declare module "littlejsengine" {
      *    sunColor, fog, its start and end, fogColor, the horizon color when not given, shadows, and lensFlare, the
      *    sun's lens flare; what the block leaves out stays as the game set it, and a level with no block changes
      *    nothing
-     *  @param {Object} level - The level, the level editor edits this same object
+     *  @param {Level3D} level - The level, the level editor edits this same object
      *  @return {Array<any>} - What each object's type made, a function that made nothing is left out
      *  @memberof Level3D */
-    export function level3DLoad(level: any): Array<any>;
+    export function level3DLoad(level: Level3D): Array<any>;
     /** Add a prefab: a small level, its objects placed about its own origin, to place many times under one name
      *  - It is a type from then on: a level's object of that type, the level editor's Place list and level3DSpawn make
      *    an instance, a Prefab3D; an instance is made of the prefab as it is then, so the level editor, where a prefab
@@ -10714,13 +10982,17 @@ declare module "littlejsengine" {
      *    by hand does
      *  - Adding a name again replaces it
      *  @param {string} name - The type its instances have in a level
-     *  @param {Object} prefab - {objects, attached}
+     *  @param {{objects: Array<Object>, attached?: boolean}} prefab - Its objects, about its own origin, and whether
+     *    they are attached
      *  @memberof Level3D
      *  @example
      *  level3DAddPrefab('Tower', {objects: [{type: 'Box', pos: [0, 1, 0], scale: [2, 2, 2]},
      *      {type: 'Cylinder', pos: [0, 3, 0]}]});
      *  level3DLoad({objects: [{type: 'Tower', pos: [5, 0, 5]}, {type: 'Tower', pos: [-5, 0, 5], rotation: [0, 45, 0]}]}); */
-    export function level3DAddPrefab(name: string, prefab: any): void;
+    export function level3DAddPrefab(name: string, prefab: {
+        objects: Array<any>;
+        attached?: boolean;
+    }): void;
     /** Load a prefab from a file the level editor saved and add it
      *  @param {string} name - The type its instances have in a level
      *  @param {string} url
@@ -10733,13 +11005,15 @@ declare module "littlejsengine" {
      *  @param {Vector3} [pos3D]
      *  @param {Vector3} [rotation3D] - In radians, as an object has it
      *  @param {Vector3} [scale3D] - Times the scale the type makes it with
-     *  @param {Object} [properties] - Over the type's defaults
+     *  @param {Object<string, any>} [properties] - Over the type's defaults
      *  @return {any} - What the type made, a Prefab3D for a prefab, undefined when there is no such type
      *  @memberof Level3D
      *  @example
      *  level3DAddPrefab('House', await fetchJSON('house.json'));
      *  level3DSpawn('House', vec3(10, 0, 0), vec3(0, PI/2, 0)); */
-    export function level3DSpawn(type: string, pos3D?: Vector3, rotation3D?: Vector3, scale3D?: Vector3, properties?: any): any;
+    export function level3DSpawn(type: string, pos3D?: Vector3, rotation3D?: Vector3, scale3D?: Vector3, properties?: {
+        [x: string]: any;
+    }): any;
     /**
      * An instance of a prefab, what a prefab's type makes: a handle with no shape of its own, and its parts, what the
      * prefab's objects made
@@ -10825,7 +11099,7 @@ declare module "littlejsengine" {
         /** @property {Object} - The three.js perspective camera */
         camera: any;
         /** @property {boolean} - Lock the camera to the LittleJS 2D camera so the z=0 plane matches world space */
-        cameraAlign2D: boolean;
+        cameraAlign2D: boolean | undefined;
         /** @property {number|undefined} - Near plane of the aligned camera before any zoom out, from camera.near on the
          *  first aligned frame; while aligned, change this rather than camera.near
          *  @type {number|undefined} */
@@ -10907,9 +11181,9 @@ declare module "littlejsengine" {
         /** @property {number} - Width and height of the sheet in pixels */
         size: number;
         /** @property {OffscreenCanvasRenderingContext2D} - 2d context for the canvas */
-        context: OffscreenCanvasRenderingContext2D;
+        context: OffscreenCanvasRenderingContext2D | undefined;
         /** @property {OffscreenCanvas} - Canvas holding the packed images */
-        canvas: OffscreenCanvas;
+        canvas: OffscreenCanvas | undefined;
         /** @property {TextureInfo} - The texture info for this sheet */
         textureInfo: TextureInfo;
         /** @property {Vector2} - Where the next image will be packed */
@@ -10941,7 +11215,8 @@ declare module "littlejsengine" {
      *  - Pass frameSize for animations, then step through them with TileInfo.frame
      *  - Grid images keep their layout and frames wrap down to the next row
      *  - Pass sourcePadding if the source image has padding baked in around frames
-     *  - The same image loaded again with the same settings gives back what the first load did, packed once
+     *  - The same image loaded again with the same settings gives back what the first load did, packed once, unless
+     *    that load failed
      *  @param {string} src - Image source path
      *  @param {Vector2|number} [frameSize] - Size of each animation frame in pixels, or the whole image less its
      *  source padding if not passed
@@ -10952,7 +11227,7 @@ declare module "littlejsengine" {
      *  const playerTile = loadSprite('player.png');     // a single sprite
      *  const runTile = loadSprite('run.png', vec2(16)); // a 16x16 frame animation
      *  @memberof TextureSheets */
-    export function loadSprite(src: string, frameSize?: Vector2 | number, padding?: number, sourcePadding?: number | Vector2): TileInfo;
+    export function loadSprite(src: string, frameSize?: number | Vector2, padding?: number, sourcePadding?: number | Vector2): TileInfo;
     /** Load tile images and pack them into texture sheets as one tile set, for tile layers and maps
      *  - Each image is cut into tiles of tileSize, left to right then down, so an image of one tile is one tile and a
      *    sheet is all of its tiles; the tiles are numbered from 0 in the order the images are given
@@ -10964,7 +11239,8 @@ declare module "littlejsengine" {
      *    is not read, cut it into its tiles first
      *  - An image that fails to load, or that no sheet can hold, adds no tiles and says so in the console, so the tiles
      *    of the images after it move up
-     *  - The same images loaded again with the same settings give back what the first load did, packed once
+     *  - The same images loaded again with the same settings give back what the first load did, packed once, unless
+     *    an image of it failed
      *  @param {Array<string>} sources - Image source paths
      *  @param {Vector2|number} [tileSize] - Size of a tile in pixels
      *  @param {number} [padding] - How many pixels padding around each tile on the sheet
@@ -10974,7 +11250,7 @@ declare module "littlejsengine" {
      *  await spritesReady();
      *  tileLayersLoad(map, tiles); // tile 0 is grass, 1 dirt, 2 water, then the tiles of props.png
      *  @memberof TextureSheets */
-    export function loadTiles(sources: Array<string>, tileSize?: Vector2 | number, padding?: number): TileInfo;
+    export function loadTiles(sources: Array<string>, tileSize?: number | Vector2, padding?: number): TileInfo;
     /** Load a pre-packed texture atlas and repack it onto texture sheets
      *  - Supports TexturePacker json (hash and array) and Aseprite json
      *  - Returns an empty object which is filled with TileInfos when loaded
@@ -10982,7 +11258,8 @@ declare module "littlejsengine" {
      *  - Aseprite frame tags become animations, so do names like run_0, run_1
      *  - Trimmed frames are restored to their full source size when packed
      *  - Rotated frames are rotated back upright when packed
-     *  - The same atlas loaded again by its paths, with the same padding, gives back what the first load did, packed once
+     *  - The same atlas loaded again by its paths, with the same padding, gives back what the first load did, packed
+     *    once, unless that load failed
      *  @param {string} imageSrc - Atlas image path
      *  @param {string|Object} jsonSrc - Atlas json path, or already parsed json data
      *  @param {number} [padding] - How many pixels padding around each frame
@@ -11077,10 +11354,10 @@ declare module "littlejsengine" {
         }[];
     };
     /** A copy of an effect with its four colors turned around the color wheel and their saturation scaled; lightness and
-     *  alpha stay, and grey and white have no hue to turn
+     *  alpha stay, and gray and white have no hue to turn
      *  @param {Object} effect
      *  @param {number} [hue] - How far around the wheel, 1 is all the way
-     *  @param {number} [saturation] - Multiplies the saturation, 0 is grey, clamped to 1
+     *  @param {number} [saturation] - Multiplies the saturation, 0 is gray, clamped to 1
      *  @return {Object}
      *  @memberof ParticleEffects */
     export function particleEffectRecolor(effect: any, hue?: number, saturation?: number): any;
@@ -11124,7 +11401,7 @@ declare module "littlejsengine" {
      *  @param {Object} [options] - What to change for this play, each left out when not wanted:
      *    scale grows the whole effect, the built-ins fit a one unit object at 1;
      *    hue turns its colors around the color wheel, 1 is all the way;
-     *    saturation multiplies its saturation, 0 is grey;
+     *    saturation multiplies its saturation, 0 is gray;
      *    angle is its direction, 0 is up, the effect's own angle when not given;
      *    tileInfo, a TileInfo or a TextureInfo, is the game's own art to draw with in place of the effect's shape,
      *    tinted by its colors, a whole texture drawn as one tile;