melonjs 20.1.1 → 20.3.0

package/build/input/input.d.ts

@@ -3,9 +3,28 @@
  */
 /**
  * specify if melonJS should prevent all default browser action on registered events.
+ *
+ * Read-only: this is a module binding, so `input.preventDefault = false` cannot
+ * work — assigning to a module namespace property throws. Use
+ * {@link input.setPreventDefault} instead.
  * @default true
+ * @see input.setPreventDefault
  */
 export declare let preventDefault: boolean;
+/**
+ * set whether melonJS should prevent the default browser action on registered
+ * events. This is the global default; {@link input.bindKey}'s `preventDefault`
+ * argument overrides it per binding.
+ *
+ * Pointer listeners read it when they are registered, so call this before
+ * creating the {@link Application} for it to apply to the engine's own
+ * listeners.
+ * @param value - true to prevent default browser actions (the default)
+ * @example
+ * // let the browser handle scrolling, zooming and context menus itself
+ * me.input.setPreventDefault(false);
+ */
+export declare function setPreventDefault(value: boolean): void;
 export * from "./gamepad.ts";
 export * from "./key.ts";
 export * from "./keyboard.ts";

package/build/input/input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/input/input.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AAEH,eAAO,IAAI,cAAc,EAAE,OAAc,CAAC;AAE1C,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/input/input.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;GAQG;AACH,eAAO,IAAI,cAAc,EAAE,OAAc,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,QAE/C;AAED,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC"}

package/build/input/pointerevent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointerevent.d.ts","sourceRoot":"","sources":["../../src/input/pointerevent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,OAAO,MAAM,cAAc,CAAC;AAoBnC;;;GAGG;AACH,eAAO,IAAI,IAAI,EAAE,WAAW,CAAC;AAggB7B;;GAEG;AACH,eAAO,IAAI,kBAAkB,EAAE,WAAW,GAAG,IAAW,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAAiC,CAAC;AAExD;;GAEG;AACH,eAAO,IAAI,MAAM,EAAE,OAAe,CAAC;AAEnC;;;;GAIG;AACH,eAAO,IAAI,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;AAElD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAY1E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,CAAC,EAAE,MAAM,GACZ,IAAI,CAEN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAanD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC5C,IAAI,CAsCN;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC7C,IAAI,CAiCN;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAMzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAO5C;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAMzC"}
+{"version":3,"file":"pointerevent.d.ts","sourceRoot":"","sources":["../../src/input/pointerevent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,OAAO,MAAM,cAAc,CAAC;AAoBnC;;;GAGG;AACH,eAAO,IAAI,IAAI,EAAE,WAAW,CAAC;AAqiB7B;;GAEG;AACH,eAAO,IAAI,kBAAkB,EAAE,WAAW,GAAG,IAAW,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAAiC,CAAC;AAExD;;GAEG;AACH,eAAO,IAAI,MAAM,EAAE,OAAe,CAAC;AAEnC;;;;GAIG;AACH,eAAO,IAAI,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;AAElD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAY1E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,CAAC,EAAE,MAAM,GACZ,IAAI,CAEN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAanD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC5C,IAAI,CAsCN;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC7C,IAAI,CAiCN;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAMzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAO5C;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAMzC"}

package/build/lang/deprecated.d.ts

@@ -25,13 +25,15 @@ export class CanvasTexture extends CanvasRenderTarget {
      * @param {number} width - the desired width of the canvas
      * @param {number} height - the desired height of the canvas
      * @param {object} attributes - The attributes to create both the canvas and context
-     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl" — creates a WebGL 2 context)
+     * @param {string} [attributes.context="2d"] - the context type to be created ("2d", "webgl" — creates a WebGL 2 context, or "webgpu")
+     * @param {boolean} [attributes.transparent=false] - whether to enable transparency on the canvas
      * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
      * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
      * @param {boolean} [attributes.antiAlias=false] - Whether to enable anti-aliasing, use false (default) for a pixelated effect.
      */
     constructor(width: number, height: number, attributes: {
-        context?: boolean | undefined;
+        context?: string | undefined;
+        transparent?: boolean | undefined;
         offscreenCanvas?: boolean | undefined;
         willReadFrequently?: boolean | undefined;
         antiAlias?: boolean | undefined;

package/build/lang/deprecated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AAuJA;;;;;;;;GAQG;AACH,4CAHW,OAAO,QAsBjB;AAED;;;;;;GAMG;AACH,uCAeC;AA7LD;;;GAGG;AACH;IACC;;;;;;;;OAQG;IACH,mBARW,MAAM,UACN,MAAM,cAEd;QAA6B,OAAO;QACP,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;AA4BD;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;;+BA3F8B,6CAA6C;6BAC/C,oCAAoC;6BACpC,8CAA8C;wBACnD,yCAAyC"}
+{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AA0JA;;;;;;;;GAQG;AACH,4CAHW,OAAO,QAsBjB;AAED;;;;;;GAMG;AACH,uCAeC;AAhMD;;;GAGG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,cAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;AA8BD;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;;+BA9F8B,6CAA6C;6BAC/C,oCAAoC;6BACpC,8CAA8C;wBACnD,yCAAyC"}

package/build/level/gltf/GLTFScene.d.ts

@@ -87,12 +87,24 @@ export default class GLTFScene {
      * at unit intensity and lets the app tune. With this option the
      * authored ratios survive: e.g. `0.001` maps a 1000-lux sun to 1 while
      * a half-strength 500-lux fill lands at 0.5.
+     * @param {boolean} [options.castGroundShadow] - give this scene's meshes a
+     * ground shadow ({@link Mesh#castGroundShadow}), overriding the
+     * application's setting for this scene in both directions; omit it to
+     * inherit. As a scene-wide opt-in it skips nodes with no vertical extent —
+     * a scene's ground plane is exactly that, and shadowing it with itself
+     * smears a blob across the whole floor.
+     * @param {number} [options.shadowGroundY] - world Y of the floor those
+     * shadows land on ({@link Mesh#shadowGroundY}); omit it and each blob sits
+     * at its own object's base at full strength, which is right for a scene
+     * whose props already rest on the ground.
      */
     addTo(container: Container, options?: {
         scale?: number | undefined;
         rightHanded?: boolean | undefined;
         lights?: boolean | undefined;
         lightIntensityScale?: number | undefined;
+        castGroundShadow?: boolean | undefined;
+        shadowGroundY?: number | undefined;
     }): void;
     /**
      * Add the scene's authored lights — directional, point and spot — (plus a soft ambient fill) to

package/build/level/gltf/GLTFScene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AA6VA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAJW,aAAa,aACb,MAAM,QAwChB;AA7YD;;;;;;;;;;GAUG;AACH;IACC;;OAEG;IACH,qBAFW,MAAM,EAkBhB;IAfA;;;OAGG;IACH,MAFU,MAAM,CAEG;IACnB;;;OAGG;IACH,QAFU,MAAM,CAEI;IACpB;;;OAGG;IACH,MAFU,MAAM,CAEY;IAG7B;;;;OAIG;IACH,cAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iBAtBW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;KAQ9C,QA4KA;IAED;;;;;;;;;;;;OAYG;IACH,sBANW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAqEhB;IAED;;;;;OAKG;IACH,gBAAY;CACZ;0BAvVyB,oCAAoC"}
+{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AAuWA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAJW,aAAa,aACb,MAAM,QAwChB;AAvZD;;;;;;;;;;GAUG;AACH;IACC;;OAEG;IACH,qBAFW,MAAM,EAkBhB;IAfA;;;OAGG;IACH,MAFU,MAAM,CAEG;IACnB;;;OAGG;IACH,QAFU,MAAM,CAEI;IACpB;;;OAGG;IACH,MAFU,MAAM,CAEY;IAG7B;;;;OAIG;IACH,cAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,iBAhCW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;QAQlB,gBAAgB;QAMjB,aAAa;KAIxC,QA4KA;IAED;;;;;;;;;;;;OAYG;IACH,sBANW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAqEhB;IAED;;;;;OAKG;IACH,gBAAY;CACZ;0BAjWyB,oCAAoC"}

package/build/level/tiled/TMXObjectFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXObjectFactory.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXObjectFactory.js"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,0CAJW,MAAM,GACJ,OAAO,GAAC,MAAM,EAAE,CAY5B;AAED;;;;;;;;;;;;GAYG;AACH,2CAJW,MAAM,GACJ,MAAM,CAsBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iDApBW,MAAM,2BAgChB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAZW,MAAM,+BA6BhB;AAQD;;;;;;;GAOG;AACH,gDAJW,MAAM,+BAWhB;AAoCD;;;;;;;GAOG;AACH,0CALW,MAAM,OACN,UAAU,GACR,UAAU,CAqBtB"}
+{"version":3,"file":"TMXObjectFactory.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXObjectFactory.js"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,0CAJW,MAAM,GACJ,OAAO,GAAC,MAAM,EAAE,CAgB5B;AAED;;;;;;;;;;;;GAYG;AACH,2CAJW,MAAM,GACJ,MAAM,CAsBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iDApBW,MAAM,2BAgChB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAZW,MAAM,+BA6BhB;AAQD;;;;;;;GAOG;AACH,gDAJW,MAAM,+BAWhB;AAoCD;;;;;;;GAOG;AACH,0CALW,MAAM,OACN,UAAU,GACR,UAAU,CAqBtB"}

package/build/loader/loader.d.ts

@@ -47,7 +47,7 @@ export function setBaseURL(type: string, url?: string): void;
  * @typedef {object} Asset
  * @memberof loader
  * @property {string} name - name of the asset
- * @property {string} type  - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tmj"|"tsx"|"tsj"|"fontface"|"video"|"aseprite"|"shader"|"obj"|"mtl"|"gltf"|"glb")
+ * @property {string} type  - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tsx"|"fontface"|"video"|"aseprite"|"shader"|"obj"|"mtl"|"gltf"|"glb"). JSON-serialised Tiled maps and tilesets (`.tmj` / `.tsj`) load under `"tmx"` / `"tsx"` — those are file extensions, not asset types.
  * @property {string|string[]} [src]  - path and/or file name of the resource (for audio assets only the path is required).
  * For image assets, an array of sources can be provided as a fallback chain (e.g. compressed texture formats by priority, with a PNG fallback).
  * The loader will try each source in order and use the first one that loads successfully.
@@ -410,11 +410,11 @@ export function getGLTF(elt: string): GLTFData | null;
  *     } },
  * ], () => {
  *     // one shared program — same uniform state for every user
- *     mySprite.shader = me.loader.getShader("waterRipple");
+ *     mySprite.addPostEffect(me.loader.getShader("waterRipple"));
  *     // private copy with its own uniforms (caller-owned, shared = false)
- *     boss.shader = me.loader.getShader("flash").clone();
+ *     boss.addPostEffect(me.loader.getShader("flash").clone());
  *     // a complete program hosts on a mesh, replacing the built-in shading
- *     myMesh.shader = me.loader.getShader("toonMesh");
+ *     myMesh.addPostEffect(me.loader.getShader("toonMesh"));
  * });
  */
 export function getShader(elt: string): ShaderEffect | GLShader | null;
@@ -513,42 +513,6 @@ export let crossOrigin: string;
  * me.loader.preload(game.resources, () => this.loaded());
  */
 export let withCredentials: boolean;
-/**
- * onload callback
- * @default undefined
- * @memberof loader
- * @type {function}
- * @deprecated since 18.2.0 - Use the {@link event.LOADER_COMPLETE} event or the `onloadcb` parameter of {@link loader.preload} instead.
- * @example
- * // use the LOADER_COMPLETE event instead
- * me.event.on(me.event.LOADER_COMPLETE, this.loaded.bind(this));
- */
-export let onload: Function;
-/**
- * onProgress callback<br>
- * each time a resource is loaded, the loader will fire the specified function,
- * giving the actual progress [0 ... 1], as argument, and an object describing the resource loaded
- * @default undefined
- * @memberof loader
- * @type {function}
- * @deprecated since 18.2.0 - Use the {@link event.LOADER_PROGRESS} event instead.
- * @example
- * // use the LOADER_PROGRESS event instead
- * me.event.on(me.event.LOADER_PROGRESS, (progress, resource) => this.updateProgress(progress, resource));
- */
-export let onProgress: Function;
-/**
- * onError callback<br>
- * each time a resource loading is failed, the loader will fire the specified function giving the actual asset as argument.
- * @default undefined
- * @memberof loader
- * @type {function}
- * @deprecated since 18.2.0 - Use the {@link event.LOADER_ERROR} event instead.
- * @example
- * // use the LOADER_ERROR event instead
- * me.event.on(me.event.LOADER_ERROR, (resource) => this.loaderError(resource));
- */
-export let onError: Function;
 /**
  * an asset definition to be used with the loader
  */

package/build/loader/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"AAuFA;;;GAGG;AACH,mDAEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAdG;IAAyB,WAAW;IACV,OAAO;IACP,eAAe;CACzC,QAqBF;AAED;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,QACN,MAAM,QA6BhB;AAkGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCAnBW,MAAM,4BA6BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,gCAhDW,KAAK,EAAE,2CAEP,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAoFzB;AAED;;;;;;;;;;;;;;;IAeI;AACJ,4BAbW,MAAM,QAqChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,4BAhCW,KAAK,0CAGH,MAAM,GAAC,OAAO,CAAC,IAAI,CAAC,CAqGhC;AAED;;;;;;;GAOG;AACH,8BALW,KAAK,GACH,OAAO,CA6HnB;AAED;;;;;GAKG;AACH,kCAyGC;AAED;;;;;;GAMG;AACH,4BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,+BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,gCAJW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAWjD;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,+BA7BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CAkCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;GAMG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AA9kCD;;;GAGG;AAGH,2BAAwB;AAExB;;GAEG;AACH;;EAA0B;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAbU,MAAM,CAaO;AAEvB;;;;;;;;;;;;;;;;GAgBG;AACH,4BAbU,OAAO,CAakB;;;;oBAgLtB,MAAM;;;;;;;;WA0qBL,MAAM,EAAE;;;;aACR,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;;;;YAClJ,MAAM,EAAE;;;;YACR;QAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAA;KAAC;;;;WAC9B,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}

package/build/loader/parsers/audio.d.ts

@@ -0,0 +1,31 @@
+/**
+ * parse/preload an Audio file
+ *
+ * Unlike the other parsers this one delegates rather than doing the work
+ * itself: audio assets are owned by the audio module, which decodes them
+ * through its own backend and tracks them for playback. Keeping that
+ * delegation here means every asset type is registered the same way — from a
+ * parser of the same shape in this directory — and the loader never reaches
+ * into the audio module directly, so replacing the audio backend cannot ripple
+ * into the loader.
+ * @param {loader.Asset} data - asset data
+ * @param {Function} [onload] - function to be called when the resource is loaded
+ * @param {Function} [onerror] - function to be called in case of error
+ * @param {Object} [settings] - Additional settings to be passed when loading the asset
+ * @returns {number} the amount of corresponding resource parsed/preloaded
+ * @ignore
+ */
+export function preloadAudio(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+/**
+ * unload the given audio asset
+ * @param {string} name - asset name
+ * @returns {boolean} true if unloaded
+ * @ignore
+ */
+export function unloadAudio(name: string): boolean;
+/**
+ * unload all audio assets
+ * @ignore
+ */
+export function unloadAllAudio(): void;
+//# sourceMappingURL=audio.d.ts.map

package/build/loader/parsers/audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/audio.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,mCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;GAKG;AACH,kCAJW,MAAM,GACJ,OAAO,CAKnB;AAED;;;GAGG;AACH,uCAEC"}

package/build/loader/parsers/shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/shader.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,MAAM,GAAC,MAAM,GAEX,YAAY,GAAC,QAAQ,CAqDjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAgHlB;yBA9OwB,qCAAqC;qBACzC,+BAA+B"}
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/shader.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,MAAM,GAAC,MAAM,GAEX,YAAY,GAAC,QAAQ,CAqDjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAgHlB;yBA7OwB,qCAAqC;qBACzC,+BAA+B"}

package/build/particles/emitter.d.ts

@@ -1,11 +1,56 @@
+import { Matrix3d } from "../math/matrix3d.ts";
 import Container from "./../renderable/container.js";
+import type CanvasRenderer from "../video/canvas/canvas_renderer.js";
 import CanvasRenderTarget from "../video/rendertarget/canvasrendertarget.js";
+import type WebGLRenderer from "../video/webgl/webgl_renderer.js";
 import { type ParticleEmitterSettings } from "./settings.ts";
 /**
  * Particle Emitter Object.
+ *
+ * ### Blend modes
+ *
+ * An emitter draws no pixels of its own: every {@link Particle} is a
+ * renderable in its own right and carries its own blend mode. Assigning
+ * `emitter.blendMode` applies the mode to the particles — both the ones
+ * already alive and, through {@link ParticleEmitterSettings.blendMode}, the
+ * ones emitted afterwards. The change is picked up on the emitter's next
+ * `update`, so within the same frame.
+ *
+ * ```js
+ * emitter.blendMode = "overlay";   // live particles AND future ones
+ * ```
+ *
+ * ### Reference space
+ *
+ * A particle stores a position, and
+ * {@link ParticleEmitterSettings.referenceSpace} decides what that position is
+ * measured against. By default it is the emitter, so a moving emitter carries
+ * its whole cloud along — right for a flame or an aura, wrong for anything
+ * emitted and then abandoned. Set it to `"world"` and the position names a
+ * place in the level instead, so the emitter moves away and leaves the
+ * particles behind; that is a trail. Pass a {@link Container} to measure from
+ * something else entirely.
+ *
+ * Changing it at runtime — by assigning the property or through
+ * {@link ParticleEmitter#reset} — re-bases the particles already alive, so the
+ * cloud does not jump; only its subsequent motion changes.
+ *
+ * Two things are worth knowing before reaching for a non-local space. The
+ * emitter is treated as always visible while it has live particles, because
+ * otherwise a trail would vanish the moment the emitter that made it scrolled
+ * off-screen (the particles themselves are still culled individually). And
+ * `clipping` or a `backgroundColor` on the emitter would be applied in the
+ * emitter's own frame rather than the particles', so neither composes with
+ * this.
+ *
+ * ```js
+ * // exhaust that stays where it was emitted
+ * const emitter = new ParticleEmitter(x, y, { referenceSpace: "world" });
+ * ```
  * @category Particles
  */
 export default class ParticleEmitter extends Container {
+    #private;
     /**
      * the current (active) emitter settings (with defaults merged in)
      */
@@ -37,6 +82,19 @@ export default class ParticleEmitter extends Container {
      * @ignore
      */
     _deltaInv: number;
+    /**
+     * Maps an emitter-local spawn point into the reference frame the particles
+     * live in, so a particle is BORN where the emitter is even though its
+     * position is thereafter measured from somewhere else. `undefined` in
+     * local mode, where the two frames coincide and no mapping is needed.
+     *
+     * Held per emitter (not a module scratch) because particles read it during
+     * their own reset, after `addParticles` has computed it. One matrix per
+     * emitter that actually uses a non-local space — emitters are few, unlike
+     * particles, which allocate nothing.
+     * @ignore
+     */
+    _spawnMap: Matrix3d | undefined;
     /**
      * @param x - x position of the particle emitter
      * @param y - y position of the particle emitter
@@ -68,11 +126,21 @@ export default class ParticleEmitter extends Container {
      * app.world.removeChild(emitter);
      */
     constructor(x: number, y: number, settings?: Partial<ParticleEmitterSettings>);
+    reset(settings?: Partial<ParticleEmitterSettings>): void;
     /**
-     * Reset the emitter with particle emitter settings.
-     * @param settings - object with emitter settings. See {@link ParticleEmitterSettings}
+     * What a particle's position is measured against — see
+     * {@link ParticleEmitterSettings.referenceSpace}.
+     *
+     * Assigning this re-bases every particle already alive into the new frame,
+     * so nothing jumps: the cloud stays exactly where it is on screen and only
+     * its subsequent motion differs. Passing it through
+     * {@link ParticleEmitter#reset} does the same.
+     * @default "local"
+     * @example
+     * emitter.referenceSpace = "world";   // start leaving a trail
      */
-    reset(settings?: Partial<ParticleEmitterSettings>): void;
+    get referenceSpace(): "local" | "world" | Container;
+    set referenceSpace(space: "local" | "world" | Container);
     /**
      * returns a random point on the x axis within the bounds of this emitter
      * @returns a random x position within the emitter bounds
@@ -83,6 +151,16 @@ export default class ParticleEmitter extends Container {
      * @returns a random y position within the emitter bounds
      */
     getRandomPointY(): number;
+    /**
+     * Draw the particles in their reference frame rather than the emitter's.
+     *
+     * The correction goes in before `super.draw()` because that is where the
+     * child walk happens; translations and the correction compose, and in
+     * local mode there is no correction and this is the inherited path
+     * untouched.
+     * @ignore
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Parameters<Container["draw"]>[1]): void;
     /** @ignore */
     addParticles(count: number): void;
     /**

package/build/particles/emitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/particles/emitter.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,8BAA8B,CAAC;AAErD,OAAO,kBAAkB,MAAM,6CAA6C,CAAC;AAE7E,OAA+B,EAC9B,KAAK,uBAAuB,EAC5B,MAAM,eAAe,CAAC;AAmCvB;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,SAAS;IACrD;;OAEG;IACH,QAAQ,EAAE,uBAAuB,CAAC;IAElC,cAAc;IACd,OAAO,EAAE,OAAO,CAAC;IAEjB,cAAc;IACd,eAAe,EAAE,MAAM,CAAC;IAExB,cAAc;IACd,cAAc,EAAE,MAAM,CAAC;IAEvB,cAAc;IACd,QAAQ,EAAE,OAAO,CAAC;IAElB,cAAc;IACd,YAAY,EAAE,MAAM,CAAC;IAErB,cAAc;IACd,GAAG,EAAE,MAAM,CAAC;IAEZ,cAAc;IACd,gBAAgB,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAEjD;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAoChD;;;OAGG;IACM,KAAK,CAAC,QAAQ,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAAG,IAAI;IAqCrE;;;OAGG;IACH,eAAe,IAAI,MAAM;IAIzB;;;OAGG;IACH,eAAe,IAAI,MAAM;IAKzB,cAAc;IACd,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAkBjC;;;OAGG;IACH,SAAS,IAAI,OAAO;IAIpB;;;OAGG;IACH,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAQxC;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;;OAGG;IACH,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IASpC;;OAEG;IACM,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IA4EpC;;;OAGG;IACM,OAAO,IAAI,IAAI;CAcxB"}
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/particles/emitter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,OAAO,SAAS,MAAM,8BAA8B,CAAC;AAErD,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AACrE,OAAO,kBAAkB,MAAM,6CAA6C,CAAC;AAC7E,OAAO,KAAK,aAAa,MAAM,kCAAkC,CAAC;AAElE,OAA+B,EAC9B,KAAK,uBAAuB,EAC5B,MAAM,eAAe,CAAC;AAmDvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,SAAS;;IACrD;;OAEG;IACH,QAAQ,EAAE,uBAAuB,CAAC;IAElC,cAAc;IACd,OAAO,EAAE,OAAO,CAAC;IAEjB,cAAc;IACd,eAAe,EAAE,MAAM,CAAC;IAExB,cAAc;IACd,cAAc,EAAE,MAAM,CAAC;IAEvB,cAAc;IACd,QAAQ,EAAE,OAAO,CAAC;IAElB,cAAc;IACd,YAAY,EAAE,MAAM,CAAC;IAErB,cAAc;IACd,GAAG,EAAE,MAAM,CAAC;IAEZ,cAAc;IACd,gBAAgB,EAAE,kBAAkB,GAAG,SAAS,CAAC;IASjD;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;;;;;;OAWG;IACH,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAoCvC,KAAK,CAAC,QAAQ,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAAG,IAAI;IAoDrE;;;;;;;;;;;OAWG;IACH,IAAI,cAAc,IAAI,OAAO,GAAG,OAAO,GAAG,SAAS,CAElD;IAED,IAAI,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,EAQtD;IAqHD;;;OAGG;IACH,eAAe,IAAI,MAAM;IAIzB;;;OAGG;IACH,eAAe,IAAI,MAAM;IAIzB;;;;;;;;OAQG;IACM,IAAI,CACZ,QAAQ,EAAE,cAAc,GAAG,aAAa,EACxC,QAAQ,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,IAAI;IASP,cAAc;IACd,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA2CjC;;;OAGG;IACH,SAAS,IAAI,OAAO;IAIpB;;;OAGG;IACH,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAQxC;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;;OAGG;IACH,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IASpC;;OAEG;IACM,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAiHpC;;;OAGG;IACM,OAAO,IAAI,IAAI;CAmBxB"}

package/build/particles/particle.d.ts

@@ -1,3 +1,4 @@
+import type { Matrix3d } from "../math/matrix3d.ts";
 import { Vector2d } from "../math/vector2d.ts";
 import Renderable from "../renderable/renderable.js";
 import CanvasRenderer from "../video/canvas/canvas_renderer.js";
@@ -8,6 +9,7 @@ import ParticleEmitter from "./emitter.ts";
  * @category Particles
  */
 export default class Particle extends Renderable {
+    #private;
     vel: Vector2d;
     image: HTMLCanvasElement | HTMLImageElement;
     life: number;
@@ -18,7 +20,6 @@ export default class Particle extends Renderable {
     wind: number;
     followTrajectory: boolean;
     onlyInViewport: boolean;
-    accurateBounds: boolean;
     _deltaInv: number;
     _halfW: number;
     _halfH: number;
@@ -28,6 +29,26 @@ export default class Particle extends Renderable {
      * @param emitter - the particle emitter
      */
     constructor(emitter: ParticleEmitter);
+    /**
+     * Whether the bounds need recomputing before anyone reads them.
+     *
+     * A `Renderable` refreshes its bounds eagerly, from a callback fired on
+     * every `pos` assignment. That is the right trade for a scene object, and
+     * the wrong one for a particle: `update()` writes `pos.x` and `pos.y`
+     * separately, so the callback fires TWICE per particle per frame, and both
+     * runs happen before `currentTransform` is rebuilt — deriving bounds from
+     * the previous frame's matrix and then throwing that away. Measured, the
+     * redundant pass was about two thirds of the whole particle update loop.
+     *
+     * So a particle invalidates instead of recomputing, and pays once, on
+     * read, for particles something actually looks at.
+     *
+     * Deliberately not a `#private` field: `updateBounds()` is reached from the
+     * base constructor chain (`Polygon.setVertices`) before a subclass's field
+     * initializers have run, and writing an undeclared private field throws.
+     * @ignore
+     */
+    _boundsDirty: boolean;
     /**
      * @ignore
      */
@@ -39,6 +60,46 @@ export default class Particle extends Renderable {
      * @param dt - time since the last update in milliseconds
      */
     update(dt: number): boolean;
+    /**
+     * `autoTransform` is off (see `onResetEvent`), so the base `preDraw` will
+     * not apply the matrix — append it here instead, unconjugated. Appending
+     * after `super` rather than splicing into it is order-equivalent for a
+     * particle specifically: no flip, no mask, and the anchor is zeroed, so
+     * nothing the base method emits interacts with this.
+     * @ignore
+     */
+    preDraw(renderer: CanvasRenderer | WebGLRenderer): void;
+    /**
+     * `currentTransform` already places the particle, so the frame it
+     * produces is positioned — only the ancestors' contribution is still
+     * missing. The base implementation would add this particle's own `pos` on
+     * top of a matrix that already contains it, counting it twice.
+     * @ignore
+     */
+    /**
+     * Bounds are recomputed here rather than when `pos` moves, so a particle
+     * nothing looks at this frame pays nothing at all.
+     *
+     * `updateBounds()` deliberately keeps its eager contract — a caller that
+     * asks for a recompute, such as {@link Container} aggregating child bounds
+     * under `enableChildBoundsUpdate`, still gets fresh values back.
+     * @ignore
+     */
+    getBounds(): Bounds;
+    updateBounds(absolute?: boolean): any;
+    /**
+     * A particle is positioned within its reference frame, which is not
+     * necessarily its parent — so summing up the ancestor chain, as the base
+     * implementation does, would measure from the wrong place.
+     * @ignore
+     */
+    getAbsolutePosition(): any;
+    /**
+     * With the placement in `currentTransform` and `autoTransform` off, the
+     * base composition would describe a transform this class never applies.
+     * @ignore
+     */
+    getLocalTransform(out: Matrix3d): Matrix3d;
     /**
      * @ignore
      */

package/build/particles/particle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle.d.ts","sourceRoot":"","sources":["../../src/particles/particle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAgB,MAAM,qBAAqB,CAAC;AAG7D,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAErD,OAAO,cAAc,MAAM,oCAAoC,CAAC;AAChE,OAAO,aAAa,MAAM,kCAAkC,CAAC;AAC7D,OAAO,eAAe,MAAM,cAAc,CAAC;AAE3C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,UAAU;IAC/C,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IAEf;;OAEG;gBACS,OAAO,EAAE,eAAe;IAiBpC;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,WAAW,GAAE,OAAe;IAwFnE;;;;;OAKG;IACM,MAAM,CAAC,EAAE,EAAE,MAAM;IA+F1B;;OAEG;IACM,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;CAMtD;AAED,eAAO,MAAM,YAAY,wEAWxB,CAAC"}
+{"version":3,"file":"particle.d.ts","sourceRoot":"","sources":["../../src/particles/particle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAgB,MAAM,qBAAqB,CAAC;AAK7D,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAErD,OAAO,cAAc,MAAM,oCAAoC,CAAC;AAChE,OAAO,aAAa,MAAM,kCAAkC,CAAC;AAC7D,OAAO,eAAe,MAAM,cAAc,CAAC;AAS3C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,UAAU;;IAC/C,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IAEf;;OAEG;gBACS,OAAO,EAAE,eAAe;IAiBpC;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,UAAQ;IAEpB;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,WAAW,GAAE,OAAe;IA2HnE;;;;;OAKG;IACM,MAAM,CAAC,EAAE,EAAE,MAAM;IA0G1B;;;;;;;OAOG;IACM,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;IAOzD;;;;;;OAMG;IACH;;;;;;;;OAQG;IACM,SAAS;IAQT,YAAY,CAAC,QAAQ,UAAO;IAkDrC;;;;;OAKG;IACM,mBAAmB;IAiB5B;;;;OAIG;IACM,iBAAiB,CAAC,GAAG,EAAE,QAAQ;IAIxC;;OAEG;IACM,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;CAMtD;AAED,eAAO,MAAM,YAAY,wEAWxB,CAAC"}

package/build/particles/settings.d.ts

@@ -1,3 +1,4 @@
+import type Container from "../renderable/container.js";
 import type ParticleEmitter from "./emitter.ts";
 /**
  * Configuration shape for {@link ParticleEmitter}.
@@ -129,9 +130,13 @@ export interface ParticleEmitterSettings {
     /**
      * Blend mode applied when rendering particles. If different than "normal",
      * supersedes the `textureAdditive` setting.
+     *
+     * Each particle copies this when it is BORN, so changing it here affects
+     * particles emitted from that point on. To change the mode of particles
+     * already alive as well, assign {@link ParticleEmitter#blendMode} instead —
+     * it updates this setting and every live particle together.
      * @default "normal"
-     * @see {@link CanvasRenderer#setBlendMode}
-     * @see {@link WebGLRenderer#setBlendMode}
+     * @see {@link CanvasRenderer#setBlendMode} for the full list of modes
      */
     blendMode: string;
     /**
@@ -146,6 +151,40 @@ export interface ParticleEmitterSettings {
      * @default false
      */
     floating: boolean;
+    /**
+     * What a particle's position is measured against.
+     *
+     * A particle stores a position, and this decides what that position is
+     * relative to. The difference is whether an effect is *attached* to the
+     * emitter or *emitted and abandoned* by it.
+     *
+     * | value | measured from | use |
+     * | --- | --- | --- |
+     * | `"local"` | the emitter | a flame, an aura, anything welded on |
+     * | `"world"` | the container the emitter sits in | trails, smoke, exhaust, dust |
+     * | a {@link Container} | that container | a moving frame of reference |
+     *
+     * With `"local"` a moving emitter drags its whole cloud along, because a
+     * particle's stored position never named a place in the level — it meant
+     * "this far from my emitter". With `"world"` the position is a place, so
+     * the emitter moves away and leaves the particles behind; only newly
+     * emitted ones appear at the new location. Passing a `Container` measures
+     * from that instead, for the case where the right frame is neither: snow
+     * drifting inside a moving carriage travels with the carriage without
+     * being welded to the vent that emits it.
+     *
+     * `"world"` resolves to the emitter's parent container rather than the
+     * root, so a level that moves carries its own trails with it. Pass the
+     * container explicitly if you want a different one.
+     *
+     * Changing this at runtime re-bases the particles already alive, so
+     * nothing jumps — only their subsequent motion differs.
+     * @default "local"
+     * @example
+     * // exhaust that stays where it was emitted
+     * const emitter = new ParticleEmitter(x, y, { referenceSpace: "world" });
+     */
+    referenceSpace: "local" | "world" | Container;
     /**
      * Maximum number of particles launched each tick (stream mode only).
      * @default 10
@@ -169,12 +208,16 @@ export interface ParticleEmitterSettings {
      */
     framesToSkip: number;
     /**
-     * When `true`, each particle refreshes its bounding box every frame so the
-     * hitbox tracks the visual exactly (useful for debug visualization or
-     * collision queries). When `false` (default), bounds reflect the previous
-     * frame's transform — sufficient for viewport culling and significantly
-     * cheaper at high particle counts.
+     * No longer has any effect, and kept only so existing configurations keep
+     * working.
+     *
+     * It used to trade hitbox accuracy for speed, because bounds were
+     * recomputed eagerly on every position write — twice per particle per
+     * frame, from a transform that had not been rebuilt yet. Particles now
+     * invalidate on write and recompute once on read, so the bounds a reader
+     * gets are always current.
      * @default false
+     * @deprecated since 20.2.0 — bounds are always up to date; remove it
      */
     accurateBounds: boolean;
     /**

package/build/particles/settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/particles/settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,cAAc,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;OAKG;IACH,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAExD;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAE/B;;;;;;;OAOG;IACH,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC1D;AAED;;;GAGG;AACH,QAAA,MAAM,8BAA8B,EAAE,uBAiCrC,CAAC;AAEF,eAAe,8BAA8B,CAAC"}
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/particles/settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,eAAe,MAAM,cAAc,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;OAKG;IACH,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAExD;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,cAAc,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;IAE9C;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAE/B;;;;;;;OAOG;IACH,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC1D;AAED;;;GAGG;AACH,QAAA,MAAM,8BAA8B,EAAE,uBAkCrC,CAAC;AAEF,eAAe,8BAA8B,CAAC"}

package/build/physics/adapter.d.ts

@@ -158,13 +158,13 @@ export interface CollisionResponse {
      */
     pair?: unknown;
     /**
-     * @deprecated Use `depth`. Built-in SAT legacy field; kept on modern
+     * @deprecated since 19.5.0 - Use `depth`. Built-in SAT legacy field; kept on modern
      * handler dispatches for migration. `undefined` under
      * `@melonjs/matter-adapter`.
      */
     overlap?: number;
     /**
-     * @deprecated Use `normal`. Built-in SAT legacy field; flipped per
+     * @deprecated since 19.5.0 - Use `normal`. Built-in SAT legacy field; flipped per
      * receiver so the sign convention aligns with `normal` on the modern
      * dispatch. `undefined` under `@melonjs/matter-adapter`.
      */
@@ -173,7 +173,7 @@ export interface CollisionResponse {
         y: number;
     };
     /**
-     * @deprecated Built-in SAT legacy field, equal to `normal × depth`.
+     * @deprecated since 19.5.0 - Built-in SAT legacy field, equal to `normal × depth`.
      * Flipped per receiver. `undefined` under `@melonjs/matter-adapter`.
      */
     overlapV?: {