littlejsengine 1.24.3 → 1.26.0

package/dist/littlejs.d.ts

@@ -85,9 +85,53 @@ declare module "littlejsengine" {
      */
     export type SpriteAnimationEndCallback = () => void;
     /**
-     * - Function called when sound is loaded
+     * - Function called once a sound has loaded, or failed to, which sound.isLoaded() tells
      */
     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
      */
@@ -143,6 +191,7 @@ declare module "littlejsengine" {
         reflectivity: number;
         emissiveMap: TextureInfo | undefined;
         emissiveMapColor: Color;
+        environmentMap: CubeMap | undefined;
         emissiveR: number;
         emissiveG: number;
         emissiveB: number;
@@ -234,10 +283,70 @@ 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,
+         * skyBox, environment
+         */
+        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 +356,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 +372,7 @@ declare module "littlejsengine" {
         /**
          * - 3D: the mouse's Ray3D
          */
-        ray: any;
+        ray: Ray3D | undefined;
         /**
          * - Is Shift held
          */
@@ -273,9 +383,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 +399,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
@@ -535,7 +646,7 @@ declare module "littlejsengine" {
      *  @param {GameCallback} [gameUpdatePost] - Called after physics and objects are updated, even when paused, use for UI updates
      *  @param {GameCallback} [gameRender] - Called before objects are rendered, use for drawing backgrounds/world elements
      *  @param {GameCallback} [gameRenderPost] - Called after objects are rendered, use for drawing UI/overlays
-     *  @param {Array<string>} [imageSources=[]] - List of image file paths to preload (e.g., ['player.png', 'tiles.png'])
+     *  @param {Array<string>|string} [imageSources=[]] - List of image file paths to preload (e.g., ['player.png', 'tiles.png']), or one path
      *  @param {HTMLElement} [rootElement] - Root DOM element to attach canvas to, defaults to document.body
      *    It keeps its own inline styles and the canvas centers inside it, but the canvas is still sized from the window,
      *    so set canvasFixedSize or canvasMaxSize to fit a smaller element
@@ -549,8 +660,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?: 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 | 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
@@ -560,7 +672,7 @@ declare module "littlejsengine" {
      *  setHeadlessMode(true);
      *  setEngineManualStep(true);
      *  await engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost);
-     *  engineStep(600); // advance 10 seconds of game time
+     *  engineStep(600); // 600 updates of 1/60 second; the first is at time 0, so time is then 599/60
      *  @memberof Engine */
     export function engineStep(frames?: number): void;
     /** Update each engine object and remove destroyed objects; time and frame are advanced by the engine loop, not here
@@ -637,7 +749,7 @@ declare module "littlejsengine" {
      * - setDebugKeysAlways lets those keys work with the overlay closed too
      * - ASSERT and LOG macros for development (removed in release builds)
      * - Debug primitive rendering (rectangles, circles, lines, points, text)
-     * - Screenshot and video capture support
+     * - Screenshot support
      * - FPS counter and performance watermark
      * - Debug overlay shows mouse position and picked objects
      * @namespace Debug
@@ -688,7 +800,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 +815,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 +932,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 +948,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;
@@ -890,15 +1006,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,7 +1039,7 @@ 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]
@@ -998,15 +1115,6 @@ declare module "littlejsengine" {
      *  In release builds this function has no effect
      *  @memberof Debug */
     export function debugShowErrors(): void;
-    /** Start capturing video
-     *  @memberof Debug */
-    export function debugVideoCaptureStart(): void;
-    /** Stop capturing video and save to disk
-     *  @memberof Debug */
-    export function debugVideoCaptureStop(): void;
-    /** Check if video capture is active
-     *  @memberof Debug */
-    export function debugVideoCaptureIsActive(): boolean;
     /**
      * LittleJS Engine Settings
      * - All settings for the engine are here
@@ -1388,6 +1496,7 @@ declare module "littlejsengine" {
     export function setCameraScale(scale: number): void;
     /** Set scale applied to engine time
      *  - 0 freezes the game like a pause, gameUpdatePost and input still run so the game can set it back
+     *  - Above 1 the fixed step runs that many updates each frame, so a large scale costs as many updates
      *  @param {number} scale - 0 or more
      *  @memberof Settings */
     export function setTimeScale(scale: number): void;
@@ -1447,6 +1556,7 @@ declare module "littlejsengine" {
      *  @memberof Settings */
     export function getCanvasPixelRatio(): number;
     /** Set default font used for text rendering
+     *  - A family name with spaces or digits goes in quotes, as "'Press Start 2P'", or the canvas does not take it
      *  @param {string} font
      *  @memberof Settings */
     export function setFontDefault(font: string): void;
@@ -1616,7 +1726,8 @@ declare module "littlejsengine" {
      *  @param {boolean} enable
      *  @memberof Settings */
     export function setVibrateEnable(enable: boolean): void;
-    /** Set if audio is enabled, false turns all sound off
+    /** Set if audio is enabled, false turns all sound off; a setting for before sounds are made, since a sound made
+     *  while it is off has nothing to play and one already playing goes on; to mute while the game runs, setSoundVolume(0)
      *  @param {boolean} enable
      *  @memberof Settings */
     export function setSoundEnable(enable: boolean): void;
@@ -1719,7 +1830,7 @@ declare module "littlejsengine" {
      *  @param {...number} values
      *  @return {number}
      *  @memberof Math */
-    export function hypot(...values: number[]): number;
+    export const hypot: (...values: number[]) => number;
     /** Returns log2 of value passed in
      *  @param {number} x
      *  @return {number}
@@ -1898,9 +2009,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]
@@ -1957,7 +2068,7 @@ declare module "littlejsengine" {
      *  @return {number}
      *  @memberof Utilities */
     export function noise1D(x: number): number;
-    /** 2D value noise — returns a smooth value in [0, 1] for any real (x, y).
+    /** 2D value noise — returns a smooth value in [0, 1] for any real (x, y)
      *  @param {number} x
      *  @param {number} y
      *  @return {number}
@@ -2512,7 +2623,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
@@ -2805,6 +2916,11 @@ declare module "littlejsengine" {
         /** @property {WebGLProgram|undefined} - The 3D program, compiled by the 3D plugin the same way, read only
          *  @type {WebGLProgram|undefined} */
         program3D: WebGLProgram | undefined;
+        /** Let go of this shader: its compiled programs are freed and it leaves the engine's list of shaders, which
+         *  keeps every one made for a lost context, so a scene made again and again, or an editor trying snippets, does
+         *  not keep them all; calling it again does nothing, and a draw with it afterwards compiles it again and takes it
+         *  back, so only let go of one no object still draws with when it should stay freed */
+        dispose(): void;
     }
     /**
      * LittleJS Drawing System
@@ -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,9 +3065,9 @@ 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?
@@ -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,7 +3201,7 @@ 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]
@@ -3120,7 +3236,7 @@ declare module "littlejsengine" {
     export function setShader(shader?: Shader): void;
     /** Set an extra canvas to composite behind the engine canvases when combining
      *  Plugins that insert their own canvas below the LittleJS canvases should set
-     *  this so it appears in screenshots and video capture
+     *  this so it appears in screenshots
      *  @param {HTMLCanvasElement} [canvas]
      *  @memberof Draw */
     export function setBackgroundCanvas(canvas?: HTMLCanvasElement): void;
@@ -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 */
@@ -3647,7 +3760,6 @@ declare module "littlejsengine" {
      *  - The output node is disconnected from everything else first, so it only feeds the speakers
      *  - The two ends of a chain must already be connected to each other, like effectA.connect(effectB)
      *  - Call with no arguments to remove the effect, an effect that was the master goes back to feeding the master gain
-     *  - Debug video capture records the end of the master chain, but loses its tap if the effect changes mid-capture
      *  @param {AudioNode|AudioEffectNodes} [input] - Node or effect the master gain connects to
      *  @param {AudioNode|AudioEffectNodes} [output] - Node or effect that connects to the audio destination, defaults to the input's output
      *  @memberof Audio */
@@ -3661,7 +3773,7 @@ declare module "littlejsengine" {
      *  @memberof Audio */
     export function audioIsRunning(): boolean;
     /**
-     * @callback SoundLoadCallback - Function called when sound is loaded
+     * @callback SoundLoadCallback - Function called once a sound has loaded, or failed to, which sound.isLoaded() tells
      * @param {Sound} sound
      * @memberof Audio
      */
@@ -3686,13 +3798,14 @@ 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
+         *  @param {SoundLoadCallback} [onloadCallback] - Called once the sound has loaded, or its file failed to, so a
+         *    game counting its sounds goes on; isLoaded says which
          */
-        constructor(asset?: string | any[] | URL, 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
@@ -3780,7 +3893,7 @@ declare module "littlejsengine" {
          *  @return {boolean} - True if sound is loaded and ready to play
          */
         isLoaded(): boolean;
-        /** Loads a sound from a URL and decodes it into sample data.
+        /** Loads a sound from a URL and decodes it into sample data
         *  @param {string} filename
         *  @return {Promise} */
         loadSound(filename: string): Promise<any>;
@@ -3812,11 +3925,11 @@ declare module "littlejsengine" {
         /** @property {Sound} - The sound object */
         sound: Sound;
         /** @property {number} - How much to scale volume by */
-        volume: number;
+        volume: any;
         /** @property {number} - The playback rate to use */
-        rate: number;
+        rate: any;
         /** @property {number} - How much to apply stereo panning */
-        pan: number;
+        pan: any;
         /** @property {boolean} - Should the sound loop */
         loop: boolean;
         /** @property {number|undefined} - Where it is in the sound while not playing, in the sound's own seconds, undefined while playing
@@ -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;
@@ -3969,8 +4082,8 @@ declare module "littlejsengine" {
      *  @param {number}  [release] - Release time, how fast sound fades out (seconds)
      *  @param {number}  [shape] - Shape of the sound wave
      *  @param {number}  [shapeCurve] - Squareness of wave (0=square, 1=normal, 2=pointy)
-     *  @param {number}  [slide] - How much to slide frequency (kHz/s)
-     *  @param {number}  [deltaSlide] - How much to change slide (kHz/s/s)
+     *  @param {number}  [slide] - How much to slide frequency, 1 is about 500 Hz a second, as ZzFX has it
+     *  @param {number}  [deltaSlide] - How much to change slide each second, in the units of slide
      *  @param {number}  [pitchJump] - Frequency of pitch jump (Hz)
      *  @param {number}  [pitchJumpTime] - Time of pitch jump (seconds)
      *  @param {number}  [repeatTime] - Resets some parameters periodically (seconds)
@@ -3981,7 +4094,8 @@ declare module "littlejsengine" {
      *  @param {number}  [sustainVolume] - Volume level for sustain (percent)
      *  @param {number}  [decay] - Decay time, how long to reach sustain after attack (seconds)
      *  @param {number}  [tremolo] - Trembling effect, rate controlled by repeat time (percent)
-     *  @param {number}  [filter] - Filter cutoff frequency, positive for HPF, negative for LPF (Hz)
+     *  @param {number}  [filter] - Filter cutoff, positive for HPF, negative for LPF; the cutoff is about twice this in
+     *    Hz, as ZzFX has it, and its resonance can take the samples past 1
      *  @return {Float32Array} - The audio samples
      *  @memberof Audio */
     export function zzfxG(volume?: number, randomness?: number, frequency?: number, attack?: number, sustain?: number, release?: number, shape?: number, shapeCurve?: number, slide?: number, deltaSlide?: number, pitchJump?: number, pitchJumpTime?: number, repeatTime?: number, noise?: number, modulation?: number, bitCrush?: number, delay?: number, sustainVolume?: number, decay?: number, tremolo?: number, filter?: number): Float32Array;
@@ -4054,6 +4168,9 @@ declare module "littlejsengine" {
         shader: Shader | undefined;
         /** @property {boolean} - Does this object draw into the light system's shadow map; false for a floor layer, a background, a pickup */
         castShadow: boolean;
+        /** @property {boolean} - Does this object draw into the light system's background map, which a
+         *  DirectionalLight lights only at its edges facing the light; for a background layer, with castShadow false */
+        castBackgroundShadow: boolean;
         /** @property {number} - With the light system, how much it lights itself: 0 lit only by the lights, 1 full
          *  brightness in its own colors whatever the lights do, between partly; drawn into the lightmap through
          *  renderEmissive, as 3D's emissive. Exact for solid pixels; a partly transparent one is self lit by its alpha
@@ -4117,15 +4234,19 @@ declare module "littlejsengine" {
         /** Update the object transform, called automatically by engine even when paused
          *  @param {boolean} [updateChildren] - Also update the children's transforms */
         updateTransforms(updateChildren?: boolean): void;
-        /** Update the object physics, called automatically by engine once each frame. Can be overridden to stop or change how physics works for an object. */
+        /** Update the object physics, called automatically by engine once each frame. Can be overridden to stop or change how physics works for an object
+         *  - With many solids each mover finds those near it through a grid, which follows a solid after its own physics
+         *    update: a solid an override moves for another object, a lift carrying a crate, is found there from the next
+         *    update on */
         updatePhysics(): void;
-        /** Update the object, called automatically by engine once each frame. Does nothing by default. */
+        /** Update the object, called automatically by engine once each frame. Does nothing by default */
         update(): void;
         /** Render the object, draws a tile by default, automatically called each frame, sorted by renderOrder */
         render(): void;
-        /** Optional hook called during the light system plugin's lightmap pass to draw this object's lightmap contribution. Does nothing by default. */
+        /** Optional hook called during the light system plugin's lightmap pass to draw this object's lightmap contribution. Does nothing by default */
         renderLight(): void;
-        /** Draw this object into the light system's shadow map, called during its shadow pass when castShadow is set.
+        /** Draw this object into the light system's shadow map, called during its shadow pass when castShadow is set, and into
+         *  its background map when castBackgroundShadow is set and a DirectionalLight is out.
          *  Calls render() by default so the object casts its own shape; override to cast a different one, like a blob at a character's feet so its body stays lit;
          *  screen space WebGL draws in render() are skipped during the pass */
         renderShadow(): void;
@@ -4137,30 +4258,38 @@ 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 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
          *    positions it only tries, so keep it free of side effects or guard them to once a frame
          *  - this.pos has already moved, so a check on where it came from, like a one way platform, needs the position
          *    saved in update, as the platformer example does
+         *  - For the point of impact, like sparks where a bullet hit, raycast from where this frame's move started,
+         *    this.pos minus this.velocity, to this.pos with tileCollisionRaycast, as the platformer's Bullet does
          *  @param {number}  tileData - the value of the tile at the position
          *  @param {Vector2} pos - the tile's bottom left corner in world space
          *  @return {boolean} - true if the collision should be resolved by modifying it's position and velocity */
         collideWithTile(tileData: number, pos: Vector2): boolean;
-        /** Called by the engine to check if an object collision should be resolved. Return true for physics to resolve the collision or false to ignore and resolve it manually.
+        /** Called by the engine to check if an object collision should be resolved. Return true for physics to resolve the collision or false to ignore and resolve it manually
          *  - Both objects of a touching pair are asked once a frame, whichever order they update in; an object that
          *    destroys itself here is gone at the end of the frame and is still asked about the pairs left this frame, so a
          *    bullet that should hit one thing checks its own destroyed flag first
+         *  - With many solids each mover finds those near it through a grid, which follows the other object after this
+         *    returns; a third object moved here is found where it is now from the next update on
          *  @param {EngineObject} object - the object to test against
          *  @param {Vector3} [push] - what it would take to move this object clear, a Vector3 from the 3D plugin, undefined in 2D
          *  @return {boolean} - true if the collision should be resolved by modifying it's position and velocity
@@ -4224,10 +4353,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 +4368,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 +4423,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 +4441,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 +4449,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?: string | number, 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 +4470,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?: string | number): 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 +4486,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 +4502,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 +4521,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 +4529,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;
@@ -4421,7 +4569,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 */
@@ -4489,7 +4637,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
@@ -4616,13 +4764,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 {
@@ -4645,7 +4793,7 @@ declare module "littlejsengine" {
          *  @param {number} [angleSpeed]        - How fast are particles rotating, in radians per frame (at 60fps)
          *  @param {number} [damping]           - How much to dampen particle speed, per-frame velocity multiplier (1 = no damping, .9 = lose 10% speed each frame)
          *  @param {number} [angleDamping]      - How much to dampen particle angular speed, per-frame multiplier (1 = no damping)
-         *  @param {number} [gravityScale]      - How much gravity effect particles
+         *  @param {number} [gravityScale]      - How much gravity affects particles
          *  @param {number} [particleConeAngle] - Half angle each side of the emitter's angle for a particle's start angle, PI is any angle
          *  @param {number} [fadeRate]          - Fraction of life spent fading: half at fade-in (start), half at fade-out (end). e.g. .2 = 10% fade-in, 80% full opacity, 10% fade-out
          *  @param {number} [randomness]    - Apply extra randomness percent
@@ -4660,7 +4808,8 @@ declare module "littlejsengine" {
         emitCircle: boolean;
         /** @property {Vector2} - World space size of the emitter, x is the diameter when emitCircle is set */
         emitSize: Vector2;
-        /** @property {number} - How long to stay alive (0 is forever) */
+        /** @property {number} - How long to emit for in seconds, 0 is forever; raised while its particles are still
+         *  alive, it emits again for the added time */
         emitTime: number;
         /** @property {number} - How many particles per second to spawn, does not emit if 0 */
         emitRate: number;
@@ -4721,16 +4870,22 @@ declare module "littlejsengine" {
         velocityInheritance: number;
         /** @property {number} - Particles owed to the emit rate, starts at one so the first comes out at once */
         emitTimeBuffer: number;
+        /** @property {number} - Seconds of its emit time it has emitted for, counted by its updates
+         *  @type {number} */
+        emitElapsed: number;
         /** @property {Array<Particle>} - Array of particles for this emitter
          *  @type {Array<Particle>} */
         particles: Array<Particle>;
         /** @type {Vector2|undefined} */
         previousPos: Vector2 | undefined;
         previousAngle: number;
+        emitFrom: Vector2;
+        emitBehind: number;
         /** Spawn one particle
          *  @return {Particle} */
         emitParticle(): Particle;
-        /** is emitter actively spawning */
+        /** is emitter actively spawning
+         *  @return {boolean} */
         isActive(): boolean;
     }
     /**
@@ -4829,6 +4984,7 @@ declare module "littlejsengine" {
      *  - Call this after creating all medals
      *  - Loads which medals are unlocked from the save, and writes the catalog back
      *  - A medal a service like Newgrounds holds is left as it is, see Medal.isLocal
+     *  - A medal unlocked before the first call stays unlocked and is saved by it
      *  @param {string} saveName - The localStorage key the medals are kept under, a different one from the game's own
      *  readSaveData and writeSaveData, or each would overwrite the other
      *  @memberof Medals */
@@ -4960,10 +5116,12 @@ declare module "littlejsengine" {
         cryptoKey: CryptoKey | undefined;
         /** @property {string} - Hostname sent with the view the plugin logs when it starts */
         host: string;
-        /** @property {Array} - Medals fetched from Newgrounds, empty until ready, with the unlocks only when logged in */
-        medals: any[];
-        /** @property {Array} - Scoreboards fetched from Newgrounds, empty until ready */
-        scoreboards: any[];
+        /** @property {Array<Object>} - Medals fetched from Newgrounds, empty until ready, with the unlocks only when logged in
+         *  @type {Array<Object>} */
+        medals: Array<any>;
+        /** @property {Array<Object>} - Scoreboards fetched from Newgrounds, empty until ready
+         *  @type {Array<Object>} */
+        scoreboards: Array<any>;
         /** @property {{id: number, name: string, url: string, supporter: boolean}|null} - The logged in player once ready, null when not logged in
          *  @type {{id: number, name: string, url: string, supporter: boolean}|null} */
         user: {
@@ -4980,8 +5138,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;
@@ -5041,6 +5197,123 @@ declare module "littlejsengine" {
          *  @type {number|undefined} */
         value: number | undefined;
     }
+    /**
+     * LittleJS Wavedash Plugin
+     * - The Wavedash twin of the Newgrounds plugin: achievements and leaderboards, the same shape so a game can switch
+     * - Wavedash serves the game's page and puts its SDK in window.Wavedash before the game runs, so nothing is bundled;
+     *   off Wavedash (local, itch, GitHub Pages) there is none, and every call does nothing
+     * - Make the plugin when the game can draw, at the end of gameInit: Wavedash.init is called then, and until it is
+     *   Wavedash keeps its loading screen over the game
+     * - WavedashMedal is a Medal with the identifier of its Wavedash achievement; on Wavedash an unlock is sent as that
+     *   achievement and Wavedash shows its own toast in place of the engine's popup, off it the medal unlocks as any does
+     * - Wavedash refuses an achievement until it has loaded the player's, a moment after launch, so refused and earlier
+     *   unlocks are sent again every two seconds until it takes them; medals unlocked before, in the save, are sent too
+     * - Leaderboards are made from code: give the plugin a table of them, each with how it sorts and shows its scores,
+     *   and they are made at once, so each one exists from the first launch
+     * - The SDK checks its arguments' types and throws on a wrong one, so every call passes real booleans and whole
+     *   numbers and is caught; a game built with its own minifier keeps the SDK's names, see REFERENCE
+     * @namespace Wavedash
+     */
+    /** Global Wavedash plugin object
+     *  @type {WavedashPlugin}
+     *  @memberof Wavedash */
+    export let wavedash: WavedashPlugin;
+    /**
+     * Wavedash plugin: starts the Wavedash SDK, sends achievements and posts and reads leaderboards
+     * @memberof Wavedash
+     * @example
+     * // at the end of gameInit, with the leaderboards the game posts to
+     * new WavedashPlugin({LEVEL_1: {lowerWins: true, display: 'milliseconds'}, HIGH_SCORE: {}});
+     * wavedash.postScore('LEVEL_1', timeMs);
+     */
+    export class WavedashPlugin {
+        /** Start the Wavedash SDK when the game is on Wavedash, and make its leaderboards
+         *  @param {Object<string, {lowerWins?: boolean, display?: string}>} [leaderboards] - The game's leaderboards by
+         *    name: lowerWins for times and golf, where a lower score is better, higher wins when left out; display how
+         *    Wavedash shows a score, 'number', 'seconds', 'milliseconds' or 'ticks' (60 a second), 'number' when left out
+         */
+        constructor(leaderboards?: {
+            [x: string]: {
+                lowerWins?: boolean;
+                display?: string;
+            };
+        });
+        /** @property {Object<string, Promise<string|undefined>>} - Each leaderboard's id by its name, once Wavedash
+         *  has made or found it, undefined when it could not
+         *  @type {Object<string, Promise<string|undefined>>} */
+        leaderboards: {
+            [x: string]: Promise<string | undefined>;
+        };
+        /** @type {Object<string, {lowerWins?: boolean, display?: string}>} */
+        leaderboardSettings: {
+            [x: string]: {
+                lowerWins?: boolean;
+                display?: string;
+            };
+        };
+        /** @type {Set<string>} */
+        achievementsSent: Set<string>;
+        /** @type {Object<string, number>} */
+        achievementTries: {
+            [x: string]: number;
+        };
+        /** @type {number|undefined} */
+        achievementRetry: number | undefined;
+        /** Whether the game is on Wavedash, its SDK on the page
+         *  @return {boolean} */
+        isActive(): boolean;
+        /** Call the SDK, undefined off Wavedash; a call that throws, as on an argument of the wrong type, says so in
+         *  the console and gives undefined
+         *  @param {string} name - The SDK function
+         *  @param {...*} args
+         *  @return {*}
+         *  @ignore */
+        call(name: string, ...args: any[]): any;
+        /** A leaderboard's id by its name, made on Wavedash the first time it is asked for, with the settings it was given
+         *  @param {string} name
+         *  @return {Promise<string|undefined>}
+         *  @ignore */
+        leaderboard(name: string): Promise<string | undefined>;
+        /** Post a score to a leaderboard, Wavedash keeping the player's best; off Wavedash it does nothing
+         *  - A leaderboard not in the table given to the plugin is made the first time, higher wins and shown as a number
+         *  @param {string} name - The leaderboard's name
+         *  @param {number} score - A whole number, milliseconds for a time
+         *  @return {Promise<boolean>} - Whether it was posted */
+        postScore(name: string, score: number): Promise<boolean>;
+        /** Read a leaderboard's entries, undefined off Wavedash or when it could not be read
+         *  @param {string} name - The leaderboard's name
+         *  @param {number} [offset] - How many entries to skip over
+         *  @param {number} [limit] - How many entries to read
+         *  @param {boolean} [friendsOnly] - Only the player and their friends
+         *  @return {Promise<Array<Object>|undefined>} - The entries, as Wavedash gives them */
+        getScores(name: string, offset?: number, limit?: number, friendsOnly?: boolean): Promise<Array<any> | undefined>;
+        /** Send every unlocked WavedashMedal's achievement Wavedash has not taken yet, again every two seconds while it
+         *  refuses some, as it does until it has loaded the player's achievements; one refused for about a minute is
+         *  taken as an identifier Wavedash does not have, said once in the console, and not sent again this visit
+         *  @ignore */
+        sendAchievements(): void;
+    }
+    /**
+     * WavedashMedal: a medal that is also a Wavedash achievement, unlocked on Wavedash by its identifier
+     * @extends Medal
+     * @memberof Wavedash
+     * @example
+     * const medal_finish = new WavedashMedal(0, 'ACH_01_FINISH', 'Finish', 'Finish a level');
+     * medal_finish.unlock(); // Wavedash's toast on Wavedash, the engine's popup anywhere else
+     */
+    export class WavedashMedal extends Medal {
+        /** Create a WavedashMedal and add it to the list of medals
+         *  @param {number} id            - The unique identifier of the medal, as for any Medal
+         *  @param {string} achievement   - The identifier of its Wavedash achievement, as made with the Wavedash CLI
+         *  @param {string} name          - Name of the medal
+         *  @param {string} [description] - Description of the medal
+         *  @param {string} [icon]        - Icon for the medal
+         *  @param {string} [src]         - Image location for the medal
+         */
+        constructor(id: number, achievement: string, name: string, description?: string, icon?: string, src?: string);
+        /** @property {string} - The identifier of its Wavedash achievement */
+        achievement: string;
+    }
     /**
      * LittleJS Post Processing Plugin
      * - Supports shadertoy style post processing shaders
@@ -5077,6 +5350,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 +5381,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 +5391,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 +5418,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
@@ -5233,6 +5546,8 @@ declare module "littlejsengine" {
      *   setShadowTransparent lets its color tint the light
      * - Set light.glow for a soft hazy glow over a light, like a lamp at night; it is added over the lit scene after the
      *   lightmap, so it shows in the dark and sits in front of everything there
+     * - A DirectionalLight is a sun: one per scene, it lights everything from one direction, foreground casters throw long
+     *   shadows and objects with castBackgroundShadow are lit only at their edges facing it
      * - Must be constructed BEFORE PostProcessPlugin so post-process sees lit pixels
      * @namespace LightSystem
      */
@@ -5250,7 +5565,7 @@ declare module "littlejsengine" {
      * @memberof LightSystem
      */
     export class LightSystemPlugin {
-        /** Create the global light system plugin.
+        /** Create the global light system plugin
          *  @param {Vector2} [textureSize]  - Size of the lightmap texture (defaults to following mainCanvasSize, which is css pixels, so the lightmap is not scaled by canvasPixelRatio; pass mainCanvasSize.scale(getCanvasPixelRatio()) for a full resolution lightmap)
          *  @param {Color}   [ambientColor] - Color applied to unlit areas of the scene (defaults to BLACK = pitch dark). Set a small RGB like rgb(0.1,0.1,0.15) for a faint "moonlight" baseline so unlit areas aren't fully black.
          *  @example
@@ -5260,6 +5575,7 @@ declare module "littlejsengine" {
         constructor(textureSize?: Vector2, ambientColor?: Color);
         /** @property {boolean} - When false, the render pass is skipped entirely */
         enabled: boolean;
+        shadersFailed: boolean;
         /** @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 */
@@ -5303,6 +5619,10 @@ declare module "littlejsengine" {
         /** @property {WebGLTexture|undefined} - The shadow map, casters drawn black on white around the camera, read only
          *  @type {WebGLTexture|undefined} */
         shadowMap: WebGLTexture | undefined;
+        /** @property {WebGLTexture|undefined} - The background map, objects with castBackgroundShadow drawn black on
+         *  white, the shadow map's size and place, made by a directional light when something casts into it and kept while the light is, read only
+         *  @type {WebGLTexture|undefined} */
+        backgroundMap: WebGLTexture | undefined;
         /** @property {WebGLTexture|undefined} - One of the two textures each light's shadow is built in
          *  @type {WebGLTexture|undefined} */
         shadowTextureA: WebGLTexture | undefined;
@@ -5328,6 +5648,26 @@ declare module "littlejsengine" {
         shadowMapOrigin: Vector2;
         /** @property {number} - World size the shadow map covers, set each shadow pass */
         shadowMapWorldSize: number;
+        /** @property {DirectionalLight|undefined} - The scene's directional light, a sun, or undefined, read only
+         *  @type {DirectionalLight|undefined} */
+        directionalLight: DirectionalLight | undefined;
+        /** @property {number} - Pixels across the square textures a directional light is built in, covering the
+         *  shadow map's area; larger is sharper and slower; a power of two, as shadowMapSize, so their texels line up */
+        directionalTextureSize: number;
+        /** @property {WebGLTexture|undefined} - The directional light as built this frame, white where it reaches,
+         *  over the shadow map's area, read only
+         *  @type {WebGLTexture|undefined} */
+        directionalTexture: WebGLTexture | undefined;
+        /** @type {WebGLTexture|undefined} */
+        directionalTextureA: WebGLTexture | undefined;
+        /** @type {WebGLTexture|undefined} */
+        directionalTextureB: WebGLTexture | undefined;
+        directionalTextureSizeAllocated: number;
+        backgroundCasters: boolean;
+        /** @type {Object<string, WebGLProgram|WebGLVertexArrayObject>} */
+        directionalPrograms: {
+            [x: string]: WebGLProgram | WebGLVertexArrayObject;
+        };
         shadowMapSizeAllocated: number;
         shadowTextureSizeAllocated: number;
         /** Bring the sizes of the textures it makes down to what the device can make: shadowMapSize, shadowTextureSize
@@ -5392,6 +5732,34 @@ declare module "littlejsengine" {
          *  called by LightSystemPlugin after the lightmap is applied */
         renderGlow(): void;
     }
+    /**
+     * A DirectionalLight is a sun for the 2D light system: it lights the whole scene from one direction, added into the
+     * lightmap with the point lights
+     * - One at a time, made after the LightSystemPlugin, lightSystem.directionalLight is the one; a debug build asserts on
+     *   a second while the first lives, a release build destroys the first
+     * - Its castShadow lets foreground casters, objects with castShadow, throw long shadows across open space, fading out
+     *   by shadowLength; a light does not need lightSystem.shadows for that
+     * - Objects with castBackgroundShadow, a background layer, are dark to it inside and lit at the edges that face it,
+     *   fading in by backgroundDepth
+     * @extends EngineObject
+     * @memberof LightSystem
+     * @example
+     * new DirectionalLight(vec2(-1, 1), hsl(.1, .3, 1)); // a warm sun up and to the left, shining down and to the right
+     */
+    export class DirectionalLight extends EngineObject {
+        /** Create the scene's directional light
+         *  @param {Vector2} [sunDirection] - Toward the sun, it shines the other way, as render3D.sunDirection
+         *  @param {Color} [color] - Color of the light; alpha modulates intensity */
+        constructor(sunDirection?: Vector2, color?: Color);
+        /** @property {Vector2} - Toward the sun, it shines the other way, as render3D.sunDirection */
+        sunDirection: Vector2;
+        /** @property {number} - World units a long shadow reaches before it has faded out; a caster casts only from
+         *  inside the shadow map, shadowMapScale views across, so past (shadowMapScale - 1) / 2 of a view beyond the
+         *  screen it throws none in */
+        shadowLength: number;
+        /** @property {number} - World units the light gets into a background area from its edges facing it */
+        backgroundDepth: number;
+    }
     /**
      * LittleJS Audio Effects Plugin
      * - Web Audio effects with a wet/dry mix: filter, reverb, delay, distortion, compressor
@@ -5606,6 +5974,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,24 +6121,19 @@ 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?: "center" | "left" | "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
-         */
         /** 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} */
@@ -5882,6 +6250,7 @@ declare module "littlejsengine" {
         textLineWidth: number;
         /** @property {boolean} - Should this object be drawn */
         visible: boolean;
+        uiUpdatePass: number;
         /** @property {Array<UIObject>} - A list of this object's children
          *  @type {Array<UIObject>} */
         children: Array<UIObject>;
@@ -5951,15 +6320,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} */
@@ -6023,7 +6397,7 @@ declare module "littlejsengine" {
          *  @param {string}  [text]
          */
         constructor(pos?: Vector2, size?: Vector2, text?: string);
-        /** @property {number} - Max length of input (0 = no limit) */
+        /** @property {number} - Max length of input in characters as a reader counts them (0 = no limit) */
         maxLength: number;
         text: string;
         /** Stop editing the text */
@@ -6132,9 +6506,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 */
@@ -6196,10 +6570,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 */
@@ -6338,23 +6712,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;
     }
     /**
@@ -6363,6 +6743,10 @@ declare module "littlejsengine" {
      * - Provides interface for Box2D body and fixture functions
      * - Each object can have multiple fixtures and joints
      * - Angular values are clockwise like angle: angular velocity, torque, joint angles, limits and motor speeds
+     * - Box2D moves the body, so the EngineObject physics fields do nothing on it: velocity, angleVelocity, damping,
+     *   angleDamping, mass, friction, restitution and gravityScale; use setLinearVelocity, setAngularVelocity,
+     *   setLinearDamping, setAngularDamping, setMass, the friction and restitution of its shapes and setGravityScale.
+     *   A debug build warns once when one of them is set
      * @extends EngineObject
      * @memberof Box2D
      */
@@ -6389,7 +6773,7 @@ declare module "littlejsengine" {
          *  @type {Array<Array<Vector2>>} */
         edgeLoops: Array<Array<Vector2>>;
         edgeListFixtures: Map<any, any>;
-        /** Draws all this object's fixtures
+        /** Draw all this object's fixtures
          *  @param {Color}   [color]
          *  @param {Color}   [lineColor]
          *  @param {number}  [lineWidth]
@@ -6415,7 +6799,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]
@@ -6426,61 +6811,69 @@ 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] */
-        addCircle(diameter?: number, offset?: 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 circle too big to make */
+        addCircle(diameter?: number, offset?: Vector2, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any | undefined;
         /** Add an edge shape to the body
          *  @param {Vector2} point1
          *  @param {Vector2} point2
          *  @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;
@@ -6523,10 +6916,12 @@ declare module "littlejsengine" {
         /** Sets the angular velocity, clockwise like angle
          *  @param {number} angularVelocity */
         setAngularVelocity(angularVelocity: number): void;
-        /** Sets the linear damping
+        /** Sets the linear damping, Box2D's: a rate, 0 none and larger slows it faster, with no upper limit, where the
+         *  damping of an EngineObject is the fraction it keeps each frame and does nothing on a Box2dObject
          *  @param {number} damping */
         setLinearDamping(damping: number): void;
-        /** Sets the angular damping
+        /** Sets the angular damping, Box2D's: a rate, 0 none and larger slows its turning faster, with no upper limit;
+         *  angleDamping does nothing on a Box2dObject
          *  @param {number} damping */
         setAngularDamping(damping: number): void;
         /** Sets the gravity scale
@@ -6796,10 +7191,10 @@ declare module "littlejsengine" {
         /** Get the frequency in Hertz
          *  @return {number} */
         getFrequency(): number;
-        /** Set the damping ratio
+        /** Set how much the spring is damped, 0 for none and 1 to stop it bouncing
          *  @param {number} ratio */
         setDampingRatio(ratio: number): void;
-        /** Get the damping ratio
+        /** Get how much the spring is damped, 0 for none and 1 to stop it bouncing
          *  @return {number} */
         getDampingRatio(): number;
     }
@@ -6807,6 +7202,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
      */
@@ -6903,7 +7300,7 @@ declare module "littlejsengine" {
         /** Set the max motor torque, a magnitude
          *  @param {number} torque */
         setMaxMotorTorque(torque: number): void;
-        /** Get the max motor torque
+        /** Get the most torque the motor can apply, a magnitude
          *  @return {number} */
         getMaxMotorTorque(): number;
         /** Get the motor torque over the last step, clockwise like angle
@@ -7003,10 +7400,10 @@ declare module "littlejsengine" {
         /** Enable/disable the joint motor
          *  @param {boolean} [enable] */
         enableMotor(enable?: boolean): void;
-        /** Set the motor speed
+        /** Set the speed the motor drives the bodies apart along the axis, in meters per second
          *  @param {number} speed */
         setMotorSpeed(speed: number): void;
-        /** Get the motor speed
+        /** Get the speed the motor drives the bodies apart along the axis, in meters per second
          *  @return {number} */
         getMotorSpeed(): number;
         /** Set the maximum motor force
@@ -7067,7 +7464,7 @@ declare module "littlejsengine" {
         /** Set the maximum motor torque, a magnitude
          *  @param {number} torque */
         setMaxMotorTorque(torque: number): void;
-        /** Get the max motor torque
+        /** Get the most torque the wheel's motor can apply, a magnitude
          *  @return {number} */
         getMaxMotorTorque(): number;
         /** Get the motor torque over the last step, clockwise like angle
@@ -7080,10 +7477,10 @@ declare module "littlejsengine" {
         /** Get the spring frequency in Hertz
          *  @return {number} */
         getSpringFrequencyHz(): number;
-        /** Set the spring damping ratio
+        /** Set how much the suspension spring is damped, 0 for none and 1 to stop it bouncing
          *  @param {number} ratio */
         setSpringDampingRatio(ratio: number): void;
-        /** Get the spring damping ratio
+        /** Get how much the suspension spring is damped, 0 for none and 1 to stop it bouncing
          *  @return {number} */
         getSpringDampingRatio(): number;
     }
@@ -7116,18 +7513,12 @@ declare module "littlejsengine" {
         /** Get the frequency in Hertz
          *  @return {number} */
         getFrequency(): number;
-        /** Set the damping ratio
+        /** Set how much the weld's spring is damped, 0 for none and 1 to stop it bouncing
          *  @param {number} ratio */
         setDampingRatio(ratio: number): void;
-        /** Get the damping ratio
+        /** Get how much the weld's spring is damped, 0 for none and 1 to stop it bouncing
          *  @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
@@ -7215,10 +7606,10 @@ declare module "littlejsengine" {
          *  @param {Box2dObject} objectA
          *  @param {Box2dObject} objectB */
         constructor(objectA: Box2dObject, objectB: Box2dObject);
-        /** Set the target linear offset, in frame A, in meters.
+        /** Set the target linear offset, in frame A, in meters
          *  @param {Vector2} offset */
         setLinearOffset(offset: Vector2): void;
-        /** Get the target linear offset, in frame A, in meters.
+        /** Get the target linear offset, in frame A, in meters
          *  @return {Vector2} */
         getLinearOffset(): Vector2;
         /** Set the target angular offset, objectB angle minus objectA angle, clockwise like angle
@@ -7280,7 +7671,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
@@ -7288,7 +7679,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?: number | Color, 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
@@ -7316,7 +7707,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
@@ -7324,7 +7715,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?: number | Color, 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
@@ -7421,9 +7812,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)
@@ -7456,15 +7847,18 @@ declare module "littlejsengine" {
          *  the last iteration of a loop or pingPong, and again each time a restart plays through; then() sets it
          *  @type {undefined|function():void} */
         onComplete: undefined | (() => void);
-        /** Continuation when a pass ends, set by loop() and pingPong() to start the next iteration.
+        /** Continuation when a pass ends, set by loop() and pingPong() to start the next iteration
          *  @private */
         private thenCallback;
-        /** Remaining iterations including the current run (loop/pingPong only).
+        /** 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;
@@ -7479,9 +7873,9 @@ declare module "littlejsengine" {
         target: {
             destroyed?: boolean;
         } | undefined;
-        /** Set the easing curve and return this for chaining.
+        /** 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
@@ -7491,7 +7885,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
@@ -7502,7 +7896,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.
@@ -7511,11 +7905,11 @@ 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 this tween. While paused, tweenUpdate skips it */
         pause(): void;
-        /** Resume a paused tween. */
+        /** Resume a paused tween */
         resume(): void;
         /** Reset this tween to the start: life back to duration, pause cleared,
          *  re-added to the active list if previously stopped, and the callback
@@ -7526,17 +7920,17 @@ declare module "littlejsengine" {
          *  after restart to repeat it. The `then` callback is kept and is called
          *  again when it completes. */
         restart(): void;
-        /** True if this tween is in the active list and not paused.
-         *  @returns {boolean} */
+        /** True if this tween is in the active list and not paused
+         *  @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`.
@@ -7544,7 +7938,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. */
@@ -7565,12 +7959,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
@@ -7697,7 +8091,7 @@ declare module "littlejsengine" {
      *  @return {function(OffscreenCanvasRenderingContext2D, Vector2): void}
      *  @memberof Parallax */
     export function parallaxMountains(topColor?: Color, bottomColor?: Color, seed?: number): (arg0: OffscreenCanvasRenderingContext2D, arg1: Vector2) => void;
-    /** Grid pathfinder using A* with two optional smoothing passes.
+    /** Grid pathfinder using A* with two optional smoothing passes
      *  @memberof PathFinding
      *  @example
      *  // Tile-layer driven (most common):
@@ -7709,7 +8103,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);
@@ -7750,27 +8145,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.
+        /** 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).
+        /** 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.
+        /** 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
@@ -7781,7 +8176,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
@@ -7794,9 +8189,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.
@@ -7831,7 +8226,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
@@ -7843,7 +8238,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
@@ -7860,7 +8255,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
@@ -7868,7 +8263,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) */
@@ -7896,9 +8292,10 @@ declare module "littlejsengine" {
         heapIndex: number;
         /** Clear what a search left on this node, keeping walkable and cost */
         resetSearch(): void;
-        /** Reset per-search state and walkability (called by buildNodeData). */
+        /** 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
@@ -8392,8 +8789,9 @@ declare module "littlejsengine" {
      * - The 3D scene draws under the 2D sprites, so HUD and text land on top
      * - Lighting is the sun plus ambient, with optional extra lights, fog and shadows
      * - Any object or draw can bring its own Shader, a mainImage snippet the lighting then applies to
-     * - Build shapes with buildBox, buildSphere, buildGrid and buildLathe; the other builders, terrain, particles,
-     *   camera controls and the OBJ loader are in the Render3D Extras plugin, which goes after this one
+     * - Meshes and the basic builders are in render3dMesh.js, EngineObject3D, instancing and lights in
+     *   render3dObject.js, both right after this one; the other builders, terrain, particles, camera controls and the
+     *   OBJ loader are in the Render3D Extras plugin, which goes after those
      * - Requires the Math3D plugin
      * @namespace Render3D
      */
@@ -8488,6 +8886,18 @@ declare module "littlejsengine" {
         /** @property {Mesh|undefined} - Sky dome from buildSky or setSky, drawn around the camera behind everything
          *  @type {Mesh|undefined} */
         sky: Mesh | undefined;
+        /** @property {CubeMap|undefined} - A cube map drawn as the sky, behind everything, in place of the sky dome;
+         *  an orthographic camera looks the same way through every pixel, so it sees one color of it; fog fades to
+         *  fogColor, not to the sky box, so with fog set fogColor to its horizon's color
+         *  @type {CubeMap|undefined} */
+        skyBox: CubeMap | undefined;
+        /** @property {CubeMap|undefined} - The world around, what reflective surfaces reflect: an object's
+         *  reflectivity says how much and its shininess how sharp, the same shininess that tightens its highlight:
+         *  10000 a mirror, 1000 polished, 10 a wide blur; undefined reflects the sky's colors as setSky gave them; a cube map holds GPU
+         *  memory until its dispose(), so one made again and again, as for a sky that changes, disposes the one it
+         *  replaces, or a captured one is captured into again
+         *  @type {CubeMap|undefined} */
+        environment: CubeMap | undefined;
         /** @property {boolean} - Draw the 3D scene on top of the 2D scene instead of under it */
         renderAfter2D: boolean;
         /** @property {boolean} - Draw see through things far to near so they blend correctly */
@@ -8548,6 +8958,19 @@ declare module "littlejsengine" {
         shadowShader: WebGLProgram | undefined;
         /** @type {WebGLVertexArrayObject|undefined} */
         vao: WebGLVertexArrayObject | undefined;
+        /** @type {Set<CubeMap>} */
+        cubeCaptures: Set<CubeMap>;
+        /** @type {CubeMap|undefined} */
+        capturingCube: CubeMap | undefined;
+        /** @type {WebGLFramebuffer|undefined} */
+        captureFramebuffer: WebGLFramebuffer | undefined;
+        /** @type {WebGLRenderbuffer|undefined} */
+        captureDepth: WebGLRenderbuffer | undefined;
+        captureDepthSize: number;
+        /** @type {WebGLProgram|undefined} */
+        skyBoxProgram: WebGLProgram | undefined;
+        /** @type {WebGLVertexArrayObject|undefined} */
+        skyBoxVao: WebGLVertexArrayObject | undefined;
         /** @type {WebGLTexture|undefined} */
         whiteTexture: WebGLTexture | undefined;
         /** @type {Map<number, WebGLSampler>} */
@@ -8567,7 +8990,10 @@ declare module "littlejsengine" {
         cameraDepthHeight: number;
         depthPass: boolean;
         contextGeneration: number;
-        uniforms: Map<any, any>;
+        /** @type {WeakMap<WebGLProgram, Object<string, WebGLUniformLocation|null>>} */
+        uniforms: WeakMap<WebGLProgram, {
+            [x: string]: WebGLUniformLocation | null;
+        }>;
         /** @type {Object<string, Array<number>>} */
         uniformValues: {
             [x: string]: Array<number>;
@@ -8594,7 +9020,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;
@@ -8663,6 +9090,10 @@ declare module "littlejsengine" {
         /** Emissive map for the next draws, set from each object's emissiveMap
          *  @return {TextureInfo|undefined} */
         get emissiveMap(): TextureInfo | undefined;
+        set environmentMap(arg: CubeMap | undefined);
+        /** The cube map the next draws reflect in place of render3D.environment, set from each object's environment
+         *  @return {CubeMap|undefined} */
+        get environmentMap(): CubeMap | 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
@@ -8805,7 +9236,8 @@ declare module "littlejsengine" {
         /** Draw the queued transparent draws far to near with the state each was drawn under, called automatically at the
          *  end of the transparent stage */
         flushTransparentQueue(): void;
-        /** Draw render3D.sky around the camera, unlit, unfogged and behind everything, called automatically by the pass */
+        /** Draw render3D.skyBox, or render3D.sky around the camera, unlit, unfogged and behind everything, called
+         *  automatically by the pass */
         drawSky(): void;
         /** Rebuild the light's view projection around the shadow center, called automatically each frame shadows are on */
         updateShadowMatrix(): void;
@@ -8892,6 +9324,78 @@ declare module "littlejsengine" {
          *  @return {void} */
         drawSoftShadow(pos: Vector3, size?: number, floorHeight?: number | HeightMap | ((arg0: number, arg1: number) => number), color?: Color, lift?: number): void;
     }
+    /**
+     * CubeMap - Six square images all around a point, the world far away: what reflective surfaces reflect as
+     * render3D.environment, and the sky as render3D.skyBox
+     * - makeCubeMap paints one from a function of direction, loadCubeMap loads six images
+     * - Made with no faces it is drawn from the scene: capture(pos3D) draws everything around that point into it in the
+     *   next frame's 3D pass, six views of the whole scene, so capture once for a still scene or now and then for one
+     *   that moves
+     * - Its faces are in WebGL's order and lay out, +x, -x, +y, -y, +z, -z: WebGL's cube is left handed, so in this right
+     *   handed world a face seen from the middle is mirrored; loadCubeMap turns a sky box set's images to it
+     * @memberof Render3D
+     * @example
+     * render3D.environment = render3D.skyBox = makeCubeMap(64, (d)=> hsl(.6, .8, .4 + d.y * .4));
+     * @example
+     * // a chrome ball that reflects the scene around it, captured once
+     * const ball = new EngineObject3D(vec3(0, 1, 0), render3D.sphereMesh, undefined, BLACK);
+     * ball.reflectivity = 1;
+     * ball.shininess = 1e4;
+     * render3D.environment = new CubeMap(128);
+     * render3D.environment.capture(ball.pos3D);
+     */
+    export class CubeMap {
+        /** Make a cube map from its six faces, as makeCubeMap and loadCubeMap do, or with none to capture the scene into
+         *  @param {number} size - Pixels a side of each face
+         *  @param {Array<Uint8Array|HTMLImageElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas>} [faces] - +x, -x,
+         *  +y, -y, +z and -z, RGBA pixels row by row or images; none for a cube map drawn by capture */
+        constructor(size: number, faces?: (Uint8Array | OffscreenCanvas | ImageBitmap | HTMLCanvasElement | HTMLImageElement)[]);
+        /** @property {number} - Pixels a side of each face */
+        size: number;
+        /** @property {Array<Uint8Array|HTMLImageElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas>|undefined} -
+         *  Its faces, kept to upload again after a lost context, undefined for one drawn by capture
+         *  @type {Array<Uint8Array|HTMLImageElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas>|undefined} */
+        faces: Array<Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas> | undefined;
+        /** @property {Vector3|undefined} - Where it was last captured from, and is captured from again after a lost
+         *  context
+         *  @type {Vector3|undefined} */
+        capturePos: Vector3 | undefined;
+        /** @type {WebGLTexture|undefined} */
+        glTexture: WebGLTexture | undefined;
+        contextGeneration: number;
+        /** Draw the scene around a point into a cube map made with no faces, in the next frame's 3D pass
+         *  - Every object of the layer render3D.renderAfter2D picks is drawn, with the sky and the render callbacks; the
+         *    camera's near and far planes, the lights and the fog are the scene's
+         *  - It is six more draws of the scene, so capture once for a still scene, or every few frames for a moving one
+         *  - A closed mesh around the point, like the ball that reflects it, is not seen from inside, so it hides nothing
+         *  - While it is drawn, what would reflect it reflects the sky's colors in its place
+         *  - It is seen from one point, so it suits what is near that point best, give each mirror its own with
+         *    obj.environment
+         *  @param {Vector3} pos3D - The point it is seen from */
+        capture(pos3D: Vector3): void;
+        /** Free its texture, which is made again if it is used after */
+        dispose(): void;
+    }
+    /** Make a cube map by asking a function the color of each direction
+     *  - The function gets a unit Vector3 for each pixel of each face and gives a Color
+     *  - It runs size * size * 6 times, so a size of 64 or 128 makes one at once, larger takes a moment
+     *  @param {number} size - Pixels a side of each face
+     *  @param {function(Vector3): Color} colorOf - The color seen looking that way
+     *  @return {CubeMap}
+     *  @example
+     *  // a sky, blue above and pale at the horizon, with a sun
+     *  const sun = vec3(1, 1, -1).normalize();
+     *  render3D.environment = makeCubeMap(64, (d)=> hsl(.6, .7, .9 - max(d.y, 0) * .5).lerp(WHITE, max(0, d.dot(sun)) ** 64));
+     *  @memberof Render3D */
+    export function makeCubeMap(size: number, colorOf: (arg0: Vector3) => Color): CubeMap;
+    /** Load a cube map from six square images of one size
+     *  - The images are a sky box set as three.js's CubeTextureLoader takes them, and show the same: each face seen from
+     *    inside as its image is drawn
+     *  @param {Array<string>} sources - The images of +x, -x, +y, -y, +z and -z, as a sky box set names them right,
+     *  left, top, bottom, front and back
+     *  @return {Promise<CubeMap>}
+     *  @memberof Render3D */
+    export function loadCubeMap(sources: Array<string>): Promise<CubeMap>;
     /**
      * Camera3D - Position, rotation and lens for the 3D view
      * - Looks down its -Z axis, rotation is vec3(pitch, yaw, roll)
@@ -8910,7 +9414,8 @@ declare module "littlejsengine" {
         far: number;
         /** @property {number} - Visible height in world units for an orthographic view, 0 is perspective */
         orthographic: number;
-        /** @property {boolean} - Line the 3D camera up with the 2D camera, so 3D things at z=0 sit on the 2D sprites */
+        /** @property {boolean} - Line the 3D camera up with the 2D camera, so 3D things at z=0 sit on the 2D sprites;
+         *  it lines up with the 2D view of the main canvas, whatever canvas size a screenToRay is given */
         align2D: boolean;
         /** Returns the camera's world transform
          *  @return {Matrix4} */
@@ -9040,6 +9545,10 @@ declare module "littlejsengine" {
         emissiveMap: TextureInfo | undefined;
         /** @property {Color} - Multiplies the emissive map, as glTF's emissiveFactor */
         emissiveMapColor: Color;
+        /** @property {CubeMap|undefined} - What it reflects in place of render3D.environment, as a mirror captures
+         *  the scene from its own middle
+         *  @type {CubeMap|undefined} */
+        environment: CubeMap | undefined;
         /** @property {boolean} - Collide as the sphere that fits size3D instead of as the size3D box, so it rolls
          *  around corners */
         collideAsSphere3D: boolean;
@@ -9062,6 +9571,10 @@ declare module "littlejsengine" {
         matrixParent: EngineObject3D | undefined;
         matrixParentVersion: number;
         movePass: number;
+        collideFrom: Vector3;
+        collideFromPass: number;
+        /** @type {EngineObject3D|undefined} */
+        drawOwner: EngineObject3D | undefined;
         /** Called by a VoxelMap to ask whether a block stops this object, a hook to let one through or react to it
          *  @param {number} type - The block's type, 1 to 255
          *  @param {Vector3} cell - The block's cell in the map
@@ -9084,6 +9597,13 @@ declare module "littlejsengine" {
          *    cheap to call
          *  @return {Matrix4} */
         getMatrix(): Matrix4;
+        set roughness(arg: number);
+        /** How rough the surface is, 0 a mirror to 1 matte, as glTF and three.js's MeshStandardMaterial have it: another
+         *  way to set shininess, which is what is kept, shininess = 2 / roughness^4 - 2 and at least 1; it sets both the
+         *  highlight and how blurred a reflection is; read back it is the same up to about .9, above which shininess is 1
+         *  and it reads .9
+         *  @return {number} */
+        get roughness(): number;
         /** Turn the object so its -Z axis points at a world space target, sets pitch and yaw and clears roll
          *  @param {Vector3} target */
         lookAt(target: Vector3): void;
@@ -9167,6 +9687,7 @@ declare module "littlejsengine" {
             pointCount: number;
             data: ArrayBuffer;
         } | undefined;
+        vertexDataPacked: boolean;
         instanceCount: number;
         /** @type {Float32Array|undefined} */
         instanceData: Float32Array | undefined;
@@ -9752,7 +10273,8 @@ declare module "littlejsengine" {
         chunkTransparentMeshes: Array<Mesh | undefined>;
         /** @type {Array<Vector3>} */
         chunkCenters: Array<Vector3>;
-        chunksChanged: Set<any>;
+        /** @type {Set<number>} */
+        chunksChanged: Set<number>;
         /** @type {Array<{faces: Array<number>, seeThrough: boolean, transparent: boolean, doubleSided: boolean}|undefined>} */
         blockTypes: Array<{
             faces: Array<number>;
@@ -9760,7 +10282,8 @@ declare module "littlejsengine" {
             transparent: boolean;
             doubleSided: boolean;
         } | undefined>;
-        tiles: Map<any, any>;
+        /** @type {Map<number, Array<Vector2>>} */
+        tiles: Map<number, Array<Vector2>>;
         /** The block type at a cell, 0 for empty or outside the map
          *  @param {Vector3} cell
          *  @return {number} */
@@ -9852,7 +10375,8 @@ declare module "littlejsengine" {
          *  @ignore */
         levelRaycast3D(ray: Ray3D): number | undefined;
         /** Where a short move goes into a block, for a particle's move in one frame: the part of the move made before it,
-         *  0 to 1, and the normal of the face it comes in through; undefined when it hits none, or starts inside one
+         *  0 to 1, and the normal of the face it comes in through; undefined when it hits none, or starts inside one; a
+         *  move that starts on a block's face, coming in, hits it at 0
          *  @param {Vector3} from
          *  @param {Vector3} to
          *  @return {{distance: number, normal: Vector3}|undefined}
@@ -10117,7 +10641,8 @@ declare module "littlejsengine" {
         /** @property {boolean} - Flatten the spawn area across the way it emits, its own up: a sphere becomes a disc
          *  and a box a flat rectangle, for rain from a sheet of sky or flames from a patch of ground */
         emitFlat: boolean;
-        /** @property {number} - How long to keep emitting, 0 is forever */
+        /** @property {number} - How long to keep emitting, 0 is forever; raised while its particles are still alive,
+         *  it emits again for the added time */
         emitTime: number;
         /** @property {number} - Particles per second, 0 does not emit */
         emitRate: number;
@@ -10183,10 +10708,16 @@ declare module "littlejsengine" {
          *  @type {Vector3|undefined} */
         worldPos3D: Vector3 | undefined;
         emitTimeBuffer: number;
+        emitElapsed: number;
+        /** @type {Vector3|undefined} */
+        emitFrom: Vector3 | undefined;
+        emitBehind: number;
         /** Spawn one particle now */
         emitParticle(): void;
-        particleCall(callback: any, k: any, level: any, pos: any): any;
-        particleCollide(k: any, x: any, y: any, z: any): boolean;
+        /** @private */
+        private particleCall;
+        /** @private */
+        private particleCollide;
     }
     /**
      * Trail3D - A ribbon through where the object has been, thinning and fading with age
@@ -10308,8 +10839,9 @@ declare module "littlejsengine" {
         /** @property {number} - Seconds the flare takes to fade out or in when the sun is hidden or shows again */
         fadeTime: number;
         /** @property {number} - How much of the sun shows, 0 hidden, off the screen or behind the camera to 1 in
-         *  plain view, eased */
+         *  plain view, eased; the first update sets it at once, so a sun hidden from the start never shows */
         visible: number;
+        visibleFound: boolean;
         madeKey: string;
         /** @type {Array<LensFlareElement>} */
         made: Array<LensFlareElement>;
@@ -10360,6 +10892,11 @@ declare module "littlejsengine" {
          *  it is doubleSided
          *  @return {boolean} */
         isHidden(): boolean;
+        /** Ease visible toward whether the sun shows over some seconds; the first time it is found at once, from the
+         *  camera as it is, its matrices made, by the first update or the first draw, whichever comes first
+         *  @param {number} seconds
+         *  @ignore */
+        updateVisible(seconds: number): void;
     }
     /**
      * Collect the EngineObject3D objects whose boxes overlap a sphere or a box, the 3D twin of engineObjectsCollect
@@ -10423,14 +10960,22 @@ declare module "littlejsengine" {
      * @memberof GLTF
      */
     export class GLTFModel {
-        /** @param {Array<GLTFPart>} parts @param {Array<GLTFAnimation>} [animations] @param {Object} [nodeTree] */
+        /** 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
          *  @type {Array<GLTFAnimation>} */
         animations: Array<GLTFAnimation>;
-        nodeTree: any;
+        /** @type {{nodes: Array<Object>, parents: Array<number|undefined>, restInverse: Array<Matrix4>,
+         *  restPose: Array<Matrix4|undefined>}|undefined} */
+        nodeTree: {
+            nodes: Array<any>;
+            parents: Array<number | undefined>;
+            restInverse: Array<Matrix4>;
+            restPose: Array<Matrix4 | undefined>;
+        } | undefined;
         modelMatrix: Matrix4;
         /** @property {Mesh} - Every part combined, each tinted with its material color; the texture is textureInfo,
          *  and blending and unlit stay with the parts, which createObject draws */
@@ -10470,6 +11015,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
@@ -10487,9 +11033,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
@@ -10507,6 +11055,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
      */
     /**
@@ -10514,7 +11063,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;
@@ -10547,6 +11097,15 @@ declare module "littlejsengine" {
         emissiveMap: TextureInfo | undefined;
         /** @property {Color} - The emissiveFactor, which multiplies the emissive map */
         emissiveMapColor: Color;
+        /** @property {number} - The material's roughnessFactor, 0 a mirror to 1 matte, 1 when it has none as the
+         *  format says; the object createObject makes takes it as its roughness, which sets its shininess */
+        roughness: number;
+        /** @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
@@ -10577,28 +11136,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;
@@ -10618,7 +11214,7 @@ declare module "littlejsengine" {
      *    is fetched then
      *  - A file the model needs that is not found is named in the error, and an image that can not be read is named in
      *    a warning and left out
-     *  @param {ArrayBuffer|Object|string} data - GLB bytes, or the glTF JSON as bytes, text or an object
+     *  @param {ArrayBuffer|ArrayBufferView|Object<string, any>|string} data - GLB bytes, or the glTF JSON as bytes, text or an object
      *  @param {string} [baseUrl] - Where the .bin and image files are, with its trailing slash; loadGLTF passes the file's folder
      *  @param {Map<string, Blob>} [files] - The files it refers to, by their paths, in place of fetching them
      *  @return {Promise<GLTFModel>}
@@ -10628,7 +11224,9 @@ declare module "littlejsengine" {
      *  const gltf = [...files.values()].find((file)=> file.name.endsWith('.gltf'));
      *  const model = await parseGLTF(await gltf.text(), '', files);
      *  @memberof GLTF */
-    export function parseGLTF(data: ArrayBuffer | any | string, baseUrl?: string, files?: Map<string, Blob>): Promise<GLTFModel>;
+    export function parseGLTF(data: ArrayBuffer | ArrayBufferView | {
+        [x: string]: any;
+    } | string, baseUrl?: string, files?: Map<string, Blob>): Promise<GLTFModel>;
     /** Load a glTF or GLB model, the .bin and images of a .gltf from beside it
      *  - A texture only OPAQUE materials use loads with its alpha set to 1, so the 3D pass cuts no holes in it
      *  @param {string} url
@@ -10677,13 +11275,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
@@ -10714,13 +11314,14 @@ declare module "littlejsengine" {
      *    are added before its objects are made, one the game added itself keeps its place
      *  - A level may set the scene too, in a scene block beside its objects: sky, three colors for straight up, the
      *    horizon and straight down, ambient, how much of them lights the scene, .5 when not given, sunDirection and
-     *    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
+     *    sunColor, fog, its start and end, fogColor, the horizon color when not given, shadows, lensFlare, the
+     *    sun's lens flare, and skyBox and environment, each six image urls as loadCubeMap takes them, which load in
+     *    the background and are set when they have; what the block leaves out stays as the game set it, and a level
+     *    with no block changes nothing
+     *  @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
@@ -10733,13 +11334,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
@@ -10752,13 +11357,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
@@ -10777,13 +11384,22 @@ declare module "littlejsengine" {
         prefabName: string;
         /** @property {boolean} - Are its parts its children, moving with it as one body */
         attached: boolean;
-        /** @property {Array<any>} - What the prefab's objects made, in the prefab's order */
-        parts: any[];
+        /** @property {Array<EngineObject3D>} - What the prefab's objects made, in the prefab's order
+         *  @type {Array<EngineObject3D>} */
+        parts: Array<EngineObject3D>;
         /** @property {Vector3} - From the prefab's origin to the handle, in the prefab's own space: nothing for
          *  separate parts, and for an attached prefab the middle of the box around its parts, where its handle
          *  is, as an object's place is the middle of its body */
         originOffset: Vector3;
-        partObjects: any[];
+        /** @type {Array<{id?: number, type: string, pos?: Array<number>, rotation?: Array<number>, scale?: Array<number>|number, properties?: Object}>} */
+        partObjects: Array<{
+            id?: number;
+            type: string;
+            pos?: Array<number>;
+            rotation?: Array<number>;
+            scale?: Array<number> | number;
+            properties?: any;
+        }>;
         partsPlaced: string;
         partsMade: boolean;
         /** Put the instance with its prefab's origin at a place, turned and sized as the handle is: where a level's
@@ -11022,9 +11638,12 @@ declare module "littlejsengine" {
      *  - Accepts TexturePacker json (hash and array) and Aseprite json
      *  - Frames tagged in Aseprite or named like run_0, run_1 group into animations
      *  @param {Object} data - Parsed atlas json data
-     *  @return {Array<Object>} List of {name, frames} groups in atlas order
+     *  @return {Array<{name: string, frames: Array<Object>}>} List of {name, frames} groups in atlas order
      *  @memberof TextureSheets */
-    export function parseAtlas(data: any): Array<any>;
+    export function parseAtlas(data: any): {
+        name: string;
+        frames: Array<any>;
+    }[];
     /** Wait for everything started by loadSprite and loadAtlas to finish packing
      *  @return {Promise}
      *  @example
@@ -11099,10 +11718,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;
@@ -11146,7 +11765,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;
@@ -11182,8 +11801,9 @@ declare module "littlejsengine" {
      *  @memberof ParticleEffects */
     export function particleEffectApply3D(emitter: ParticleEmitter3D, effect: any): void;
     /** An effect with a 2D emitter's settings, to save, build again, or build in 3D with particleEffect3D; its tile is
-     *  left out, since a hand made emitter's tile is its own texture and not one an effect can name, and so is its
-     *  scale, which an effect does not keep: pass it again with options.scale
+     *  left out, since a hand made emitter's tile is its own texture and not one an effect can name, and so are its
+     *  scale, which an effect does not keep: pass it again with options.scale, and its renderOrder, which an effect takes
+     *  from additive; a finished emitter's emit time is the time it emitted for
      *  @param {ParticleEmitter} emitter
      *  @param {string} [name]
      *  @return {Object}
@@ -11193,7 +11813,7 @@ declare module "littlejsengine" {
      *  @param {string} name
      *  @param {function(Particle, number): void} update - Pushes a 2D particle, given the strength
      *  @param {function(Particle3D, number): void} [update3D] - The same for a 3D particle, none leaves 3D alone
-     *  @param {number} [min] - Strength range the designer offers
+     *  @param {number} [min] - Strength range the designer offers, and the range a strength is clamped to
      *  @param {number} [max]
      *  @param {number} [value] - Strength when first added
      *  @param {string} [description]