melonjs 20.8.0 → 20.9.0

package/build/input/gamepad.d.ts

@@ -71,16 +71,27 @@ export declare const GAMEPAD: {
  * @param button - Button/Axis definition
  * @param button.type - "buttons" or "axes"
  * @param button.code - button or axis code id
- * @param button.threshold - value indicating when the axis should trigger the keycode
+ * @param button.threshold - how far past the deadzone the axis must travel to
+ * trigger the keycode. It is ADDED to {@link input.setGamepadDeadzone}, it does
+ * not replace it, so with the default deadzone of 0.1 a threshold of 0.5 fires
+ * at 0.6 of full deflection. Its SIGN picks the half of the axis to watch:
+ * negative for left/up, positive for right/down, and the two halves are bound
+ * separately. Ignored for `"buttons"`, which take the browser's own pressed
+ * state; the deadzone reaches a button only where a non-standard mapping
+ * routes an axis onto one through its `analog` array.
  * @param keyCode - (See {@link input.KEY})
+ * @throws {Error} if `keyCode` has no action bound to it yet — call
+ * {@link input.bindKey} first.
  * @example
  * // enable the keyboard
  * me.input.bindKey(me.input.KEY.X, "shoot");
  * ...
  * // map the lower face button on the first gamepad to the X key
  * me.input.bindGamepad(0, {type:"buttons", code: me.input.GAMEPAD.BUTTONS.FACE_1}, me.input.KEY.X);
- * // map the left axis value on the first gamepad to the LEFT key
+ * // map the left half of the stick to LEFT, firing at 0.6 of full travel
+ * // (0.1 deadzone + 0.5 threshold), and the right half to RIGHT
  * me.input.bindGamepad(0, {type:"axes", code: me.input.GAMEPAD.AXES.LX, threshold: -0.5}, me.input.KEY.LEFT);
+ * me.input.bindGamepad(0, {type:"axes", code: me.input.GAMEPAD.AXES.LX, threshold: 0.5}, me.input.KEY.RIGHT);
  * @category Input
  */
 export declare function bindGamepad(index: number, button: {
@@ -90,17 +101,33 @@ export declare function bindGamepad(index: number, button: {
 }, keyCode: number): void;
 /**
  * unbind the defined keycode
+ *
+ * Takes the `type` the binding was made with, because a button code and an
+ * axis code are both small integers from different sets and they collide:
+ * `GAMEPAD.AXES.LX` and `GAMEPAD.BUTTONS.FACE_1` are both 0. Without it an
+ * axis could not be unbound at all, and asking for one by its code removed
+ * whatever button happened to share the number.
  * @param index - Gamepad index
  * @param button - (See {@link input.GAMEPAD})
+ * @param type - which table the binding is in, `"buttons"` by default
  * @example
  * me.input.unbindGamepad(0, me.input.GAMEPAD.BUTTONS.FACE_1);
+ * me.input.unbindGamepad(0, me.input.GAMEPAD.AXES.LX, "axes");
  * @category Input
  */
-export declare function unbindGamepad(index: number, button: number): void;
+export declare function unbindGamepad(index: number, button: number, type?: "buttons" | "axes"): void;
 /**
  * Set deadzone for analog gamepad inputs<br>
  * The default deadzone is 0.1 (10%) Analog values less than this will be ignored
+ *
+ * For axes it is the floor that a binding's own `threshold` is added to: one
+ * bound with `threshold: 0.5` under this default fires at 0.6, so raising it
+ * moves every axis binding with it. An ordinary button never consults it at
+ * all, since its pressed state comes from the browser; it reaches a button
+ * only where a non-standard mapping routes an axis onto one through its
+ * `analog` array.
  * @param value - Deadzone value
+ * @see {@link input.bindGamepad}
  * @category Input
  */
 export declare function setGamepadDeadzone(value: number): void;
@@ -135,5 +162,104 @@ export declare function setGamepadDeadzone(value: number): void;
  * });
  */
 export declare const setGamepadMapping: (id: string, mapping: Partial<GamepadMapping>) => void;
+/**
+ * Options for {@link input.vibrateGamepad}.
+ * @category Input
+ */
+export interface GamepadVibration {
+    /** how long the effect runs, milliseconds */
+    duration?: number;
+    /** the heavy, low-frequency motor, `0` to `1` */
+    strongMagnitude?: number;
+    /** the light, high-frequency motor, `0` to `1` */
+    weakMagnitude?: number;
+    /** how long to wait before it starts, milliseconds */
+    startDelay?: number;
+    /** left trigger motor, `0` to `1`. `"trigger-rumble"` only */
+    leftTrigger?: number;
+    /** right trigger motor, `0` to `1`. `"trigger-rumble"` only */
+    rightTrigger?: number;
+    /**
+     * Which effect to play. `"dual-rumble"` is the one every haptic pad
+     * supports; `"trigger-rumble"` drives the motors inside the triggers and
+     * is not widely implemented.
+     */
+    type?: GamepadHapticEffectType;
+}
+/**
+ * Whether the pad at this index can vibrate.
+ *
+ * For deciding what to OFFER — a rumble toggle in an options screen, say.
+ * Nothing needs to call it before {@link input.vibrateGamepad}, which is a
+ * no-op on a pad without motors.
+ * @param index - Gamepad index
+ * @returns true when there is haptic hardware to drive
+ * @category Input
+ */
+export declare function hasGamepadVibration(index: number): boolean;
+/**
+ * Vibrate a gamepad.
+ *
+ * Safe to call blind: with no pad in that slot, no motors, or a browser
+ * without the Gamepad API at all, it resolves `false` and does nothing. That
+ * is the whole error path, so game code never has to branch on support.
+ *
+ * Magnitudes default to FULL, unlike the underlying web API where every
+ * parameter defaults to zero and a bare `playEffect("dual-rumble")` is a
+ * silent no-op. `vibrateGamepad(0)` vibrates.
+ *
+ * A second call preempts the first on the same pad, which is what makes a
+ * rapid series of hits read as a rapid series of hits rather than a queue.
+ * That is for DISTINCT events: a sustained rumble should be one effect with
+ * a long `duration`, not a call per frame, which would spend a promise and a
+ * preempted effect every frame to produce one continuous one.
+ * @param index - Gamepad index
+ * @param options - how hard and how long; see {@link GamepadVibration}
+ * @returns whether the effect ran to completion. `false` covers unsupported,
+ * preempted by a later call, and rejected by the device alike — a rumble is
+ * feedback, and nothing sensible branches on which of those happened.
+ * @example
+ * // a short, sharp knock
+ * input.vibrateGamepad(0, { duration: 90, strongMagnitude: 0.4, weakMagnitude: 0.8 });
+ * // and a long heavy one for something big
+ * input.vibrateGamepad(0, { duration: 600, strongMagnitude: 1, weakMagnitude: 0.5 });
+ * @category Input
+ */
+export declare function vibrateGamepad(index: number, options?: GamepadVibration): Promise<boolean>;
+/**
+ * Stop whatever a gamepad is currently playing.
+ *
+ * For cutting a long effect short — the player pausing, or a run ending under
+ * a rumble that would otherwise outlive it. A no-op where there is nothing to
+ * stop.
+ * @param index - Gamepad index
+ * @category Input
+ */
+export declare function stopGamepadVibration(index: number): void;
+/**
+ * The index of the pad the player is actually using.
+ *
+ * Slots are handed out in plug order, so index 0 is a guess rather than an
+ * answer: a wheel, a spare pad or a keyboard-shaped device left plugged in
+ * can hold slot 0 for a whole session while the player presses buttons on
+ * slot 1. Nothing in the browser reports which is "the" controller, and the
+ * one thing that identifies it is use.
+ *
+ * So this reports the last pad to produce a BOUND input, falling back to the
+ * first connected one before anything has been pressed, and to -1 when there
+ * is no pad at all. Pass it wherever an index is wanted —
+ * {@link input.vibrateGamepad} most of all, since rumbling the wrong pad is
+ * both useless and impossible to notice in testing.
+ *
+ * It follows bound inputs only, which is what makes it an answer about the
+ * player rather than about electrical noise: a resting stick on a worn pad
+ * reports movement for ever, and would otherwise claim to be the active one.
+ * @returns the gamepad index, or -1 when no gamepad is connected
+ * @example
+ * // rumble whichever pad the player is holding
+ * input.vibrateGamepad(input.activeGamepad(), { duration: 120 });
+ * @category Input
+ */
+export declare function activeGamepad(): number;
 export {};
 //# sourceMappingURL=gamepad.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AAWA,UAAU,cAAc;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtE;AAsVD;;GAEG;AACH,eAAO,MAAM,OAAO;IACnB;;;;;;;;OAQG;;;;;;;;;;;IAYH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACtE,OAAO,EAAE,MAAM,GACb,IAAI,CAuDN;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,KAC5B,IAAiB,CAAC"}
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AAWA,UAAU,cAAc;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtE;AAoSD;;GAEG;AACH,eAAO,MAAM,OAAO;IACnB;;;;;;;;OAQG;;;;;;;;;;;IAYH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACtE,OAAO,EAAE,MAAM,GACb,IAAI,CAuDN;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,SAAS,GAAG,MAAkB,GAClC,IAAI,CAQN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,KAC5B,IAAiB,CAAC;AAEvB;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,IAAI,CAAC,EAAE,uBAAuB,CAAC;CAC/B;AAsDD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,gBAAqB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAelB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAOxD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAkBtC"}

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

@@ -33,7 +33,7 @@
  */
 export default class GLTFModel extends Container {
     /**
-     * @param {import("../../loader/loader.js").GLTFData} data - the parsed glTF descriptor, as returned by {@link loader.getGLTF}
+     * @param {import("../../loader/parsers/gltf.js").GLTFData} data - the parsed glTF descriptor, as returned by {@link loader.getGLTF}
      * @param {object} [options]
      * @param {number} [options.scale=1] - pixels per glTF unit (uniform scene scale)
      * @param {boolean} [options.rightHanded=true] - glTF Y-up → engine Y-down via a rotation (no mirror)
@@ -42,14 +42,14 @@ export default class GLTFModel extends Container {
      * @param {number} [options.shadowGroundY] - world Y of the floor those shadows land on
      * @param {number} [options.shadowOpacity=0.45] - opacity of those shadows before any height fade
      * @param {number} [options.shadowScale=1] - size multiplier for those shadows (see {@link Mesh#shadowScale})
-     * @param {number} [options.shadowOffset=0] - how far to slide them along their direction, in multiples of each blob's own radius; needs `shadowGroundY` (see {@link Mesh#shadowOffset})
+     * @param {number} [options.shadowOffset=0] - how far to slide them along their direction, in multiples of each blob's own radius; needs `shadowGroundY` (see {@link Mesh#shadowOffset}). `shadowGroundPoint` is deliberately not a scene option: one floor point shared by every part would stack their blobs on a single spot
      * @param {number} [options.shadowStretch=1] - how much longer they are along that direction, clamped to 3
      * @param {number} [options.shadowDirectionX=0] - x of the ground direction they are cast along
      * @param {number} [options.shadowDirectionZ=0] - z of the ground direction they are cast along
      * @param {number[]|Vector3d} [options.shadowGroundNormal] - the UP normal of the floor those shadows land on; needs `shadowGroundY` (see {@link Mesh#shadowGroundNormal})
      * @param {Light3d} [options.shadowLight] - a {@link Light3d} to take that direction from instead
      */
-    constructor(data: import("../../loader/loader.js").GLTFData, options?: {
+    constructor(data: import("../../loader/parsers/gltf.js").GLTFData, options?: {
         scale?: number | undefined;
         rightHanded?: boolean | undefined;
         lit?: boolean | undefined;
@@ -61,7 +61,7 @@ export default class GLTFModel extends Container {
         shadowStretch?: number | undefined;
         shadowDirectionX?: number | undefined;
         shadowDirectionZ?: number | undefined;
-        shadowGroundNormal?: number[] | Vector3d;
+        shadowGroundNormal?: number[] | Vector3d | undefined;
         shadowLight?: any;
     });
     /**
@@ -138,4 +138,5 @@ export default class GLTFModel extends Container {
 }
 import Container from "../../renderable/container.js";
 import type { AnimationOptionsInput } from "../../renderable/animation.ts";
+import type { Vector3d } from "../../math/vector3d.ts";
 //# sourceMappingURL=GLTFModel.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GLTFModel.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFModel.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,OAAO,wBAAwB,EAAE,QAAQ,YAEjD;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;QACH,gBAAgB;QACjB,aAAa;QACb,aAAa;QACb,WAAW;QACX,YAAY;QACZ,aAAa;QACb,gBAAgB;QAChB,gBAAgB;QACL,kBAAkB,GAA9C,MAAM,EAAE,GAAC,QAAQ;QACC,WAAW;KACvC,EA8RA;IAjRA;;;OAGG;IACH,eAAoD;IA0CpD;;;;OAIG;IACH,YAA8B;IAC9B;;;;OAIG;IACH,YAA8B;IAC9B;;;;OAIG;IACH,gBAAqB;IACrB;;;;OAIG;IACH,gBAAqB;IACrB;;;;;;;OAOG;IACH,WAAgB;IAahB;;;;;;;;;;;;OAYG;IACH,gBAAkC;IAClC;;;OAGG;IACH,iBAAwD;IAExD;;;OAGG;IACH,iBAAyD;IA6FzD;;;;OAIG;IACH,SAAc;IAiBd;;;;OAIG;IACH,gBAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IAIH;;;OAGG;IACH;;;;MAAsD;IACtD;;;;OAIG;IACH,oGAA0B;IAC1B;;;;OAIG;IACH,mBAAsB;IAOvB;;;;;OAKG;IACH,qBAJa,MAAM,EAAE,CAMpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BAXW,MAAM,YACN,qBAAqB,iBACrB,OAAO,GACL,SAAS,CAgErB;IAED;;;;;;;;;;;;;OAaG;IACH,YATW,MAAM,YACN,qBAAqB,GACnB,SAAS,CAarB;IAED;;;;OAIG;IACH,SAFa,SAAS,CAKrB;IAED;;;;;;OAMG;IACH,QAFa,SAAS,CAarB;IAkDD;;;;;;OAMG;IACH;;;;;;;;;;;;;;;OAeG;IACH,WAFa,OAAO,CAInB;IAkDD;;;OAGG;IACH,cAOC;IAED;;;;;;;;;;;;;;OAcG;IACH,eAJa,MAAM,EAAE,CA4BpB;IAED;;;;;OAKG;IACH,4DAqBC;IAED;;;;;;;OAOG;IACH,2CAJa,MAAM,EAAE,CAyCpB;IAED;;;;;;;;OAQG;IACH,+CAYC;CACD;sBA7yBqB,+BAA+B;2CASX,+BAA+B"}
+{"version":3,"file":"GLTFModel.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFModel.js"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,OAAO,8BAA8B,EAAE,QAAQ,YAEvD;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;QACH,gBAAgB;QACjB,aAAa;QACb,aAAa;QACb,WAAW;QACX,YAAY;QACZ,aAAa;QACb,gBAAgB;QAChB,gBAAgB;QACL,kBAAkB;QAC5B,WAAW;KACvC,EAyRA;IA5QA;;;OAGG;IACH,eAAoD;IA0CpD;;;;OAIG;IACH,YAA8B;IAC9B;;;;OAIG;IACH,YAA8B;IAC9B;;;;OAIG;IACH,gBAAqB;IACrB;;;;OAIG;IACH,gBAAqB;IACrB;;;;;;;OAOG;IACH,WAAgB;IAahB;;;;;;;;;;;;OAYG;IACH,gBAAkC;IAClC;;;OAGG;IACH,iBAAwD;IAExD;;;OAGG;IACH,iBAAyD;IAwFzD;;;;OAIG;IACH,SAAc;IAiBd;;;;OAIG;IACH,gBAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IAIH;;;OAGG;IACH;;;;MAAsD;IACtD;;;;OAIG;IACH,oGAA0B;IAC1B;;;;OAIG;IACH,mBAAsB;IAOvB;;;;;OAKG;IACH,qBAJa,MAAM,EAAE,CAMpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BAXW,MAAM,YACN,qBAAqB,iBACrB,OAAO,GACL,SAAS,CAgErB;IAED;;;;;;;;;;;;;OAaG;IACH,YATW,MAAM,YACN,qBAAqB,GACnB,SAAS,CAarB;IAED;;;;OAIG;IACH,SAFa,SAAS,CAKrB;IAED;;;;;;OAMG;IACH,QAFa,SAAS,CAarB;IAkDD;;;;;;OAMG;IACH;;;;;;;;;;;;;;;OAeG;IACH,WAFa,OAAO,CAInB;IAkDD;;;OAGG;IACH,cAOC;IAED;;;;;;;;;;;;;;OAcG;IACH,eAJa,MAAM,EAAE,CA4BpB;IAED;;;;;OAKG;IACH,4DAqBC;IAED;;;;;;;OAOG;IACH,2CAJa,MAAM,EAAE,CAyCpB;IAED;;;;;;;;OAQG;IACH,+CAYC;CACD;sBAzyBqB,+BAA+B;2CASX,+BAA+B;8BAC9C,wBAAwB"}

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":"AA6aA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oCALW,aAAa,aACb,MAAM,QAyChB;AA/dD;;;;;;GAMG;AACH;;;;;;;;;GASG;AACH;IAwCC;;;;;;;;;;;;;OAaG;IACH,oBAJU,aAAa,CAAC,MAAM,CAAC,CAmB5B;IApEH;;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;IAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,iBAtDW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;QAQlB,gBAAgB;QAMjB,aAAa;QAIb,aAAa;QACb,WAAW;QACX,YAAY;QACZ,aAAa;QACb,gBAAgB;QAChB,gBAAgB;QACL,kBAAkB;QAC5B,WAAW;KACrC,QAoMF;IAED;;;;;;;;;;;;;OAaG;IACH,sBAPW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAsEhB;IAED;;;;;;OAMG;IACH,gBAAY;CACZ;0BAvayB,oCAAoC;2BAOpC,+BAA+B;8BAG9B,wBAAwB;wBAd3B,2BAA2B"}
+{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AA0aA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oCALW,aAAa,aACb,MAAM,QAyChB;AA5dD;;;;;;GAMG;AACH;;;;;;;;;GASG;AACH;IAwCC;;;;;;;;;;;;;OAaG;IACH,oBAJU,aAAa,CAAC,MAAM,CAAC,CAyB5B;IA1EH;;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;IAuCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,iBAtDW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;QAQlB,gBAAgB;QAMjB,aAAa;QAIb,aAAa;QACb,WAAW;QACX,YAAY;QACZ,aAAa;QACb,gBAAgB;QAChB,gBAAgB;QACL,kBAAkB;QAC5B,WAAW;KACrC,QA2LF;IAED;;;;;;;;;;;;;OAaG;IACH,sBAPW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAsEhB;IAED;;;;;;OAMG;IACH,gBAAY;CACZ;0BApayB,oCAAoC;2BAOpC,+BAA+B;8BAG9B,wBAAwB;wBAd3B,2BAA2B"}

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

@@ -51,9 +51,10 @@ export function registerTiledObjectFactory(type: string, factory: Function): voi
  * registerTiledObjectClass("Enemy", Enemy);
  *
  * @example
- * // equivalent to pool.register (which auto-registers for Tiled too)
+ * // the older spelling: `pool.register` registers a Tiled factory as a side
+ * // effect, and additionally makes the class RECYCLABLE, which this registry
+ * // alone does not do
  * pool.register("CoinEntity", CoinEntity, true);
- * // CoinEntity is now available both in the pool AND as a Tiled object factory
  */
 export function registerTiledObjectClass(name: string, Constructor: Function): void;
 //# sourceMappingURL=TMXObjectFactory.d.ts.map

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":"AA8BA;;;;;;;GAOG;AACH,0CALW,MAAM,GACJ,OAAO,GAAC,MAAM,EAAE,CAiB5B;AAED;;;;;;;;;;;;;GAaG;AACH,2CALW,MAAM,GACJ,MAAM,CAuBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iDApBW,MAAM,2BAgChB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAZW,MAAM,+BA6BhB;AASD;;;;;;;;GAQG;AACH,gDALW,MAAM,+BAYhB;AAqCD;;;;;;;;GAQG;AACH,0CANW,MAAM,OACN,UAAU,GACR,UAAU,CAsBtB"}
+{"version":3,"file":"TMXObjectFactory.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXObjectFactory.js"],"names":[],"mappings":"AA2CA;;;;;;;GAOG;AACH,0CALW,MAAM,GACJ,OAAO,GAAC,MAAM,EAAE,CAiB5B;AAED;;;;;;;;;;;;;GAaG;AACH,2CALW,MAAM,GACJ,MAAM,CAuBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iDApBW,MAAM,2BAgChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+CAbW,MAAM,+BA0ChB;AAsBD;;;;;;;;GAQG;AACH,gDALW,MAAM,+BAWhB;AAoED;;;;;;;;GAQG;AACH,0CANW,MAAM,OACN,UAAU,GACR,UAAU,CAsBtB"}

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

@@ -1 +1 @@
-{"version":3,"file":"TMXTileMap.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTileMap.js"],"names":[],"mappings":"AAkJA;;;;GAIG;AACH;IACC;;;;;;;;;;;OAWG;IACH,oBAJU,aAAa,CAAC,MAAM,CAAC,CAIsC;IAErE;;;;;;;;OAQG;IACH,qBARW,MAAM,QACN,MAAM,EAiKhB;IAzJA;;;;OAIG;IACH,aAAgB;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,QAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,MAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,WAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,YAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,UAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,aAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,SAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,cAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,OAFU,MAAM,CAEO;IAGvB,6CAAoB;IAInB,cAAgB;IAIhB,oBAAsB;IAIvB,kBAA8C;IAG9C,iCAAmD;IAGnD,sBAAwC;IACxC,iBAAmC;IACnC,kBAAqC;IAGrC,eAAoD;IAGpD,cAA8B;IAC9B,eAAgC;IAGhC,qBAA2C;IAwB3C,qBAAwB;IAGzB;;;OAGG;IACH,eAFa,WAAW,CAUvB;IAHC,0LAAuC;IAKzC;;;OAGG;IACH,aAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,gCA2DC;IAED;;;;;;;;;;;OAWG;IACH,iBATW,SAAS,YACT,OAAO,sBACP,OAAO,QAgFjB;IAED;;;;;;;;;OASG;IACH,qBAJW,OAAO,GAEL,UAAU,EAAE,CA4GxB;IAED;;;OAGG;IACH,aAFa,QAAQ,EAAE,CAMtB;IAED;;OAEG;IACH,gBAKC;CACD;4BAvnB2B,sBAAsB;4BAIzB,yBAAyB;6BAEtB,2BAA2B;sBAhBjC,+BAA+B;4BAe1B,gCAAgC;qBARtC,eAAe"}
+{"version":3,"file":"TMXTileMap.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTileMap.js"],"names":[],"mappings":"AAiJA;;;;GAIG;AACH;IACC;;;;;;;;;;;OAWG;IACH,oBAJU,aAAa,CAAC,MAAM,CAAC,CAIsC;IAErE;;;;;;;;OAQG;IACH,qBARW,MAAM,QACN,MAAM,EAiKhB;IAzJA;;;;OAIG;IACH,aAAgB;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,QAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,MAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,WAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,YAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,UAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,aAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,SAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,cAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,OAFU,MAAM,CAEO;IAGvB,6CAAoB;IAInB,cAAgB;IAIhB,oBAAsB;IAIvB,kBAA8C;IAG9C,iCAAmD;IAGnD,sBAAwC;IACxC,iBAAmC;IACnC,kBAAqC;IAGrC,eAAoD;IAGpD,cAA8B;IAC9B,eAAgC;IAGhC,qBAA2C;IAwB3C,qBAAwB;IAGzB;;;OAGG;IACH,eAFa,WAAW,CAUvB;IAHC,0LAAuC;IAKzC;;;OAGG;IACH,aAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,gCA2DC;IAED;;;;;;;;;;;OAWG;IACH,iBATW,SAAS,YACT,OAAO,sBACP,OAAO,QAgFjB;IAED;;;;;;;;;OASG;IACH,qBAJW,OAAO,GAEL,UAAU,EAAE,CA4GxB;IAED;;;OAGG;IACH,aAFa,QAAQ,EAAE,CAMtB;IAED;;OAEG;IACH,gBAKC;CACD;4BAtnB2B,sBAAsB;4BAIzB,yBAAyB;6BAEtB,2BAA2B;sBAhBjC,+BAA+B;4BAe1B,gCAAgC;qBARtC,eAAe"}

package/build/level/tiled/renderer/TMXObliqueRenderer.d.ts

@@ -1,6 +1,7 @@
 /**
  * additional import for TypeScript
  * @import {Bounds} from "../../../physics/bounds.ts";
+ * @import TMXTileMap from "../TMXTileMap.js";
  */
 /**
  * an Oblique Map Renderer (Tiled 1.12+)
@@ -9,10 +10,6 @@
  * @category Tilemap
  */
 export default class TMXObliqueRenderer extends TMXOrthogonalRenderer {
-    /**
-     * @param {TMXTileMap} map - the TMX map
-     */
-    constructor(map: TMXTileMap);
     /**
      * horizontal pixel offset per tile row
      * @type {number}

package/build/level/tiled/renderer/TMXObliqueRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXObliqueRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXObliqueRenderer.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;;;;;GAKG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAoCpB;IA/BA;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEsD;IAEtE;;;OAGG;IACH,QAFU,MAAM,CAEoD;IAEpE;;;;;OAKG;IACH,MAJU,MAAM,CAIyB;CA6M1C;kCA9PiC,4BAA4B"}
+{"version":3,"file":"TMXObliqueRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXObliqueRenderer.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;;;;;GAKG;AACH;IAOE;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEsD;IAEtE;;;OAGG;IACH,QAFU,MAAM,CAEoD;IAEpE;;;;;OAKG;IACH,MAJU,MAAM,CAIyB;CA6M1C;kCA/PiC,4BAA4B"}

package/build/loader/cache.d.ts

@@ -1,3 +1,219 @@
+
+/**
+ * return the specified TMX/TSX object
+ * @param {string} elt - name of the tmx/tsx element ("map1");
+ * @returns {object} requested element or null if not found
+ * @category Assets
+ */
+export function getTMX(elt: string): object;
+/**
+ * return the specified Binary object
+ * @param {string} elt - name of the binary object ("ymTrack");
+ * @returns {object} requested element or null if not found
+ * @category Assets
+ */
+export function getBinary(elt: string): object;
+/**
+ * return the specified Image Object
+ * @param {string} image - name of the Image element ("tileset-platformer");
+ * @returns {HTMLImageElement|CompressedImage|null} requested element or null if not found
+ * @category Assets
+ */
+export function getImage(image: string): HTMLImageElement | CompressedImage | null;
+/**
+ * return the specified JSON Object
+ * @param {string} elt - name of the json file
+ * @returns {JSON}
+ * @category Assets
+ */
+export function getJSON(elt: string): JSON;
+/**
+ * return the specified OBJ model data
+ * @param {string} elt - name of the OBJ file (as specified in the preload list)
+ * @returns {object} parsed OBJ data with `vertices` (Float32Array), `uvs` (Float32Array), `indices` (Uint16Array), and `vertexCount` (number), or null if not found
+ * @category Assets
+ * @example
+ * // 1. preload the OBJ model and its texture
+ * me.loader.preload([
+ *     { name: "cube", type: "obj", src: "models/cube.obj" },
+ *     { name: "cube", type: "image", src: "models/cube_texture.png" },
+ * ], () => {
+ *     // 2. create a Mesh using the preloaded model name
+ *     const mesh = new me.Mesh(400, 300, {
+ *         model: "cube",        // references the preloaded OBJ
+ *         texture: "cube",      // references the preloaded image
+ *         width: 200,
+ *         height: 200,
+ *     });
+ *     me.game.world.addChild(mesh);
+ *
+ *     // 3. or access the raw parsed data directly
+ *     const data = me.loader.getOBJ("cube");
+ *     // data.vertices — Float32Array of x,y,z positions
+ *     // data.uvs — Float32Array of u,v texture coordinates
+ *     // data.indices — Uint16Array of triangle vertex indices
+ *     // data.vertexCount — number of unique vertices
+ *     // data.groups — usemtl material groups ({materialName, start, count} index ranges)
+ * });
+ */
+export function getOBJ(elt: string): object;
+/**
+ * return the parsed glTF/GLB scene descriptor for the given asset name.
+ *
+ * The descriptor is `{ nodes, cameras, lights, bounds, graph, animations }`:
+ * - `nodes` — one entry per mesh primitive, each carrying its accumulated
+ *   `world` transform (16 floats, column-major), `vertices`, `normals`,
+ *   `uvs`, `indices`, `vertexCount`, a decoded baseColor `image` (or `null`),
+ *   and a `doubleSided` flag.
+ * - `cameras` — glTF cameras, each with its `world` transform + perspective
+ *   parameters.
+ * - `lights` — parsed `KHR_lights_punctual` lights (`type`, `color`,
+ *   `intensity`, `range`, spot cone angles, world-space
+ *   `direction`/`position`, `name`); empty without the extension. The
+ *   level director instantiates directional, point and spot lights
+ *   automatically (see {@link level.load} options).
+ * - `bounds` — world-space `{ min, max }` (glTF units), handy for framing.
+ *
+ * Most code never needs this: a preloaded glTF/GLB auto-registers with the
+ * {@link level} director, so the whole scene loads into a container in one
+ * call via `me.level.load(name)` — exactly like a Tiled map. Reach for
+ * `getGLTF` only when you want to inspect the raw descriptor (e.g. to frame
+ * a `Camera3d` from the embedded camera).
+ * @param {string} elt - name of the glTF/GLB file (as specified in the preload list)
+ * @returns {GLTFData|null} the parsed scene descriptor, or `null` if not found
+ * @category Assets
+ * @example
+ * me.loader.preload(
+ *     [{ name: "diorama", type: "glb", src: "scenes/diorama.glb" }],
+ *     () => {
+ *         // load the whole scene into the world (view under a Camera3d)
+ *         me.level.load("diorama", { scale: 32 });
+ *
+ *         // ...or inspect the raw descriptor for custom framing
+ *         const scene = me.loader.getGLTF("diorama");
+ *         const { min, max } = scene.bounds;
+ *     },
+ * );
+ */
+export function getGLTF(elt: string): GLTFData | null;
+/**
+ * Return the precompiled `ShaderEffect` for the given "shader" asset —
+ * compiled once during preloading, ready to assign to a renderable or
+ * camera `shader` property.
+ *
+ * **This returns a SHARED instance**: the *same* `ShaderEffect` object on
+ * every call, owned by the loader (its `shared` flag is `true`). That means:
+ * - it is safe to assign to any number of renderables — none of their
+ *   cleanup paths will auto-destroy it, only {@link loader.unload} /
+ *   {@link loader.unloadAll} free it (and its GL program);
+ * - all of them share ONE set of uniform values — `setUniform` on it
+ *   affects every renderable using the shader.
+ *
+ * When a renderable needs its **own** uniform values, make a private,
+ * caller-owned copy with `ShaderEffect.clone()` — the clone's `shared` flag
+ * is reset to `false`, so it is auto-destroyed with the renderable it is
+ * assigned to, like any hand-constructed effect.
+ *
+ * A shader asset declared as a **complete program** — a
+ * `{vertex, fragment}` GLSL pair and/or a full `wgsl` module (see the
+ * example) — compiles into a raw {@link GLShader} instead, carrying one
+ * realization per GPU backend (`isWebGL` / `isWebGPU`): the type the
+ * hosted paths take directly (a `Mesh` custom shader,
+ * `renderer.customShader`, a custom batcher). Same shared-instance
+ * semantics, and `GLShader.clone()` likewise yields a caller-owned copy.
+ *
+ * Degradation is never fatal: a fragment-body asset without a body in the
+ * active renderer's language (or on Canvas) is an inert `ShaderEffect`
+ * stub, and a complete-program asset without a realization for the active
+ * backend is an inert `GLShader` — assigning either just keeps the
+ * built-in rendering. Note that shader assets require an initialized
+ * Application (`await app.init()`) — an inherent precondition of the
+ * preload flow, since the loading screen itself needs the renderer.
+ * @param {string} elt - name of the shader asset (as specified in the preload list)
+ * @returns {ShaderEffect|GLShader|null} the shared, precompiled shader, or `null` if not found
+ * @category Assets
+ * @example
+ * me.loader.preload([
+ *     // from a file (or data: URI)
+ *     { name: "waterRipple", type: "shader", src: "shaders/waterRipple.frag" },
+ *     // or inline GLSL via the `data` field
+ *     { name: "flash", type: "shader", data: `
+ *         uniform float uIntensity;
+ *         vec4 apply(vec4 color, vec2 uv) { return mix(color, vec4(1.0), uIntensity); }
+ *     ` },
+ *     // or a complete program — a {vertex, fragment} GLSL pair and/or a
+ *     // full WGSL module → one GLShader carrying both realizations; the
+ *     // active renderer hosts the one it speaks
+ *     { name: "toonMesh", type: "shader", src: {
+ *         vertex: "shaders/toon.vert",
+ *         fragment: "shaders/toon.frag",
+ *         wgsl: "shaders/toon.wgsl",
+ *     } },
+ * ], () => {
+ *     // one shared program — same uniform state for every user
+ *     mySprite.addPostEffect(me.loader.getShader("waterRipple"));
+ *     // private copy with its own uniforms (caller-owned, shared = false)
+ *     boss.addPostEffect(me.loader.getShader("flash").clone());
+ *     // a complete program hosts on a mesh, replacing the built-in shading
+ *     myMesh.addPostEffect(me.loader.getShader("toonMesh"));
+ * });
+ */
+export function getShader(elt: string): ShaderEffect | GLShader | null;
+/**
+ * return the specified MTL material data
+ * @param {string} elt - name of the MTL file (as specified in the preload list)
+ * @returns {object} map of material names to properties (`Kd`, `d`, `map_Kd`), or null if not found
+ * @category Assets
+ * @example
+ * // 1. preload OBJ + MTL + texture
+ * me.loader.preload([
+ *     { name: "fox", type: "obj", src: "models/fox.obj" },
+ *     { name: "fox", type: "mtl", src: "models/fox.mtl" },
+ *     { name: "colormap", type: "image", src: "models/colormap.png" },
+ * ], () => {
+ *     // 2. create a Mesh with material — texture, tint, opacity auto-applied
+ *     const mesh = new me.Mesh(400, 300, {
+ *         model: "fox",
+ *         material: "fox",
+ *         texture: "colormap",
+ *         width: 200,
+ *         height: 200,
+ *     });
+ *
+ *     // 3. or access the raw material data directly
+ *     const materials = me.loader.getMTL("fox");
+ *     // materials["colormap"].Kd — [r, g, b] diffuse color (0-1 range)
+ *     // materials["colormap"].d — opacity (0-1)
+ *     // materials["colormap"].Ke — [r, g, b] emissive color (glow, applied as Mesh.emissive)
+ *     // materials["colormap"].map_Kd — resolved texture URL
+ * });
+ */
+export function getMTL(elt: string): object;
+/**
+ * return the specified Video Object
+ * @param {string} elt - name of the video file
+ * @returns {HTMLVideoElement}
+ * @category Assets
+ */
+export function getVideo(elt: string): HTMLVideoElement;
+/**
+ * return the specified FontFace Object
+ * @param {string} elt - name of the font file
+ * @returns {FontFace}
+ * @category Assets
+ */
+export function getFont(elt: string): FontFace;
+/**
+ * additional imports for TypeScript
+ *
+ * Type-only, so they add no runtime edge and this module stays importable
+ * from anywhere. Without them the unions below silently degrade to `any` in
+ * the generated declarations, which `tsc` does not report.
+ * @import {CompressedImage} from "./parsers/compressed_textures/compressed_image.js";
+ * @import {GLTFData} from "./parsers/gltf.js";
+ * @import GLShader from "../video/webgl/glshader.js";
+ * @import ShaderEffect from "../video/effects/shadereffect.js";
+ */
 /**
  * where all preloaded content is cached
  */
@@ -11,4 +227,8 @@ export const objList: {};
 export const mtlList: {};
 export const gltfList: {};
 export const shaderList: {};
+import type { CompressedImage } from "./parsers/compressed_textures/compressed_image.js";
+import type { GLTFData } from "./parsers/gltf.js";
+import type ShaderEffect from "../video/effects/shadereffect.js";
+import type GLShader from "../video/webgl/glshader.js";
 //# sourceMappingURL=cache.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/loader/cache.js"],"names":[],"mappings":"AAAA;;GAEG;AAGH,yBAA0B;AAG1B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAG3B,2BAA4B;AAG5B,0BAA2B;AAG3B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAK3B,4BAA6B"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/loader/cache.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;GAUG;AACH,+BANW,MAAM,QACN,MAAM,GACJ,OAAO,CAOnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kCANW,MAAM,QACN,MAAM,GACJ,OAAO,CAWnB;AAED;;;;;;;;;GASG;AACH,iCALW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAeD;;;;;GAKG;AACH,4BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;GAKG;AACH,+BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;GAKG;AACH,gCAJW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAWjD;AAED;;;;;GAKG;AACH,6BAJW,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,+BA7BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CAkCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;GAKG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;GAKG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AAlbD;;;;;;;;;;GAUG;AAEH;;GAEG;AAGH,yBAA0B;AAG1B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAG3B,2BAA4B;AAG5B,0BAA2B;AAG3B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAK3B,4BAA6B;AAyB7B;;;;;;;;;;GAUG;AACH,2BAJU,SAAS,MAAM,EAAE,CAIyC;qCA5ElC,mDAAmD;8BAC1D,mBAAmB;8BAEjB,kCAAkC;0BADtC,4BAA4B"}